package system

import (
	"time"
	"xps/cache"
	"xps/datasource"
	"xps/repositories/system"
	"xps/utils"
	"xps/viewmodels"
	"xps/web/middleware"
)

type LoginService interface {
	GetAccountByName(cond string)(*viewmodels.AccountInfo, error)
	CheckLogin(username, password string) (bRet bool, msg string, data *viewmodels.AccessToken)
	Logout(userId int64) error
}

type loginService struct {
	accountRepo             *system.AccountRepo
	ocRepo                  *system.OcRepo
	roleMemberRepo          *system.RoleMemberRepo
	groupMemberRepo         *system.GroupMemberRepo
	groupMemberPositionRepo *system.GroupMemberPositionRepo
}

func NewLoginService() LoginService {
	return &loginService{
		accountRepo:             system.NewAccountRepo(datasource.InstanceMaster()),
		ocRepo:                  system.NewOcRepo(datasource.InstanceMaster()),
		roleMemberRepo:          system.NewRoleMemberRepo(datasource.InstanceMaster()),
		groupMemberRepo:         system.NewGroupMemberRepo(datasource.InstanceMaster()),
		groupMemberPositionRepo: system.NewGroupMemberPositionRepo(datasource.InstanceMaster()),
	}
}

func (s *loginService) GetAccountByName(cond string)(*viewmodels.AccountInfo, error) {
	return s.accountRepo.GetAccountByName(cond)
}

func (s *loginService) CheckLogin(code, password string) (bRet bool, msg string, data *viewmodels.AccessToken) {
	account, err := s.accountRepo.GetAccountByCode(code)
	if err != nil {
		return false, "用户不存在", nil
	}

	pwd := utils.GetMD5String(password)
	if pwd != account.Password {
		return false, "密码错误", nil
	}

	if account.Status == 2 {
		return false, "账号被锁定，无法登陆，请联系管理员", nil
	}

	ocId            := account.OcId
	accountId       := account.AccountId
	accountName     := account.AccountName
	accountRealName := account.AccountRealName
	accountAvatar   := account.AccountAvatar
	accountPhoto    := account.AccountPhoto
	accountIntro    := account.AccountIntro
	accountPhone    := account.AccountPhone

	oc, err := s.ocRepo.GetById(ocId)
	if err != nil {
		return false, "单位信息不完整，请联系管理员", nil
	}
	ocName   := oc.OcName
	ocTypeId := oc.OcTypeId

	roleMember, err := s.roleMemberRepo.GetAccountFirstRole(ocId, accountId)
	if err != nil {
		return false, "帐号没有配置角色信息", nil
	}
	curRoleId := roleMember.RoleId
	curRoleName := roleMember.RoleName

	groupMember, err := s.groupMemberRepo.GetFirstGroupByAccountId(ocId, accountId)
	if err != nil {
		return false, "账号没有所属部门", nil
	}

	curGroupId := groupMember.GroupId
	curGroupName := groupMember.GroupName

	groupMemberPosition, err := s.groupMemberPositionRepo.GetFirstPositionByGroupIdAndAccountId(ocId, curGroupId, accountId)
	if err != nil {
		return false, "账号没有岗位信息", nil
	}

	curPositionId := groupMemberPosition.PositionId
	curPositionName := groupMemberPosition.PositionName

	userData := &viewmodels.UserData{}
	userData.OcId         = ocId
	userData.OcName       = ocName
	userData.UserId       = accountId
	userData.UserName     = accountName
	userData.UserRealName = accountRealName
	userData.UserPhone    = accountPhone
	userData.UserPhoto    = accountPhoto
	userData.UserAvatar   = accountAvatar
	userData.UserIntro    = accountIntro
	userData.GroupId      = curGroupId
	userData.GroupName    = curGroupName
	userData.PositionId   = curPositionId
	userData.PositionName = curPositionName
	userData.RoleId       = curRoleId
	userData.RoleName     = curRoleName
	
	err = cache.SetUserData(accountId, userData)
	if err != nil {
		return false, "Redis缓存用户数据失败", nil
	}
	
	tokenStr, err := middleware.GenerateToken(ocId, ocTypeId, accountId)
	if err != nil {
		return false, "没有生成Token", nil
	}
	
	expiresIn := time.Now().Add(time.Hour*24).UnixNano() / 1e6
	tokenResult := &viewmodels.AccessToken{}
	tokenResult.AccessToken = tokenStr
	tokenResult.User = userData
	tokenResult.ExpiresIn = expiresIn
	tokenResult.LeaseTime = expiresIn
	return true, "", tokenResult
}

func (s *loginService) Logout(userId int64) error {
	_, err := cache.DeleteUserData(userId)
	return err
}