package model

import (
	"sort"

	pasturePb "gitee.com/xuyiping_admin/go_proto/proto/go/backend/cow"
)

type SystemDept struct {
	Id        int64                 `json:"id"`
	PastureId int64                 `json:"pastureId"`
	Name      string                `json:"name"`
	Remarks   string                `json:"remarks"`
	DeptType  pasturePb.Depth_Kind  `json:"deptType"`
	LeaderId  int64                 `json:"leaderId"`
	ParentId  int64                 `json:"parentId"`
	Sort      int32                 `json:"sort"`
	IsShow    pasturePb.IsShow_Kind `json:"isShow"`
	IsDelete  pasturePb.IsShow_Kind `json:"isDelete"`
	CreatedAt int64                 `json:"createdAt"`
	UpdatedAt int64                 `json:"updatedAt"`
}

func (s *SystemDept) TableName() string {
	return "system_dept"
}

func (s *SystemDept) DepthUpdate(req *pasturePb.SearchDeptRequest) {
	s.Name = req.Name
	s.ParentId = int64(req.ParentId)
	s.Sort = req.Sort
	s.Remarks = req.Remarks
	s.IsShow = req.IsShow
	s.IsDelete = req.IsDelete
}

func NewSystemDept(pastureId int64, req *pasturePb.SearchDeptRequest) *SystemDept {
	return &SystemDept{
		PastureId: pastureId,
		Name:      req.Name,
		Remarks:   req.Remarks,
		DeptType:  pasturePb.Depth_Company,
		LeaderId:  int64(req.LeaderId),
		ParentId:  int64(req.ParentId),
		IsShow:    pasturePb.IsShow_Ok,
		IsDelete:  pasturePb.IsShow_Ok,
	}
}

func NewSystemDeptInit(pasture *AppPastureList) *SystemDept {
	return &SystemDept{
		PastureId: pasture.Id,
		Name:      pasture.Name,
		Remarks:   "",
		DeptType:  pasturePb.Depth_Company,
		LeaderId:  0,
		ParentId:  0,
		Sort:      0,
		IsShow:    pasturePb.IsShow_Ok,
		IsDelete:  pasturePb.IsShow_Ok,
	}
}

type SystemDeptSlice []*SystemDept

func (s SystemDeptSlice) ToPB(systemUserList []*SystemUser) []*pasturePb.SearchDeptRequest {
	res := make([]*pasturePb.SearchDeptRequest, len(s))
	for i, d := range s {
		leaderName := ""
		for _, v := range systemUserList {
			if d.LeaderId != v.Id {
				continue
			}
			leaderName = v.Name
		}

		res[i] = &pasturePb.SearchDeptRequest{
			Id:         int32(d.Id),
			Name:       d.Name,
			Remarks:    d.Remarks,
			ParentId:   int32(d.ParentId),
			DepthType:  d.DeptType,
			LeaderId:   int32(d.LeaderId),
			LeaderName: leaderName,
			Sort:       d.Sort,
			IsShow:     d.IsShow,
			IsDelete:   d.IsDelete,
			PastureId:  int32(d.PastureId),
			CreatedAt:  int32(d.CreatedAt),
			UpdatedAt:  int32(d.UpdatedAt),
		}
	}
	return res
}

func (s SystemDeptSlice) ToTree() []*pasturePb.DeptTreeData {
	res := make([]*pasturePb.DeptTreeData, len(s))
	if 0 == len(s) {
		return res
	}
	// 正排序
	sort.Slice(s, func(i, j int) bool {
		return s[i].ParentId < s[j].ParentId
	})

	for i, v := range s {
		res[i] = &pasturePb.DeptTreeData{
			Id:        int32(v.Id),
			ParentId:  int32(v.ParentId),
			Name:      v.Name,
			IsShow:    v.IsShow,
			PastureId: int32(v.PastureId),
			Children:  make([]*pasturePb.DeptTreeData, 0),
		}
	}
	// 构建树
	return deptBuildTree(res)
}

func deptBuildTree(deptTreeList []*pasturePb.DeptTreeData) []*pasturePb.DeptTreeData {
	tree := make([]*pasturePb.DeptTreeData, 0)
	for _, dept := range deptTreeList {
		if dept.ParentId == 0 {
			tree = append(tree, dept)
		} else {
			parent := deptFindByID(deptTreeList, dept.ParentId)
			if parent != nil {
				parent.Children = append(parent.Children, dept)
			}
		}
	}
	return tree
}

func deptFindByID(menuTreeList []*pasturePb.DeptTreeData, id int32) *pasturePb.DeptTreeData {
	for _, v := range menuTreeList {
		if id == v.Id {
			return v
		}
		if child := deptFindByID(v.Children, id); child != nil {
			return child
		}
	}
	return nil
}