package service

import (
	"fmt"
	"time"

	"joylink.club/bj-rtsts-server/db/dbquery"
	"joylink.club/bj-rtsts-server/db/model"
	"joylink.club/bj-rtsts-server/dto"
	"joylink.club/bj-rtsts-server/sys_error"
)

// 查询权限角色信息列表
func PageAuthRoleQuery(query *dto.PageQueryDto) *dto.PageDto[*dto.AuthRoleRspDto] {
	d := dbquery.AuthRole
	records, total, err := d.Debug().Select(d.ID, d.Name).Order(d.CreateTime).FindByPage(query.Offset(), query.Size)
	if err != nil {
		panic(sys_error.New("查询权限数据库出错，请联系维护人员", err))
	}
	return &dto.PageDto[*dto.AuthRoleRspDto]{Total: int(total), PageQueryDto: *query, Records: dto.ConvertFromAuthRole(records)}
}

// 获取角色列表
func ListAuthRoleQuery() []*dto.AuthRoleRspDto {
	d := dbquery.AuthRole
	records, err := d.Debug().Select(d.ID, d.Name).Order(d.CreateTime).Find()
	if err != nil {
		panic(sys_error.New("查询权限数据库出错，请联系维护人员", err))
	}
	return dto.ConvertFromAuthRole(records)
}

// 创建权限角色
func CreateAuthRole(a *dto.AuthRoleReqDto) bool {
	d := model.AuthRole{Name: a.Name, CreateTime: time.Now()}
	aq := dbquery.AuthRole
	err := aq.Save(&d)
	if err != nil {
		panic(sys_error.New("保存权限数据库出错，请联系维护人员", err))
	}
	n := len(a.AddPaths)
	if n == 0 {
		return true
	}
	// 查询刚插入的角色
	newAuthRole, _ := aq.Where(aq.Name.Eq(a.Name)).Order(aq.CreateTime).Last()
	rolePaths := make([]*model.AuthRoleAPIPath, n)
	for i, v := range a.AddPaths {
		rolePaths[i] = &model.AuthRoleAPIPath{Rid: newAuthRole.ID, Pid: v}
	}
	dbquery.AuthRoleAPIPath.Save(rolePaths...)
	return true
}

// 查询角色详情
func QueryAuthRole(rid int32) *dto.AuthRoleDetailRspDto {
	// 查询用户角色信息
	role, err := dbquery.AuthRole.Where(dbquery.AuthRole.ID.Eq(rid)).First()
	if err != nil {
		panic(sys_error.New("查询角色数据库出错，请联系维护人员", err))
	}
	rsp := &dto.AuthRoleDetailRspDto{
		Id:    role.ID,
		Name:  role.Name,
		Paths: QueryAuthApiPathByRids([]int32{rid}),
	}
	return rsp
}

// 查询用户的角色
func QueryAuthRoleByUid(uid int32) []*model.AuthRole {
	aru := dbquery.AuthRoleUser
	arus, err1 := aru.Distinct(aru.Rid).Select(aru.Rid).Where(aru.UID.Eq(uid)).Find()
	if err1 != nil {
		panic(sys_error.New("查询角色数据库出错，请联系维护人员", err1))
	}
	if len(arus) == 0 {
		return nil
	}
	rids := make([]int32, len(arus))
	for i, v := range arus {
		rids[i] = v.Rid
	}
	roles, err2 := dbquery.AuthRole.Where(dbquery.AuthRole.ID.In(rids...)).Find()
	if err2 != nil {
		panic(sys_error.New("查询角色数据库发生错误，请联系维护人员", err2))
	}
	return roles
}

// 编辑角色信息
func UpdateAuthRole(rid int32, info *dto.AuthRoleReqDto) bool {
	// 查询用户角色信息
	role, err := dbquery.AuthRole.Where(dbquery.AuthRole.ID.Eq(rid)).First()
	if err != nil {
		panic(sys_error.New("更新角色数据库发生错误，不存在此用户", err))
	}
	role.Name = info.Name // 更新名称
	dbquery.AuthRole.Updates(role)
	dqarap := dbquery.AuthRoleAPIPath
	// 删除关联
	rn := len(info.DelPaths)
	if rn > 0 {
		dqarap.Where(dqarap.Rid.Eq(rid), dqarap.Pid.In(info.DelPaths...)).Delete()
	}
	// 增加关联
	an := len(info.AddPaths)
	if an == 0 {
		return true
	}
	rolePaths := make([]*model.AuthRoleAPIPath, an)
	for i, v := range info.AddPaths {
		rolePaths[i] = &model.AuthRoleAPIPath{Rid: rid, Pid: v}
	}
	dqarap.Save(rolePaths...)
	return true
}

// 删除权限角色
func DeleteAuthRole(rid int32) bool {
	oldD, err1 := dbquery.AuthRole.Where(dbquery.AuthRole.ID.Eq(rid)).First()
	if err1 != nil {
		panic(sys_error.New("删除权限角色数据库发生错误", err1))
	}
	if dto.IsSystemRole(oldD.ID) {
		panic(sys_error.New("系统角色不可删除", err1))
	}
	// 如果有用户关联则不删除
	count, err2 := dbquery.AuthRoleUser.Where(dbquery.AuthRoleUser.Rid.Eq(rid)).Count()
	if err2 != nil {
		panic(sys_error.New("删除失败，还存在用户关联", err2))
	}
	if count > 0 {
		panic(sys_error.New("删除失败，有用户关联该角色"))
	}
	// 删除用户关联关系
	dbquery.AuthRoleUser.Where(dbquery.AuthRoleUser.Rid.Eq(rid)).Delete()
	// 删除路径关联关系
	dbquery.AuthRoleAPIPath.Where(dbquery.AuthRoleAPIPath.Rid.Eq(rid)).Delete()
	// 删除角色
	dbquery.AuthRole.Where(dbquery.AuthRole.ID.Eq(rid)).Delete()
	return true
}

// 查询接口路径信息列表
func PageAuthApiPathQuery(query *dto.AuthApiPathPageReqDto) *dto.PageDto[*model.AuthAPIPath] {
	d := dbquery.AuthAPIPath
	dq := d.Where()
	if query.Name != "" {
		dq = dq.Where(d.Name.Like(fmt.Sprintf("%%%s%%", query.Name)))
	}
	records, total, err := dq.Debug().FindByPage(query.Offset(), query.Size)
	if err != nil {
		panic(dto.ErrorDto{Code: dto.DataOperationError, Message: err.Error()})
	}
	return &dto.PageDto[*model.AuthAPIPath]{Total: int(total), PageQueryDto: query.PageQueryDto, Records: records}
}

// 查询接口路径信息列表
func ListAuthApiPathQuery() []*model.AuthAPIPath {
	records, err := dbquery.AuthAPIPath.Find()
	if err != nil {
		panic(dto.ErrorDto{Code: dto.DataOperationError, Message: err.Error()})
	}
	return records
}

// 创建接口路径信息
func CreateAuthApiPath(ap *dto.AuthApiPathReqDto) bool {
	d := model.AuthAPIPath{Name: ap.Name, Path: ap.Path, Method: ap.Method}
	err := dbquery.AuthAPIPath.Save(&d)
	if err != nil {
		panic(dto.ErrorDto{Code: dto.DataOperationError, Message: err.Error()})
	}
	return true
}

// 查询接口路径信息
func QueryAuthApiPath(id int32) *model.AuthAPIPath {
	data, err := dbquery.AuthAPIPath.Where(dbquery.AuthAPIPath.ID.Eq(id)).Debug().First()
	if err != nil {
		panic(dto.ErrorDto{Code: dto.DataOperationError, Message: err.Error()})
	}
	return data
}

// 根据角色ID查询路径信息
func QueryAuthApiPathByRids(rids []int32) []*model.AuthAPIPath {
	rn := len(rids)
	if rn == 0 {
		return nil
	}
	// 判断是否是超级管理
	isAdmin := false
	for i := 0; i < rn && !isAdmin; i++ {
		isAdmin = rids[i] == int32(dto.ADMIN)
	}
	if isAdmin { // 超级管理员查询所有路径
		apiPaths, _ := dbquery.AuthAPIPath.Find()
		return apiPaths
	}
	linkPids, err2 := dbquery.AuthRoleAPIPath.Distinct(dbquery.AuthRoleAPIPath.Pid).Where(dbquery.AuthRoleAPIPath.Rid.In(rids...)).Find()
	if err2 != nil {
		panic(dto.ErrorDto{Code: dto.DataOperationError, Message: err2.Error()})
	}
	pn := len(linkPids)
	if pn == 0 { // 无关联路径
		return nil
	}
	pids := make([]int32, pn)
	for i, r := range linkPids {
		pids[i] = r.Pid
	}
	apiPaths, err4 := dbquery.AuthAPIPath.Where(dbquery.AuthAPIPath.ID.In(pids...)).Find()
	if err4 != nil {
		panic(dto.ErrorDto{Code: dto.DataOperationError, Message: err4.Error()})
	}
	return apiPaths
}

// 更新接口路径信息
func UpdateAuthApiPath(id int32, a *dto.AuthApiPathReqDto) bool {
	dbqa := dbquery.AuthAPIPath
	oldD, err1 := dbqa.Where(dbqa.ID.Eq(id)).Debug().First()
	if oldD == nil || err1 != nil {
		panic(dto.ErrorDto{Code: dto.DataOperationError, Message: err1.Error()})
	}
	oldD.Name = a.Name
	oldD.Path = a.Path
	oldD.Method = a.Method
	_, err2 := dbqa.Updates(oldD)
	if err2 != nil {
		panic(dto.ErrorDto{Code: dto.DataOperationError, Message: err2.Error()})
	}
	return true
}

// 删除接口路径信息
func DeleteAuthApiPath(id int32) bool {
	_, err1 := dbquery.AuthAPIPath.Where(dbquery.AuthAPIPath.ID.Eq(id)).First()
	if err1 != nil {
		panic(dto.ErrorDto{Code: dto.DataOperationError, Message: err1.Error()})
	}
	// 删除角色中的路径信息
	dbquery.AuthRoleAPIPath.Where(dbquery.AuthRoleAPIPath.Pid.Eq(id)).Delete()
	// 删除接口路径信息
	dbquery.AuthAPIPath.Where(dbquery.AuthAPIPath.ID.Eq(id)).Delete()
	return true
}

// 用户关联角色信息
func UserLinkRole(linkInfo *dto.AuthRoleUserReqDto) bool {
	dbar := dbquery.AuthRoleUser
	// 删除角色关联信息
	_, err1 := dbar.Where(dbar.UID.Eq(linkInfo.Uid), dbar.Rid.In(linkInfo.DelRids...)).Delete()
	if err1 != nil {
		panic(dto.ErrorDto{Code: dto.DataOperationError, Message: err1.Error()})
	}
	// 插入关联关系
	n := len(linkInfo.AddRids)
	if n == 0 {
		return true
	}
	arul := make([]*model.AuthRoleUser, n)
	for i, l := range linkInfo.AddRids {
		arul[i] = &model.AuthRoleUser{UID: linkInfo.Uid, Rid: l}
	}
	err2 := dbar.Save(arul...)
	if err2 != nil {
		panic(dto.ErrorDto{Code: dto.DataOperationError, Message: err2.Error()})
	}
	return true
}

// 查询用户权限信息
func QueryUserAuthApiPath(uid int32) *dto.AuthUserStorageDto {
	authUser := &dto.AuthUserStorageDto{UID: uid, IsAdmin: false}
	// 查询用户角色
	roles := QueryAuthRoleByUid(uid)
	rn := len(roles)
	rids := make([]int32, rn+1)
	if rn > 0 {
		for i, r := range roles {
			rids[i] = r.ID
			authUser.IsAdmin = authUser.IsAdmin || (r.ID == int32(dto.ADMIN))
		}
		if authUser.IsAdmin { // 管理员直接返回
			return authUser
		}
	}
	rids[rn] = int32(dto.USER)                             // 最后添加一个普通用户角色
	apiPaths := QueryAuthApiPathByRids(rids)               // 查询角色拥有的权限路径
	authUser.AuthPaths = dto.ConvertFromAuthPath(apiPaths) // 赋值路径数组
	return authUser
}