package service

import (
	"context"
	"dashoo.cn/micro/app/dao"
	"dashoo.cn/micro/app/model"
	"github.com/gogf/gf/util/gconv"
)

type deptService struct {
	*contextService
	Dao *dao.SysDeptDao
}

func NewDeptService(ctx context.Context) (svc *deptService, err error) {
	svc = new(deptService)
	if svc.contextService, err = svc.Init(ctx); err != nil {
		return nil, err
	}
	svc.Dao = dao.NewSysDeptDao(svc.Tenant)
	svc.Table = svc.Dao.Table
	return svc, nil
}

func (s *deptService) GetList(searchParams *model.SysDeptSearchParams) ([]*model.SysDept, error) {
	deptModel := s.Dao.M
	if searchParams.DeptName != "" {
		deptModel = deptModel.WhereLike("dept_name", "%"+searchParams.DeptName+"%")
	}
	if searchParams.Status != "" {
		deptModel = deptModel.Where("status", searchParams.Status)
	}
	depts := ([]*model.SysDept)(nil)
	if err := deptModel.Scan(&depts); err != nil {
		return nil, err
	}
	list := make([]*model.SysDept, 0, len(depts))
	if searchParams.ExcludeId != 0 {
		for _, v := range depts {
			if searchParams.ExcludeId != v.Id {
				list = append(list, v)
			}
		}
		return list, nil
	} else {
		return depts, nil
	}
}

func (s *deptService) GetRoleDepts(roleId int) ([]int, error) {
	var entityList []*model.SysRoleDept
	err := s.Dao.Where("role_id", roleId).Scan(&entityList)
	if err != nil {
		return nil, err
	}
	result := make([]int, 0)
	for _, v := range entityList {
		result = append(result, v.DeptId)
	}
	return result, nil
}

func (s *deptService) FindSonByParentId(depts []*model.SysDept, deptId int) []*model.SysDept {
	children := make([]*model.SysDept, 0, len(depts))
	for _, v := range depts {
		if v.ParentId == deptId {
			children = append(children, v)
			fChildren := s.FindSonByParentId(depts, v.Id)
			children = append(children, fChildren...)
		}
	}
	return children
}

func (s *deptService) GetDeptListTree(pid int, list []*model.SysDept) []*model.SysDeptTreeRes {
	tree := make([]*model.SysDeptTreeRes, 0, len(list))
	for _, v := range list {
		if v.ParentId == pid {
			t := &model.SysDeptTreeRes{
				SysDept: v,
			}
			child := s.GetDeptListTree(v.Id, list)
			if len(child) > 0 {
				t.Children = child
			}
			tree = append(tree, t)
		}
	}
	return tree
}

func (s *deptService) GetDeptById(id int64) (dept *model.SysDept, err error) {
	err = s.Dao.Where("id", id).Scan(&dept)
	return
}

func (s *deptService) Create(req *model.SysDeptReq) (err error) {
	data := new(model.SysDept)
	if err := gconv.Struct(req, data); err != nil {
		return err
	}
	SetCreatedInfo(data, s.GetCxtUserId(), s.GetCxtUserName())
	_, err = s.Dao.Insert(data)
	return
}

func (s *deptService) UpdateById(req *model.UpdateSysDeptReq) error {
	data := new(model.SysDept)
	if err := gconv.Struct(req, data); err != nil {
		return err
	}
	SetUpdatedInfo(data, s.GetCxtUserId(), s.GetCxtUserName())
	_, err := s.Dao.FieldsEx(UpdateFieldEx...).WherePri(data.Id).
		Update(data)
	return err
}

func (s *deptService) DeleteById(id int) error {
	var list []*model.SysDept
	err := s.Dao.Scan(&list)
	if err != nil {
		return err
	}
	children := s.FindSonByParentId(list, id)
	ids := make([]int, 0, len(list))
	for _, v := range children {
		ids = append(ids, v.Id)
	}
	ids = append(ids, id)
	_, err = s.Dao.Where(s.Dao.Columns.Id+" in (?)", ids).Delete()
	return err
}