package dao

import (
	"github.com/druidcaesa/gotool"
	"reflect"
	"strings"
	"ulink-admin/frame"
	"ulink-admin/modules/system/models/model"
	"ulink-admin/modules/system/models/req"
	"ulink-admin/pkg/base"
	"ulink-admin/pkg/page"
	"ulink-admin/utils"
	"xorm.io/xorm"
)

type RoleDao struct {
	base.BaseDao
}

// 角色公用sql
func (d RoleDao) sqlSelectJoin() *xorm.Session {
	return base.GetSession().Session.Table([]string{model.SysRole{}.TableName(), "r"}).
		Join("LEFT", []string{"sys_user_role", "ur"}, "ur.role_id = r.id").
		Join("LEFT", []string{"sys_user", "u"}, "u.id = ur.user_id")
}

// 角色公用sql
func (d RoleDao) sqlSelect() *xorm.Session {
	return base.GetSession().Session.Table([]string{model.SysRole{}.TableName(), "r"})
}

// 用户角色关系查询sql
func (d RoleDao) sqlSelectRoleAndUser() *xorm.Session {
	return base.GetSession().Session.Table([]string{model.SysRole{}.TableName(), "r"}).
		Join("LEFT", []string{"sys_user_role", "ur"}, "ur.role_id = r.id").
		Join("LEFT", []string{"sys_user", "u"}, "u.id = ur.user_id")
}

// page 分页查询
func (d RoleDao) Page(q *req.RoleQuery, list interface{}) int64 {
	session := base.GetSession().Session
	session.Table([]string{model.SysRole{}.TableName(), "r"}).
		Join("LEFT", []string{"sys_user_role", "ur"}, "ur.role_id = r.id").
		Join("LEFT", []string{"sys_user", "u"}, "u.id = ur.user_id")
	if !gotool.StrUtils.HasEmpty(q.RoleName) {
		session.And("r.role_name like concat('%', ?, '%')", q.RoleName)
	}
	if !gotool.StrUtils.HasEmpty(q.Status) {
		session.And("r.status = ?", q.Status)
	}
	if !gotool.StrUtils.HasEmpty(q.RoleKey) {
		session.And("r.role_key like concat('%', ?, '%')", q.RoleKey)
	}
	if !gotool.StrUtils.HasEmpty(q.BeginTime) {
		session.And("date_format(r.create_time,'%y%m%d') >= date_format(?,'%y%m%d')", q.BeginTime)
	}
	if !gotool.StrUtils.HasEmpty(q.EndTime) {
		session.And("date_format(r.create_time,'%y%m%d') <= date_format(?,'%y%m%d')", q.EndTime)
	}

	if !base.GetCurUser().IsAdmin {
		session.And("r.company_id = ?", base.GetCurUser().ComponyId)
	}
	total, err := session.Limit(q.Size(), page.StartSize(q.Page(), q.Size())).OrderBy("r.role_sort").FindAndCount(list)
	if err != nil {
		frame.Throw(frame.SQL_CODE, "查询错误:"+err.Error())
	}
	return total
}

// list 查询所有角色
func (d RoleDao) List(q *req.RoleQuery, list interface{}) {
	session := base.GetSession().Session
	session.Table([]string{model.SysRole{}.TableName(), "o"})
	if !base.GetCurUser().IsAdmin {
		session.And("o.company_id = ?", base.GetCurUser().ComponyId)
	}
	err := session.Find(list)
	if err != nil {
		frame.Throw(frame.SQL_CODE, "查询错误:"+err.Error())
	}
}

// SelectRoleListByUserId 根据用户id查询用户角色id集合
func (d RoleDao) SelectRoleListByUserId(id int64) *[]int64 {
	sqlSelectRoleAndUser := d.sqlSelectRoleAndUser()
	var roleIds []int64
	err := sqlSelectRoleAndUser.Cols("r.id").Where("u.id = ?", id).Find(&roleIds)
	if err != nil {
		gotool.Logs.ErrorLog().Println(err)
		return nil
	}
	return &roleIds
}

// GetRolePermissionByUserId 查询用户角色集合
func (d RoleDao) GetRolePermissionByUserId(id int64) *[]string {
	var roleKeys []string
	err := d.sqlSelectJoin().Cols("r.role_key").Where("r.del_flag = '0'").And("u.id = ?", id).Find(&roleKeys)
	if err != nil {
		gotool.Logs.ErrorLog().Println(err)
		return nil
	}
	return &roleKeys
}

// GetRoleListByUserId 根据用户ID查询角色
func (d RoleDao) GetRoleListByUserId(id int64) *[]model.SysRole {
	roles := make([]model.SysRole, 0)
	err := d.sqlSelectJoin().Where("r.del_flag = '0'").And("ur.user_id = ?", id).Find(&roles)
	if err != nil {
		gotool.Logs.ErrorLog().Println(err)
		return nil
	}
	return &roles
}

// SelectRoleByRoleId 根据角色id查询角色数据
func (d RoleDao) SelectRoleByRoleId(id int64) *model.SysRole {
	role := model.SysRole{}
	_, err := d.sqlSelectJoin().Where("r.id = ?", id).Get(&role)
	if err != nil {
		gotool.Logs.ErrorLog().Println(err)
		return nil
	}
	return &role
}

// CheckRoleNameUnique 校验角色名称是否唯一
func (d RoleDao) CheckRoleNameUnique(role model.SysRole) int64 {
	session := base.GetSession().Session.Table(role.TableName()).Where("role_name = ?", role.RoleName)
	if role.Id > 0 {
		session.And("id != ?", role.Id)
	}
	count, err := session.Count(&role)
	if err != nil {
		gotool.Logs.ErrorLog().Println(err)
	}
	return count
}

// CheckRoleKeyUnique 校验角色权限是否唯一
func (d RoleDao) CheckRoleKeyUnique(role model.SysRole) int64 {
	session := base.GetSession().Session.Table(role.TableName()).Where("role_key = ?", role.RoleKey)
	if role.Id > 0 {
		session.And("id != ?", role.Id)
	}
	count, err := session.Count(&role)
	if err != nil {
		gotool.Logs.ErrorLog().Println(err)
	}
	return count
}

// SelectRolesByUserName 查询角色组
func (d RoleDao) SelectRolesByUserName(name string) *[]model.SysRole {
	roles := make([]model.SysRole, 0)
	session := d.sqlSelectJoin()
	err := session.Where("r.del_flag = '0'").And("u.user_name = ?", name).Find(&roles)
	if err != nil {
		gotool.Logs.ErrorLog().Println(err)
		return nil
	}
	return &roles
}

func (d RoleDao) CheckUnique(role model.SysRole, condition []string) int64 {
	session := base.GetSession().Session.Table(role.TableName())
	if role.Id > 0 {
		session.And("id != ?", role.Id)
	}

	for _, item := range condition {
		fieldValue := reflect.ValueOf(role).FieldByName(utils.Ucfirst(item))
		if strings.Contains(fieldValue.Type().String(), "int") {
			session.And(utils.Camel2Case(item)+" = ?", fieldValue.Int())
		} else if strings.Contains(fieldValue.Type().String(), "string") {
			session.And(utils.Camel2Case(item)+" = ?", fieldValue.String())
		} else {
			session.And(utils.Camel2Case(item)+" = ?", fieldValue.String())
		}
	}
	count, err := session.Count()
	if err != nil {
		gotool.Logs.ErrorLog().Println(err)
	}
	return count
}