package service

import (
    "errors"
    "time"
    "xps/constant"
    "xps/datamodel"
    "xps/datasource"
    "xps/repositories"
    "xps/utils"
    "xps/viewmodel"
)

type UserService interface {
    GetList(m map[string]interface{}) ([]viewmodel.UserInfo, error)
    GetPage(m map[string]interface{}) (*viewmodel.PageResult, error)
    GetById(ocId, groupId, userId int64) (*viewmodel.UserInfo, error)
    Create(ocTypeId int64, user *viewmodel.UserInfo) error
    Update(user *viewmodel.UserInfo) error
    UpdatePassword(ocId, userId int64, pwd string) error
    ResetPassword(ocId, userId int64) error
    ChangeStatus(ocId, userId, status int64) error
    Delete(m map[string]interface{}) error
    IsUserNameExist(ocId int64, accountName string) (bool, error)
    IsUserPhoneExist(ocId int64, accountPhone string)(bool, error)
    IsStaffNoExist(ocId int64, staffNo string)(bool, error)
    IsEmailExist(ocId int64, staffNo string)(bool, error)
    SelectUser(ocId int64)([]viewmodel.UserSelectVo, error)
    GetPermit(userId int64, appKey string)([]viewmodel.AppPermitInfo, error)
}

type userService struct {
    userRepo *repositories.UserRepo
    accountRepo *repositories.AccountRepo
    roleMemberRepo *repositories.RoleMemberRepo
    groupRepo *repositories.GroupRepo
    groupMemberRepo *repositories.GroupMemberRepo
    groupMemberPositionRepo *repositories.GroupMemberPositionRepo
    permitRepo *repositories.AppPermitRepo
}

func NewUserService() UserService {
    return &userService{
        userRepo:                repositories.NewUserRepo(datasource.InstanceMaster()),
        accountRepo:             repositories.NewAccountRepo(datasource.InstanceMaster()),
        roleMemberRepo:          repositories.NewRoleMemberRepo(datasource.InstanceMaster()),
        groupRepo:               repositories.NewGroupRepo(datasource.InstanceMaster()),
        groupMemberRepo:         repositories.NewGroupMemberRepo(datasource.InstanceMaster()),
        groupMemberPositionRepo: repositories.NewGroupMemberPositionRepo(datasource.InstanceMaster()),
        permitRepo:              repositories.NewAppPermitRepo(datasource.InstanceMaster()),
    }
}

func (s *userService) GetList(m map[string]interface{}) ([]viewmodel.UserInfo, error) {
    ocId    := m["ocId"].(int64)
    groupId := m["groupId"].(int64)
    group, err := s.groupRepo.GetById(ocId, groupId)
    if err != nil {
        return nil, err
    }
    
    nodeLeft  := group.NodeLeft
    nodeRight := group.NodeRight
    m["nodeLeft"]  = nodeLeft
    m["nodeRight"] = nodeRight
    return s.userRepo.GetList(m)
}

func (s *userService) GetPage(m map[string]interface{}) (*viewmodel.PageResult, error) {
    ocId    := m["ocId"].(int64)
    groupId := m["groupId"].(int64)
    group, err := s.groupRepo.GetById(ocId, groupId)
    if err != nil {
        return nil, err
    }
    
    nodeLeft  := group.NodeLeft
    nodeRight := group.NodeRight
    m["nodeLeft"]  = nodeLeft
    m["nodeRight"] = nodeRight
    return s.userRepo.GetPage(m)
}

func (s *userService) GetById(ocId, groupId, userId int64) (*viewmodel.UserInfo, error) {
    return s.userRepo.GetById(ocId, groupId, userId)
}

func (s *userService) Create(ocTypeId int64, user *viewmodel.UserInfo) error {
    ocId      := user.OcId
    userId    := ocId //管理员ID同公司ID,只有管理员可以作账号管理
    newId     := NewID()
    accountId := newId
    
    userRole := constant.ENT_USER_ROLE
    if ocTypeId == constant.OCTYPE_ADMIN {
        userRole = constant.OP_ROLE_USER
    }else if ocTypeId == constant.OCTYPE_ORG{
        userRole = constant.ORG_ROLE_USER
    }else if ocTypeId == constant.OCTYPE_ENT{
        userRole = constant.ENT_USER_ROLE
    }else if ocTypeId == constant.OCTYPE_PARTNER{
        userRole = constant.PARTNER_ROLE_USER
    }
    
    // 1.Account
    account := &datamodel.Account{
        OcId:           ocId,
        AccountId:      accountId,
        AccountName:     user.AccountName,
        Password:        "21218cca77804d2ba1922c33e0151105",
        AccountType:     0,
        AccountRealName: user.AccountRealName,
        AccountPhone:    user.AccountPhone,
        AccountLastIp:   "",
        AccountLoc:      user.AccountLoc,
        AccountIntro:    user.AccountIntro,
        AccountPhoto:    user.AccountPhoto,
        AccountAvatar:   user.AccountAvatar,
        AccountMail:     user.AccountMail,
        AccountStaffNo:  user.AccountStaffNo,
        Status:          1,
        IsFixed:         0,
        CreatedBy:       userId,
        CreatedAt:       time.Time{},
    }
    
    err := s.accountRepo.Create(account)
    if err != nil {
        return err
    }
    
    // 2. Role member
    roleMember := &datamodel.RoleMember{
        RmId     : newId,
        OcId     : ocId,
        RoleId   : int64(userRole),
        AccountId: accountId,
    }
    err = s.roleMemberRepo.Create(roleMember)
    if err != nil {
        return err
    }
    
    // 3. Group Member
    groupId := user.GroupId
    groupMember := &datamodel.GroupMember{
        GmId     : newId,
        OcId     : ocId,
        GroupId  : groupId,
        AccountId: accountId,
    }
    err = s.groupMemberRepo.Create(groupMember)
    if err != nil {
        return err
    }
    
    // 4. Group Member Position
    positionId := user.PositionId
    groupMemberPosition := &datamodel.GroupMemberPosition{
        GmpId     : newId,
        OcId      : ocId,
        GroupId   : groupId,
        AccountId : accountId,
        PositionId: positionId,
    }
    err = s.groupMemberPositionRepo.Create(groupMemberPosition)
    return err
}

func (s *userService) Update(user *viewmodel.UserInfo) error {
    ocId       := user.OcId
    accountId  := user.AccountId
    groupId    := user.GroupId
    positionId := user.PositionId
    userId     := ocId//管理员ID同公司ID,只有管理员可以作账号管理
    
    // 1. update account
    account := &datamodel.Account{
        OcId:            ocId,
        AccountId:       accountId,
        AccountName:     user.AccountName,
        AccountType:     0,
        AccountRealName: user.AccountRealName,
        AccountPhone:    user.AccountPhone,
        AccountLastIp:   "",
        AccountLoc:      user.AccountLoc,
        AccountIntro:    user.AccountIntro,
        AccountPhoto:    user.AccountPhoto,
        AccountAvatar:   user.AccountAvatar,
        AccountMail:     user.AccountMail,
        AccountStaffNo:  user.AccountStaffNo,
        Status:          user.Status,
        UpdatedBy:       userId,
        UpdatedAt:       time.Time{},
    }
    err := s.accountRepo.Update(ocId, accountId, account)
    if err == nil {
        return err
    }
    
    // 2. update group member
    gmId := user.GmId
    groupMember := &datamodel.GroupMember{
        GmId:      gmId,
        OcId:      ocId,
        GroupId:   groupId,
        AccountId: accountId,
    }
    err = s.groupMemberRepo.Update(ocId, gmId, groupMember)
    if err != nil {
        return err
    }
    
    // 3. update the group member position
    gmpId := user.GmpId
    groupMemberPosition := &datamodel.GroupMemberPosition{
        OcId:       ocId,
        GmpId:      gmpId,
        GroupId:    groupId,
        AccountId:  accountId,
        PositionId: positionId,
    }
    err = s.groupMemberPositionRepo.Update(ocId, gmpId, groupMemberPosition)
    return err
}

func (s *userService) UpdatePassword(ocId, userId int64, pwd string) error {
    hashedPwd := utils.GetMD5String(pwd)
    data := &datamodel.Account{
        Password: hashedPwd,
    }
    return s.accountRepo.Update(ocId, userId, data)
}

func (s *userService) ResetPassword(ocId, userId int64) error {
    pwd := utils.GetMD5String("888888")
    data := &datamodel.Account{
        Password: pwd,
    }
    return s.accountRepo.Update(ocId, userId, data)
}

func (s *userService) ChangeStatus(ocId, userId, status int64) error {
    data := &datamodel.Account{
        Status: status,
    }
    return s.accountRepo.Update(ocId, userId, data)
}

func (s *userService) Delete(m map[string]interface{}) error {
    err := s.accountRepo.Delete(m)
    return err
}


func (s *userService) IsUserNameExist(ocId int64, accountName string) (bool, error){
    return s.accountRepo.IsUserNameExist(ocId, accountName)
}

func (s *userService) IsUserPhoneExist(ocId int64, accountPhone string)(bool, error){
    return s.accountRepo.IsUserPhoneExist(ocId, accountPhone)
}

func (s *userService) IsStaffNoExist(ocId int64, staffNo string)(bool, error){
    return s.accountRepo.IsStaffNoExist(ocId, staffNo)
}

func (s *userService) IsEmailExist(ocId int64, email string)(bool, error){
    return s.accountRepo.IsEmailExist(ocId, email)
}

func (s *userService) SelectUser(ocId int64)([]viewmodel.UserSelectVo, error){
    m := make(map[string]interface{}, 0)
    m["ocId"] = ocId
    memberList, err := s.groupMemberPositionRepo.GetList(m)
    if err != nil {
        return nil, err
    }
    
    voList     := make([]viewmodel.UserSelectVo, 0)
    itemList   := make([]viewmodel.UserSelectItemVo, 0)
    positionId := int64(0)
    for _, member := range memberList {
        item := viewmodel.UserSelectItemVo{
            Name: member.AccountName,
            Value: member.AccountId,
            AccountId: member.AccountId,
            AccountName: member.AccountName,
            PositionId: member.PositionId,
            PositionName: member.PositionName,
            GroupId: member.GroupId,
            GroupName: member.GroupName,
        }
        itemList   = append(itemList, item)
    
        if positionId != 0 && positionId != member.PositionId {
            vo := viewmodel.UserSelectVo{
                Name: member.PositionName,
                Children: itemList,
            }
            itemList = make([]viewmodel.UserSelectItemVo, 0)
            voList = append(voList, vo)
        }
        positionId = member.PositionId
    }
    
    return voList, nil
}

func (s *userService) GetPermit(userId int64, appKey string) ([]viewmodel.AppPermitInfo, error) {
    roleId := GetCurUserRoleId(userId)
    if roleId <= 0 {
        return nil, errors.New("用户角色信息不完整")
    }
    
    m := make(map[string]interface{},0)
    m["appKey"] = appKey
    m["roleId"] = roleId
    return s.permitRepo.GetList(m)
}