package service

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

type OcService interface {
    GetList(m map[string]interface{}) ([]viewmodel.OcInfo, error)
    GetPage(m map[string]interface{}) (*viewmodel.PageResult, error)
    GetById(ocId int64) (*viewmodel.OcInfo, error)
    Create(d *datamodel.Oc) error
    Update(d *datamodel.Oc) error
    Delete(m map[string]interface{}) error
    
    GetAdmin(ocId int64) (*viewmodel.OcAdminInfo, error)
    CreateAdmin(d *viewmodel.OcAdminInfo) error
    UpdateAdmin(d *viewmodel.OcAdminInfo) error
    ResetAdminPwd(ocId, accountId int64) error
    
    UpdateStatus(ocId, status int64) error
    UpdateLicStatus(ocId, status int64) error
}

type ocService struct {
    ocRepo *repositories.OcRepo
    groupCatRepo *repositories.GroupCatRepo
    groupRepo *repositories.GroupRepo
    accountRepo *repositories.AccountRepo
    positionRepo *repositories.PositionRepo
    groupMemberRepo *repositories.GroupMemberRepo
    groupMemberPositionRepo *repositories.GroupMemberPositionRepo
    roleMemberRepo *repositories.RoleMemberRepo
}

func NewOcService() OcService {
    return &ocService{
        ocRepo: repositories.NewOcRepo(datasource.InstanceMaster()),
    }
}

func (s *ocService) GetList(m map[string]interface{}) ([]viewmodel.OcInfo, error) {
    return s.ocRepo.GetList(m)
}

func (s *ocService) GetPage(m map[string]interface{}) (*viewmodel.PageResult, error) {
    return s.ocRepo.GetPage(m)
}

func (s *ocService) GetById(ocId int64) (*viewmodel.OcInfo, error) {
    return s.ocRepo.GetById(ocId)
}

func (s *ocService) Create(o *datamodel.Oc) error {
    ocId   := NewID()
    ocName := o.OcName
    userId := o.CreatedBy
    
    // 1.Create OC
    o.OcId      = ocId
    o.RootId    = ocId
    o.ParentId  = 0
    o.GroupId   = ocId
    o.NodeLeft  = 1
    o.NodeRight = 2
    o.NodeLevel = 1
    o.IsLeaf    = 1
    o.Status    = 1
    o.CreatedAt = time.Now()
    err1 := s.ocRepo.Create(o)
    if err1 != nil {
        return err1
    }
    
    // 2.Group Cat
    groupCat := &datamodel.GroupCat{
        OcId: ocId,
        GroupCatId: ocId,
        GroupCatTitle: "公司",
        IsFixed: 1,
        GroupCatDesc: "公司",
        CreatedAt: time.Now(),
        CreatedBy: userId,
    }
    err2 := s.groupCatRepo.Create(groupCat)
    if err2 != nil {
        return err1
    }
    
    // 3.Group
    group := &datamodel.Group{
        OcId: ocId,
        GroupId: ocId,
        GroupName: ocName,
        GroupCatId: ocId,
        NodeLeft: 1,
        NodeRight: 2,
        NodeLevel: 1,
        RootId: ocId,
        ParentId: 0,
        IsFixed: 1,
        IsLeaf: 1,
        GroupCode: "",
        GroupPath: "",
        CreatedBy: userId,
        CreatedAt: time.Now(),
    }
    err3 := s.groupRepo.Create(group)
    if err3 != nil {
        return err3
    }
    
    return nil
}

func (s *ocService) Update(o *datamodel.Oc) error {
    ocId   := o.OcId
    ocName := o.OcName
    userId := o.UpdatedBy
    
    // 1. Update OC
    o.UpdatedAt = time.Now()
    err1 := s.ocRepo.Update(o)
    if err1 != nil {
        return err1
    }
    
    // 2.Group
    group := &datamodel.Group{
        OcId: ocId,
        GroupId: ocId,
        GroupName: ocName,
        UpdatedAt: time.Now(),
        UpdatedBy: userId,
    }
    err2 := s.groupRepo.Update(group)
    if err2 != nil {
        return err2
    }
    return nil
}

func (s *ocService) Delete(m map[string]interface{}) error {
    return s.ocRepo.Delete(m)
}

func (s *ocService) GetAdmin(ocId int64) (*viewmodel.OcAdminInfo, error) {
    return s.ocRepo.GetAdmin(ocId)
}

func (s *ocService) CreateAdmin(a *viewmodel.OcAdminInfo) error {
    ocId    := a.OcId
    adminId := ocId
    userId  := a.CreatedBy
    
    //1.Account
    account := &datamodel.Account{
        OcId: ocId,
        AccountId: adminId,
        AccountName: a.AdminName,
        Password: "21218cca77804d2ba1922c33e0151105",
        AccountPhone: a.AdminPhone,
        AccountType: 0,
        AccountAvatar: "",
        IsFixed: 1,
        Status: 1,
        CreatedBy: userId,
        CreatedAt: time.Now(),
    }
    err1 := s.accountRepo.Create(account)
    if err1 != nil {
        return err1
    }
    
    //2.OC Admin
    oc := &datamodel.Oc{
        OcId: ocId,
        AdminId: adminId,
    }
    err2 := s.ocRepo.Update(oc)
    if err2 != nil {
        return err2
    }
    
    //3.Role Member
    roleMember := &datamodel.RoleMember{
        OcId: ocId,
        RmId: ocId,
        RoleId: constant.ENT_ROLE_ADMIN,
        AccountId: adminId,
    }
    err3 := s.roleMemberRepo.Create(roleMember)
    if err3 != nil {
        return err3
    }
    
    //4.Position
    position := &datamodel.Position{
        OcId: ocId,
        PositionId: ocId,
        PositionName: "管理员",
        PositionDesc: "管理员",
        IsFixed: 1,
        CreatedAt: time.Now(),
        CreatedBy: userId,
    }
    err4 := s.positionRepo.Create(position)
    if err4 != nil {
        return err4
    }
    
    //5.Group Member
    groupMember := &datamodel.GroupMember{
        OcId: ocId,
        GmId: ocId,
        GroupId: ocId,
        AccountId: adminId,
        IsFixed: 1,
    }
    err5 := s.groupMemberRepo.Create(groupMember)
    if err5 != nil {
        return err5
    }
    
    //6.Group Member Position
    groupMemberPosition := &datamodel.GroupMemberPosition{
        OcId: ocId,
        GmpId: ocId,
        GroupId: ocId,
        AccountId: adminId,
        PositionId: ocId,
        IsFixed: 1,
    }
    err6 := s.groupMemberPositionRepo.Create(groupMemberPosition)
    return err6
}

func (s *ocService) UpdateAdmin(a *viewmodel.OcAdminInfo) error {
    ocId    := a.OcId
    adminId := a.AdminId
    userId  := a.UpdatedBy
    
    //1. Account
    account := &datamodel.Account{
        OcId: ocId,
        AccountId: adminId,
        AccountName: a.AdminName,
        AccountPhone: a.AdminPhone,
        UpdatedBy: userId,
        UpdatedAt: time.Now(),
    }
    return s.accountRepo.Update(ocId, adminId, account)
}

func (s *ocService) ResetAdminPwd(ocId, accountId int64) error{
    //1. Account
    account := &datamodel.Account{
        OcId: ocId,
        AccountId: accountId,
        Password: "21218cca77804d2ba1922c33e0151105",
    }
    return s.accountRepo.Update(ocId, accountId, account)
}

func (s *ocService) UpdateStatus(ocId, status int64) error {
    oc := &datamodel.Oc{
        OcId: ocId,
        Status: status,
    }
    return s.ocRepo.Update(oc)
}

func (s *ocService) UpdateLicStatus(ocId, status int64) error{
    oc := &datamodel.Oc{
        OcId: ocId,
        IfLic: status,
    }
    return s.ocRepo.Update(oc)
}