package member

import (
	"encoding/json"
	"git.loafle.net/overflow/overflow_proxy_service/proxy"
	"log"
	"git.loafle.net/overflow/overflow_proxy_service/proxy/apikey"
	"git.loafle.net/overflow/overflow_proxy_service/proxy/keystore"
	"git.loafle.net/overflow/encryption_go"
)

type Member struct {
	Id             json.Number `json:"id,Number,omitempty"`
	Email          string      `json:"email"`
	PwSalt         string      `json:"pwSalt"`
	Digest         string      `json:"digest"`
	Name           string      `json:"name"`
	Company        string      `json:"company"`
	Phone          string      `json:"phone"`
	AuthorizedDate json.Number `json:"authorizedDate,Number"`
}

type MemberService struct {
	Param *Member 	`json:"param"`
}

var TARGET_DAO = "member"

func NewMember() *Member {
	m := Member{}
	return &m
}
func NewMemberService() *MemberService {
	ms := &MemberService{}
	ms.Param = NewMember()
	return ms
}

func (m *MemberService) getMemberMap() map[string]string {
	memMap := make(map[string]string)

	str, err := json.Marshal(m.Param)

	if err != nil {
		log.Fatal("Json Marshal Error: ", err)
	}

	memMap["com.loafle.overflow.member.model.Member"] = string(str)

	return memMap
}

func (m *MemberService) Login() string {

	result := m.ReadByEmail()
	if result == "" {
		return "login reject"
	}
	temp := Member{}
	err := json.Unmarshal([]byte(result), &temp)
	if err != nil {
		return err.Error()
	}
	if temp.AuthorizedDate == "" {
		return "Not authenticated."
	}

	b := encryption.Check(m.Param.PwSalt, temp.PwSalt, temp.Digest)
	if !b {
		return "login reject"
	}

	return "login success"
}

func (m *MemberService) Regist() string {
	log.Println("Call Regist", m.Param.Email, m.Param.PwSalt)

	pwSalt, digest, err := encryption.Encrypt(m.Param.PwSalt)
	if err != nil {
		log.Fatal("encryption Encrypt Error: ", err)
	}

	m.Param.PwSalt = pwSalt
	m.Param.Digest = digest
	memMap := m.getMemberMap()

	re := proxy.InvokeDB(TARGET_DAO, "create", memMap)

	return re
}

func (m *MemberService) ReadByEmail() string {
	log.Println("Call ReadByEmail", m.Param.Email)
	memMap := m.getMemberMap()
	re := proxy.InvokeDB(TARGET_DAO, "findByEmail", memMap)
	return re
}

func (m *MemberService) Read() string {
	log.Println("Call Read", m.Param.Email)
	// Todo Call DB Gateway
	m.Param.Digest = "qwer5795"
	//memMap := m.getMemberMap()
	mm := make(map[string]string)
	mm["id"] = string(m.Param.Id)
	log.Println("Read Member", m)
	re := proxy.InvokeDB(TARGET_DAO, "find", mm)

	return re
}

func (m *MemberService) Modify() string {
	log.Println("Call Modify", m.Param.Email, "::", m.Param.PwSalt)
	// Todo Call DB Gateway
	m.Param.Digest = "read"
	memMap := m.getMemberMap()

	re := proxy.InvokeDB(TARGET_DAO, "update", memMap)

	return re
}

func (m *MemberService) Remove() string {
	log.Println("Call Remove", m.Param.Email)
	// Todo Call DB Gateway
	//m.Digest = "read"
	memMap := m.getMemberMap()

	re := proxy.InvokeDB(TARGET_DAO, "delete", memMap)

	return re
}

func (m *MemberService) GetModel() (interface{}) {
	return m.Param
}
func (m *MemberService) EmailConfirm() string {

	ks := keystore.NewKeyStoreSerivce()

	key, err := ks.CreateKey()
	if err != nil {
		return ""
	}

	log.Println(key)

	ak := apikey.NewApiKeyService()
	out, err := ak.SaveApikey(nil)
	if err != nil {
		return ""
	}
	log.Println(out)


	return "";
}