package service

import (
    "errors"
    "xps/cmd/datasource"
    "xps/pkg/system/datamodel"
    repositories "xps/pkg/system/repository"
    "xps/pkg/system/viewmodel"
)

type GroupService interface {
    GetList(m map[string]interface{}) ([]viewmodel.GroupInfo, error)
    GetTreeView(ocId int64) ([]viewmodel.GroupTreeViewInfo, error)
    GetById(ocId int64, groupId int64) (*viewmodel.GroupInfo, error)
    Create(group *datamodel.Group) error
    Update(group *datamodel.Group) error
    Delete(m map[string]interface{}) error
}

type groupService struct {
    groupRepo               *repositories.GroupRepo
    groupMemberRepo         *repositories.GroupMemberRepo
    groupMemberPositionRepo *repositories.GroupMemberPositionRepo
    //groupMemberPositionGrantRepo *common.GroupMemberPositionGrantRepo
}

func NewGroupService() GroupService {
    return &groupService{
        groupRepo:               repositories.NewGroupRepo(datasource.InstanceMaster()),
        groupMemberRepo:         repositories.NewGroupMemberRepo(datasource.InstanceMaster()),
        groupMemberPositionRepo: repositories.NewGroupMemberPositionRepo(datasource.InstanceMaster()),
        //groupMemberPositionGrantRepo : common.NewGroupMemberPositionGrantRepo(datasource.InstanceMaster()),
    }
}

func (s *groupService) GetList(m map[string]interface{}) ([]viewmodel.GroupInfo, error) {
    return s.groupRepo.GetList(m)
}

func (s *groupService) GetTreeView(ocId int64) ([]viewmodel.GroupTreeViewInfo, error) {
    groupList, err := s.groupRepo.GetAll(ocId)
    if err != nil {
        return nil, err
    }
    return s.GenerateTreeInfo(0, groupList)
}

func (s *groupService) GenerateTreeInfo(parentId int64, groups []viewmodel.GroupInfo) ([]viewmodel.GroupTreeViewInfo, error) {

    treeItemList := make([]viewmodel.GroupTreeViewInfo, 0)
    for _, group := range groups {
        if group.ParentId == parentId {
            itemId := group.GroupId

            children, err := s.GenerateTreeInfo(itemId, groups)
            if err != nil {
                return nil, err
            }
            treeItem := viewmodel.GroupTreeViewInfo{
                Id:        itemId,
                Label:     group.GroupName,
                GroupId:   group.GroupId,
                GroupName: group.GroupName,
                Children:  children,
            }
            treeItemList = append(treeItemList, treeItem)
        }
    }
    return treeItemList, nil
}

func (s *groupService) GetById(ocId int64, gid int64) (*viewmodel.GroupInfo, error) {
    return s.groupRepo.GetById(ocId, gid)
}

func (s *groupService) Update(a *datamodel.Group) error {
    return s.groupRepo.Update(a)
}

// Create the group
func (s *groupService) Create(g *datamodel.Group) error {
    ocId := g.OcId
    parentId := g.ParentId

    var parentNodeRight = int64(0)
    var parentNodeLevel = int64(0)

    parent, err := s.groupRepo.GetById(ocId, parentId)
    if err != nil {
        return err
    }

    if parent != nil {
        parentNodeRight = parent.NodeRight
        parentNodeLevel = parent.NodeLevel

        err := s.groupRepo.IncrementGroupRight(ocId, 2, parentNodeRight)
        if err != nil {
            return err
        }

        err = s.groupRepo.IncrementGroupLeft(ocId, 2, parentNodeRight)
        if err != nil {
            return err
        }

        // refresh parent node as non-leaf status
        err = s.groupRepo.RefreshLeafStatus(ocId, parentId, false)
        if err != nil {
            return err
        }
    }

    g.GroupId = NewID()
    g.NodeLeft = parentNodeRight
    g.NodeRight = parentNodeRight + 1
    g.NodeLevel = parentNodeLevel + 1
    g.RootId = ocId
    g.IsLeaf = 1
    return s.groupRepo.Create(g)
}

func (s *groupService) Delete(m map[string]interface{}) error {
    ocId := m["ocId"].(int64)
    groupId := m["groupId"].(int64)
    group, err := s.groupRepo.GetById(ocId, groupId)
    if err != nil {
        return err
    }

    if group.IsFixed == 1 {
        return errors.New("不能删除锁定群组")
    }

    nodeLeft := group.NodeLeft
    nodeRight := group.NodeRight
    parentId := group.ParentId

    // delete the groups
    err = s.groupRepo.BatchDelete(ocId, nodeLeft, nodeRight)
    if err != nil {
        return err
    }

    steps := nodeRight - nodeLeft + 1

    // update the left
    err = s.groupRepo.DecrementGroupLeft(ocId, steps, nodeLeft)
    if err != nil {
        return err
    }

    // update the right
    err = s.groupRepo.DecrementGroupRight(ocId, steps, nodeRight)
    if err != nil {
        return err
    }

    // update the group parent leaf status
    countOfBrothers, err := s.groupRepo.CountOfChildren(ocId, parentId)
    if err != nil {
        return err
    }
    if countOfBrothers < 1 {
        err = s.groupRepo.RefreshLeafStatus(ocId, parentId, true)
        if err != nil {
            return err
        }
    }

    // delete the group members
    err = s.groupMemberRepo.DeleteByGroupId(ocId, groupId)
    if err != nil {
        return err
    }

    // delete the group member position
    err = s.groupMemberPositionRepo.DeleteByGroupId(ocId, groupId)
    if err != nil {
        return err
    }

    // delete the group member position grant
    //err = s.groupMemberPositionGrantRepo.DeleteByGroupId(ocId ,gid)

    return err
}