package member

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

type Member struct {
	Id          json.Number       `json:"id,Number,omitempty"`
	Email       string            `json:"email"`
	PwSalt      string            `json:"pwSalt"`
	Pw          string            `json:"pw"`
	Name        string            `json:"name"`
	CompanyName string            `json:"companyName"`
	Phone       string            `json:"phone"`
	Status      *MetaMemberStatus `json:"status"`
}

type MetaMemberStatus struct {
	Id   json.Number `json:"id,Number,omitempty"`
	Name string      `json:"name"`
}
type MemberService struct {
}

var TARGET_DAO = "member"

func NewMember() *Member {
	return &Member{}
}
func NewMemberService() *MemberService {
	return &MemberService{}
}

func (m *MemberService) Login(mem *Member) (string, error) {

	result, err := m.ReadByEmail(mem)
	if err != nil {
		return "", err
	}
	if result == "" {
		return "", errors.New("login reject")
	}

	temp := Member{}
	err = json.Unmarshal([]byte(result), &temp)
	if err != nil {
		return "", err
	}

	if temp.Status.Id == "1" {
		return result, errors.New("Email Auth Confirm")
	}

	b := encryption.Check(mem.PwSalt, temp.PwSalt, temp.Pw)
	if !b {
		return "", errors.New("login reject")
	}

	return "login success", nil
}

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

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

	//mem.PwSalt = pwSalt
	//mem.Pw = digest

	re, err := utils.InvokeDBByModel(TARGET_DAO, "save", mem, utils.MODEL_MEMBER)

	if err != nil {
		return "", err
	}

	// Todo EmailAuth Send
	go m.sendEmail(re)

	return re, nil
}

func (ms *MemberService) sendEmail(memberStr string) {

	tm := &Member{}

	err := json.Unmarshal([]byte(memberStr), tm)

	if err != nil {
		log.Fatal(err)
	}
	//e := email.NewEmail(tm.Id, tm.Email, tm.CompanyName, tm.Name, "")
	//
	//es := email.NewEmailService()
	//es.SendEmailForAuth(e)
}

func (m *MemberService) ReadByEmail(mem *Member) (string, error) {
	log.Println("Call ReadByEmail", mem.Email)

	re, err := utils.InvokeDBByModel(TARGET_DAO, "findByEmail", mem, utils.MODEL_MEMBER)

	if err != nil {
		return "", err
	}

	return re, nil
}

func (m *MemberService) Read(mem *Member) (string, error) {

	re, err := utils.InvokeDBByModel("member", "findOne", mem.Id, "java.lang.Long")

	if err != nil {
		return "", err
	}

	return re, err
}

func (m *MemberService) Modify(mem *Member) (string, error) {

	if mem.Id == "" {
		log.Fatal("Id nil")
	}

	re, err := utils.InvokeDBByModel("member", "findOne", mem, utils.MODEL_MEMBER)

	if err != nil {
		return "", err
	}

	return re, nil
}

func (m *MemberService) Remove(mem *Member) (string, error) {

	re, err := utils.InvokeDBByModel("member", "delete", mem.Id, "java.lang.Long")

	if err != nil {
		return "", err
	}

	return re, nil
}

func (m *MemberService) EmailConfirm() (string, error) {

	ks := keystore.NewKeyStoreSerivce()

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

	log.Println(key)

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

	return "", nil
}