package core

import (
	"errors"
	"fmt"
	"github.com/google/uuid"
)

type NKodeAPI struct {
	Db             DbAccessor
	SignupSessions map[SessionId]UserSignSession
}

func NewNKodeAPI(db DbAccessor) NKodeAPI {
	return NKodeAPI{
		Db:             db,
		SignupSessions: make(map[SessionId]UserSignSession),
	}
}

func (n *NKodeAPI) CreateNewCustomer(nkodePolicy NKodePolicy, id *CustomerId) (*CustomerId, error) {
	newCustomer, err := NewCustomer(nkodePolicy)
	if id != nil {
		newCustomer.Id = *id
	}
	if err != nil {
		return nil, err
	}
	err = n.Db.WriteNewCustomer(*newCustomer)

	if err != nil {
		return nil, err
	}
	return &newCustomer.Id, nil
}

func (n *NKodeAPI) GenerateSignupInterface(username Username, customerId CustomerId, kp KeypadDimension) (*GenerateSignupInterfaceResp, error) {
	svgIdxInterface, err := n.Db.RandomSvgIdxInterface(kp)
	if err != nil {
		return nil, err
	}
	signupSession, err := NewSignupSession(username, kp, customerId, svgIdxInterface)
	if err != nil {
		return nil, err
	}
	n.SignupSessions[signupSession.Id] = *signupSession
	svgInterface, err := n.Db.GetSvgStringInterface(signupSession.LoginUserInterface.SvgId)
	if err != nil {
		return nil, err
	}
	resp := GenerateSignupInterfaceResp{
		UserIdxInterface: signupSession.SetIdxInterface,
		SvgInterface:     svgInterface,
		SessionId:        uuid.UUID(signupSession.Id).String(),
	}
	return &resp, nil
}

func (n *NKodeAPI) SetNKode(customerId CustomerId, sessionId SessionId, keySelection KeySelection) (IdxInterface, error) {
	_, err := n.Db.GetCustomer(customerId)

	if err != nil {
		return nil, err
	}
	session, exists := n.SignupSessions[sessionId]
	if !exists {
		return nil, errors.New(fmt.Sprintf("session id does not exist %s", sessionId))
	}
	confirmInterface, err := session.SetUserNKode(keySelection)
	if err != nil {
		return nil, err
	}
	n.SignupSessions[sessionId] = session
	return confirmInterface, nil
}

func (n *NKodeAPI) ConfirmNKode(customerId CustomerId, sessionId SessionId, keySelection KeySelection) error {
	session, exists := n.SignupSessions[sessionId]
	if !exists {
		return errors.New(fmt.Sprintf("session id does not exist %s", sessionId))
	}
	customer, err := n.Db.GetCustomer(customerId)
	if err != nil {
		return err
	}
	passcode, err := session.DeducePasscode(keySelection)
	if err != nil {
		return err
	}
	err = customer.IsValidNKode(session.Kp, passcode)
	if err != nil {
		return err
	}
	user, err := NewUser(*customer, session.Username, passcode, session.LoginUserInterface, session.Kp)
	if err != nil {
		return err
	}
	err = n.Db.WriteNewUser(*user)
	delete(n.SignupSessions, session.Id)
	return err
}

func (n *NKodeAPI) GetLoginInterface(username Username, customerId CustomerId) (*GetLoginInterfaceResp, error) {
	user, err := n.Db.GetUser(username, customerId)
	if err != nil {
		return nil, err
	}
	err = user.Interface.PartialInterfaceShuffle()
	if err != nil {
		return nil, err
	}
	err = n.Db.UpdateUserInterface(user.Id, user.Interface)
	if err != nil {
		return nil, err
	}
	svgInterface, err := n.Db.GetSvgStringInterface(user.Interface.SvgId)
	if err != nil {
		return nil, err
	}
	resp := GetLoginInterfaceResp{
		UserIdxInterface: user.Interface.IdxInterface,
		SvgInterface:     svgInterface,
		NumbOfKeys:       user.Kp.NumbOfKeys,
		AttrsPerKey:      user.Kp.AttrsPerKey,
	}
	return &resp, nil
}

func (n *NKodeAPI) Login(customerId CustomerId, username Username, keySelection KeySelection) (*JwtTokens, error) {
	customer, err := n.Db.GetCustomer(customerId)
	if err != nil {
		return nil, err
	}
	user, err := n.Db.GetUser(username, customerId)
	if err != nil {
		return nil, errors.New(fmt.Sprintf("user dne %s", username))
	}
	passcode, err := ValidKeyEntry(*user, *customer, keySelection)
	if err != nil {
		return nil, err
	}

	if user.Renew {
		err = n.Db.RefreshUserPasscode(*user, passcode, customer.Attributes)
		if err != nil {
			return nil, err
		}
	}
	jwtToken, err := NewJwtTokens(string(user.Username))
	if err != nil {
		return nil, err
	}
	err = n.Db.UpdateUserRefreshToken(user.Id, jwtToken.RefreshToken)
	if err != nil {
		return nil, err
	}
	return &jwtToken, nil
}

func (n *NKodeAPI) RenewAttributes(customerId CustomerId) error {
	return n.Db.Renew(customerId)
}

func (n *NKodeAPI) RandomSvgInterface() ([]string, error) {
	return n.Db.RandomSvgInterface(KeypadMax)
}

func (n *NKodeAPI) GetSvgStringInterface(svgId SvgIdInterface) ([]string, error) {
	return n.Db.GetSvgStringInterface(svgId)
}

func (n *NKodeAPI) RefreshToken(username Username, customerId CustomerId, refreshToken string) (string, error) {
	user, err := n.Db.GetUser(username, customerId)
	if err != nil {
		return "", err
	}
	if user.RefreshToken != refreshToken {
		return "", errors.New("refresh token is invalid")
	}
	refreshClaims, err := ParseRefreshToken(refreshToken)
	if err != nil {
		return "", err
	}
	if err = ClaimExpired(*refreshClaims); err != nil {
		return "", err
	}
	newAccessClaims := NewAccessClaim(string(username))
	return EncodeAndSignClaims(newAccessClaims)
}