package service

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

type RoleService struct {
	*contextService
	Dao         *dao.SysRoleDao
	roleMenuDao *dao.SysRoleMenuDao
	roleDeptDao *dao.SysRoleDeptDao
}

func NewRoleService(ctx context.Context) (svc *RoleService, err error) {
	svc = new(RoleService)
	if svc.contextService, err = svc.Init(ctx); err != nil {
		return nil, err
	}
	svc.Dao = dao.NewSysRoleDao(svc.Tenant)
	svc.roleMenuDao = dao.NewSysRoleMenuDao(svc.Tenant)
	svc.roleDeptDao = dao.NewSysRoleDeptDao(svc.Tenant)
	return svc, nil
}

// GetRoleList 获取角色列表
func (s *RoleService) GetRoleList() (list []*model.SysRole, err error) {
	//从数据库获取
	list, err = s.Dao.OrderAsc(s.Dao.C.Sort).All()
	if err != nil {
		g.Log().Error(err)
		err = gerror.New("获取角色数据失败")
	}
	return
}

func (s *RoleService) GetRoleListSearch(req *model.SelectPageReq) (total int, list []*model.SysRole, err error) {
	db := s.Dao.M
	if req.RoleName != "" {
		db = db.Where("role_name like ?", "%"+req.RoleName+"%")
	}
	if req.Status != "" {
		db = db.Where("status", req.Status)
	}
	if req.BeginTime != "" {
		db = db.Where("created_time >= ? ", utils.StrToTimestamp(req.BeginTime))
	}
	if req.EndTime != "" {
		db = db.Where("created_time<=?", utils.StrToTimestamp(req.EndTime))
	}
	total, err = db.Count()
	if err != nil {
		g.Log().Error(err)
		err = gerror.New("获取总行数失败")
		return
	}
	err = db.Page(req.GetPage()).OrderAsc(s.Dao.C.Sort).Scan(&list)
	if err != nil {
		g.Log().Error(err)
		err = gerror.New("获取数据失败")
		return
	}
	return
}

func (s *RoleService) GetRoleById(id int64) (roleInfo *model.UpdateSysRoleReq, err error) {
	roleInfo = new(model.UpdateSysRoleReq)
	role := new(model.SysRole)
	err = s.Dao.WherePri(id).Scan(&role)
	if err := gconv.Struct(role, roleInfo); err != nil {
		return nil, err
	}
	var menuList []model.SysRoleMenu
	err = s.roleMenuDao.Where("role_id", id).Scan(&menuList)
	if err != nil {
		return nil, err
	}
	roleInfo.MenuIds = []int{}
	for _, v := range menuList {
		roleInfo.MenuIds = append(roleInfo.MenuIds, v.MenuId)
	}
	return
}

func (s *RoleService) GetRoleDeptTreeselect(id int64) (deptIds []int, err error) {
	count, err := s.Dao.WherePri(id).Count()
	if err != nil || count == 0 {
		return nil, gerror.New("角色不存在")
	}
	roleDeptList, err := s.roleDeptDao.Where("role_id", id).FindAll()
	if err != nil {
		return nil, err
	}
	deptIds = make([]int, len(roleDeptList))
	for _, v := range roleDeptList {
		deptIds = append(deptIds, v.DeptId)
	}
	return
}

// GetRolesMenuPermissions 获取角色菜单权限
func (s *RoleService) GetRolesMenuPermissions(ids []int) (perms []string, err error) {
	result, err := dao.NewSysMenuDao(s.Tenant).Fields(dao.SysMenu.C.Perms).WhereIn(dao.SysMenu.C.MenuType, g.Slice{"C", "F"}).
		WhereIn(dao.SysMenu.C.Id, s.roleMenuDao.WhereIn(s.roleMenuDao.C.RoleId, ids).Fields(s.roleMenuDao.C.MenuId).M).
		WhereNot(dao.SysMenu.C.Perms, "").Array()
	perms = gconv.Strings(result)
	return perms, err
}

func (s *RoleService) CreateRole(req *model.SysRoleReq) error {
	data := new(model.SysRole)
	if err := gconv.Struct(req, data); err != nil {
		return err
	}
	SetCreatedInfo(data, s.GetCxtUserId(), s.GetCxtUserName())
	err := s.Dao.Transaction(context.TODO(), func(ctx context.Context, tx *gdb.TX) error {
		roleId, err := s.Dao.TX(tx).Data(data).InsertAndGetId()
		if err != nil {
			return err
		}
		return s.createRoleMenu(tx, roleId, req.MenuIds)
	})
	return err
}

func (s *RoleService) UpdateRole(req *model.UpdateSysRoleReq) error {
	//保存角色信息
	roleMap := gdb.Map{
		"id":        req.Id,
		"role_name": req.RoleName,
		"role_Key":  req.RoleKey,
		"status":    req.Status,
		"sort":      req.Sort,
		"remark":    req.Remark,
	}
	SetUpdatedInfo(roleMap, s.GetCxtUserId(), s.GetCxtUserName())
	err := s.Dao.Transaction(context.TODO(), func(ctx context.Context, tx *gdb.TX) error {
		_, err := tx.Model(model.SysRole{}).Data(roleMap).WherePri(req.Id).Update()
		if err != nil {
			return err
		}
		_, err = s.roleMenuDao.TX(tx).Where(dao.SysRoleMenu.C.RoleId, req.Id).Delete()
		if err != nil {
			return err
		}
		return s.createRoleMenu(tx, int64(req.Id), req.MenuIds)
	})
	return err
}

// 角色关联菜单
func (s *RoleService) createRoleMenu(tx *gdb.TX, roleId int64, menuIds []int) error {
	list := g.Slice{}
	for _, v := range menuIds {
		list = append(list, g.Map{
			dao.SysRoleMenu.C.RoleId: roleId,
			dao.SysRoleMenu.C.MenuId: v,
		})
	}
	_, err := s.roleMenuDao.TX(tx).Insert(list)
	if err != nil {
		return err
	}
	return nil
}

func (s *RoleService) DeleteByIds(ids []int64) (err error) {
	err = s.Dao.Transaction(context.TODO(), func(ctx context.Context, tx *gdb.TX) error {
		_, err = s.Dao.TX(tx).Where("id in(?)", ids).Delete()
		if err != nil {
			return err
		}
		// 删除角色菜单权限
		_, err = s.roleMenuDao.TX(tx).WhereIn(dao.SysRoleMenu.C.RoleId, ids).Delete()
		if err != nil {
			return err
		}
		// 删除角色数据权限
		_, err = s.roleDeptDao.TX(tx).WhereIn(dao.SysRoleMenu.C.RoleId, ids).Delete()
		return err
	})

	return err
}

func (s *RoleService) UpdateRoleStatus(req *model.StatusSetReq) error {
	_, err := s.Dao.WherePri(req.RoleId).Data(s.Dao.C.Status, req.Status).Update()
	return err
}

// 设置角色数据权限
func (s *RoleService) UpdateRoleDataScope(req *model.DataScopeReq) error {
	err := s.Dao.Transaction(context.TODO(), func(ctx context.Context, tx *gdb.TX) error {
		_, err := s.Dao.TX(tx).WherePri(req.RoleId).Data(g.Map{s.Dao.C.DataScope: req.DataScope, s.Dao.C.DeptCheckStrictly: req.DeptCheckStrictly}).Update()
		if err != nil {
			return err
		}
		if req.DataScope == 2 {
			_, err := s.roleDeptDao.Where(s.roleDeptDao.C.RoleId, req.RoleId).Delete()
			if err != nil {
				return err
			}
			data := g.List{}
			for _, deptId := range req.DeptIds {
				data = append(data, g.Map{s.roleDeptDao.C.RoleId: req.RoleId, s.roleDeptDao.C.DeptId: deptId})
			}
			_, err = s.roleDeptDao.TX(tx).Data(data).Insert()
			if err != nil {
				return err
			}
		}
		return nil
	})
	return err
}

// GetRoleKeys 根据用户id获取角色key
func (s *RoleService) GetRoleKeys(roleIds []int) ([]string, error) {
	roles, err := s.Dao.WhereIn(dao.SysRole.C.Id, roleIds).Fields(dao.SysRole.C.RoleKey).Distinct().Array()
	if err != nil {
		return nil, err
	}
	return gconv.Strings(roles), nil
}