package service

import (
	"context"
	"dashoo.cn/micro/app/dao"
	"dashoo.cn/micro/app/model"
	"dashoo.cn/opms_libary/myerrors"
	"github.com/gogf/gf/database/gdb"
	"github.com/gogf/gf/frame/g"
	"github.com/gogf/gf/util/gconv"
	"strconv"
	"strings"
)

type DeptService struct {
	*contextService
	Dao         *dao.SysDeptDao
	roleDeptDao *dao.SysRoleDeptDao
}

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)
	return svc, nil
}

func (s *DeptService) GetList(searchParams *model.SysDeptSearchParams) ([]*model.SysDept, error) {
	deptModel := s.Dao.M
	if searchParams.DeptName != "" {
		deptModel = deptModel.WhereLike(s.Dao.C.DeptName, "%"+searchParams.DeptName+"%")
	}
	if searchParams.Status != "" {
		deptModel = deptModel.Where(s.Dao.C.Status, searchParams.Status)
	}
	depts := ([]*model.SysDept)(nil)
	if err := deptModel.OrderAsc(s.Dao.C.Sort).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
	}
}

// GetAllDeptName 获取所有部门名称
func (s *DeptService) GetAllDeptName() (g.MapIntStr, error) {
	depts := ([]*model.SysDept)(nil)
	if err := s.Dao.Fields(s.Dao.C.Id, s.Dao.C.DeptName).Scan(&depts); err != nil {
		return nil, err
	}
	result := make(g.MapIntStr)
	for _, v := range depts {
		result[v.Id] = v.DeptName
	}
	return result, nil
}

func (s *DeptService) GetRoleDepts(roleId int) ([]int, error) {
	s.roleDeptDao = dao.NewSysRoleDeptDao(s.Tenant)
	result, err := s.roleDeptDao.Fields(s.roleDeptDao.C.DeptId).Where(s.roleDeptDao.C.RoleId, roleId).Array()
	if err != nil {
		return nil, err
	}
	return gconv.Ints(result), nil
}

// GetSonAndSelfIdByParentId 获取本部门下的所有子级部门(包含本部门)
// enable 仅当为false时才查询包含未启用的子部门
func (s *DeptService) GetSonAndSelfIdByParentId(deptId int, enable ...bool) ([]int, error) {
	db := s.Dao.Fields(s.Dao.C.Id).Wheref("find_in_set( %d , ancestors )", deptId)
	if !(len(enable) > 0 && !enable[0]) {
		db.Where(s.Dao.C.Status, "10")
	}
	result, err := db.Array()
	if err != nil {
		return nil, err
	}
	return gconv.Ints(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 int) (dept *model.SysDept, err error) {
	dept, err = s.Dao.WherePri(id).One()
	if err != nil {
		return nil, err
	}
	if dept == nil {
		return nil, myerrors.TipsError("部门不存在")
	}
	return
}

func (s *DeptService) Create(req *model.SysDeptReq) (err error) {
	// 检查上级部门
	dept, err := s.GetDeptById(req.ParentId)
	if err != nil {
		return err
	}
	data := new(model.SysDept)
	if err := gconv.Struct(req, data); err != nil {
		return err
	}
	data.Ancestors = dept.Ancestors + "," + gconv.String(dept.Id)
	SetCreatedInfo(data, s.GetCxtUserId(), s.GetCxtUserName())

	//开启事务管理
	err = s.Dao.Transaction(context.TODO(), func(ctx context.Context, tx *gdb.TX) (err error) {
		lastId, err := s.Dao.Ctx(ctx).Data(data).InsertAndGetId()
		if err != nil {
			return err
		}
		err = s.setAncestors(ctx, req.ParentId, lastId)
		return err
	})
	return
}

func (s *DeptService) UpdateById(req *model.UpdateSysDeptReq) error {
	// 检查上级部门
	dept, err := s.GetDeptById(req.ParentId)
	if err != nil {
		return err
	}
	data := new(model.SysDept)
	if err := gconv.Struct(req, data); err != nil {
		return err
	}
	data.Ancestors = dept.Ancestors + "," + gconv.String(dept.Id)
	SetUpdatedInfo(data, s.GetCxtUserId(), s.GetCxtUserName())
	//开启事务管理
	err = s.Dao.Transaction(context.TODO(), func(ctx context.Context, tx *gdb.TX) (err error) {
		_, err = s.Dao.Ctx(ctx).FieldsEx(UpdateFieldEx...).Data(data).WherePri(data.Id).Update()
		if err != nil {
			return myerrors.TipsError("修改失败")
		}
		//修改祖籍字段
		if dept.ParentId != req.ParentId {
			err := s.setAncestors(ctx, req.ParentId, req.Id)
			if err != nil {
				return err
			}
			lId := strconv.FormatInt(req.Id, 10)
			value, _ := s.Dao.Ctx(ctx).Fields(dao.SysDept.C.Ancestors).WhereLike(dao.SysDept.C.Ancestors, "%"+lId+"%").Array()
			if req.ParentId == -1 {
				for _, v := range value {
					newAncestors := strings.Replace(v.String(), dept.Ancestors, lId, -1)
					//修改相关祖籍字段
					_, err := s.Dao.Ctx(ctx).
						Data(dao.SysDept.C.Ancestors, newAncestors).
						Where(dao.SysDept.C.Ancestors, v.String()).Update()
					if err != nil {
						g.Log().Error(err)
						return myerrors.TipsError("关联祖籍修改失败")
					}
				}
			} else {
				//查询现有的进行拼接
				for _, v := range value {
					newAncestors := strings.Replace(dept.Ancestors, lId, "", -1)
					newAncestor := newAncestors + v.String()
					//修改相关祖籍字段
					_, err := s.Dao.Ctx(ctx).
						Data(dao.SysDept.C.Ancestors, newAncestor).
						Where(dao.SysDept.C.Ancestors, v.String()).
						WhereNot(dao.SysDept.C.Id, req.Id).
						Update()
					if err != nil {
						g.Log().Error(err)
						return myerrors.TipsError("关联祖籍修改失败")
					}
				}
			}
		}
		return nil
	})
	return err
}

func (s *DeptService) DeleteByIds(id int) error {
	ids, err := s.GetSonAndSelfIdByParentId(id, false)
	if err != nil {
		return err
	}
	_, err = s.Dao.Where(s.Dao.C.Id+" in (?)", ids).Delete()
	return err
}

// 修改祖籍字段
func (s *DeptService) setAncestors(ctx context.Context, ParentId int, lastId int64) (err error) {
	lId := strconv.FormatInt(lastId, 10)
	if ParentId == -1 { //根级别,修改祖籍为自己
		_, err := s.Dao.Ctx(ctx).Data(dao.SysDept.C.Ancestors, lId).WherePri(lastId).Update()
		if err != nil {
			g.Log().Error(err)
			return myerrors.TipsError("祖籍修改失败")
		}
	} else {
		var oldDept *model.SysDept
		err = s.Dao.Ctx(ctx).WherePri(ParentId).Scan(&oldDept)
		if err != nil {
			g.Log().Error(err)
			return myerrors.TipsError("查询祖籍失败")
		}
		_, err := s.Dao.Ctx(ctx).Data(dao.SysDept.C.Ancestors, oldDept.Ancestors+","+lId).WherePri(lastId).Update()
		if err != nil {
			g.Log().Error(err)
			return myerrors.TipsError("祖籍修改失败")
		}
	}
	return
}