// +======================================================================
// | EasyGoAdmin 企业数字化开发平台 [ 赋能开发者，助力企业发展 ]
// +----------------------------------------------------------------------
// | Copyright (c) 2019-2026 半城风雨团队 版权所有
// +----------------------------------------------------------------------
// | 开源协议: Apache-2.0
// | 重要声明: 未经书面许可，不得移除或修改本框架相关版权标识。
// +----------------------------------------------------------------------
// | 官方网站: https://www.easygoadmin.vip
// +----------------------------------------------------------------------
// | 研发团队: 小蚂蚁云团队 荣誉出品
// +======================================================================
// | 版权和免责声明:
// | 一、知识产权声明
// | 本团队对该软件框架产品（以下简称“本产品”）拥有完整知识产权，包括但不限于商标权、专利权、
// | 著作权、商业秘密等。前述权利均受中华人民共和国及相关国际法律法规保护。未经本团队书面授权，
// | 任何个人或单位不得基于本产品本身申请任何形式的知识产权。
// | 二、使用限制与禁止条款
// | 您理解并同意，禁止将本产品用于以下任何行为：
// | 1. 任何违反中华人民共和国法律法规的用途；
// | 2. 任何侵害他人合法权益（包括但不限于人身权、财产权、知识产权等）的行为；
// | 3. 任何危害国家安全、公共利益及社会道德风尚的行为。
// | 三、责任豁免
// | 因使用本产品而产生的任何损失或法律纠纷（包括但不限于直接损失、间接损失、附带损失、衍生损失
// | 以及因违约、侵权等引发的责任），本团队均不承担任何法律责任。若因违规使用本产品导致任何第三
// | 方提起索赔或行政机关进行调查，您应独立承担全部责任。
// | 四、违约与法律责任
// | 如发现任何违反本声明的行为，本团队有权：
// | 1. 无条件配合公安机关及其他有权机关的调查取证工作；
// | 2. 依法追究相关方的民事责任，并要求赔偿全部损失；
// | 3. 保留进一步采取刑事控告等法律措施的权利。
// | 五、许可范围说明
// | 1、被授权方应视本产品源代码为核心机密信息，负有最高标准的保密与保管义务。禁止以任何形式（包
// | 括但不限于直接或间接的分享、复制、传播、分发、转售、出租、开源、反向工程、反编译、反汇编或通
// | 过网络服务提供给任何第三方）泄露、披露或处置源代码的全部或部分内容。任何未经授权的复制、使用、
// | 传播行为均构成对本团队知识产权的严重侵权，本团队有权依法追究其全部法律责任，并要求赔偿因此造
// | 成的一切经济损失及商誉损害。
// | 2、本产品仅限于公司或个人在法律允许范围内，用于内部且合规的软件产品研发。具体权利义务以《软件
// | 许可协议》附件为准。
// +======================================================================

package logic

import (
	"context"
	"fmt"
	"strconv"
	"strings"

	"github.com/gogf/gf/v2/database/gdb"
	"github.com/gogf/gf/v2/errors/gerror"

	"easygoadmin/api/v1"
	"easygoadmin/internal/consts"
	"easygoadmin/internal/dao"
	"easygoadmin/internal/service"
	"easygoadmin/utility/cache"
	"easygoadmin/utility/crypto"
	"easygoadmin/utility/excel"
	"easygoadmin/utility/upload"
)

// ============================== 用户业务实现 ==============================

// sUser 用户业务实现
// 实现 service.IUser 接口，承载用户模块的业务逻辑
type sUser struct{}

func init() {
	service.RegisterUser(&sUser{})
}

// userSerializeMaps 枚举字段到字典编码的映射
// {field}Text 由 dict_item 解析，字典管理页可修改文案
var userSerializeMaps = map[string]string{
	"gender": "user_gender",
	"status": "user_status",
}

// userSpec 用户模块声明
//
// Add、Update、Detail 涉及密码、城市、头像与角色装配，采用手写实现
var userSpec = ModuleSpec[v1.UserItem, v1.UserListItem, v1.UserDetailRes]{
	Model:         dao.User.Ctx,
	LikeFields:    []string{"realname"}, // querySchemas 姓名输入 → 模糊
	EqFields:      []string{"status", "dept_id", "level_id", "position_id", "tenant_id"},
	OrderBy:       "id DESC",
	ListOrderBy:   "sort, id",
	SerializeMaps: userSerializeMaps,
	FileFields:    []string{"avatar"}, // 读侧自动补域名（file.domainUrl）
	FileSaveDir:   "user",
	Filter:        userFilter,                // keyword 列 Page/List 有别 + role_id 子查询
	DataScope:     ApplyDataScope("dept_id"), // 角色数据权限（Page/List/导出生效）
	BeforeDelete:  userDeleteGuard,
	AfterDelete:   userCleanRelations, // 清理 user_role + 身份缓存
	AfterBatchDelete: func(ctx context.Context, ids []int64) error {
		return userCleanRelationsBatch(ctx, ids)
	},
	AfterPageList: userExpandNames, // 行内角色/部门/职级/岗位名批量补全
}

// userFilter 复杂筛选
//
// 关键词按入参分支，分页请求额外匹配手机号，并支持按角色ID过滤
func userFilter(ctx context.Context, m *gdb.Model, req any) *gdb.Model {
	switch r := req.(type) {
	case *v1.UserPageReq:
		if r.Keyword != "" {
			kw := "%" + r.Keyword + "%"
			m = m.Where("(username LIKE ? OR realname LIKE ? OR mobile LIKE ?)", kw, kw, kw)
		}
		roleId := r.RoleId
		if roleId == 0 {
			roleId = r.Role // 前端传参名兼容（role）
		}
		if roleId > 0 {
			m = m.WhereIn("id", dao.UserRole.Ctx(ctx).Where("role_id", roleId).Fields("user_id"))
		}
	case *v1.UserListReq:
		if r.Keyword != "" {
			kw := "%" + r.Keyword + "%"
			m = m.Where("(username LIKE ? OR realname LIKE ?)", kw, kw)
		}
	}
	return m
}

// userDeleteGuard 删除守卫
// 校验记录存在性
func userDeleteGuard(ctx context.Context, id int64) error {
	if n, err := dao.User.Ctx(ctx).Where("id", id).Count(); err != nil {
		return err
	} else if n == 0 {
		return gerror.NewCode(consts.CodeRecordNotFound)
	}
	return nil
}

// userCleanRelations 单条删除后清理
// 清理 user_role 关联并失效身份缓存
func userCleanRelations(ctx context.Context, id int64) error {
	return userCleanRelationsBatch(ctx, []int64{id})
}

// userCleanRelationsBatch 批量删除后清理
// 清理 user_role 关联并失效身份缓存
func userCleanRelationsBatch(ctx context.Context, ids []int64) error {
	if _, err := dao.UserRole.Ctx(ctx).WhereIn("user_id", ids).Delete(); err != nil {
		return err
	}
	for _, id := range ids {
		cache.Del(ctx,
			consts.CacheKeyUserIdentity(int(id)),
			consts.CacheKeyUserPerms(int(id)),
			consts.CacheKeyUserRoles(int(id)),
		)
	}
	return nil
}

// userExpandNames 分页行冗余装配
//
// 补全角色引用数组、城市编码数组、部门、职级、岗位名称及头像域名
func userExpandNames(ctx context.Context, list []*v1.UserItem, req any) error {
	if len(list) == 0 {
		return nil
	}
	ids := make([]int64, 0, len(list))
	for _, item := range list {
		ids = append(ids, item.Id)
	}
	// UserItem 无 dept/level/position/city id 列 → 按主键回查装配所需外键
	rows, err := dao.User.Ctx(ctx).WhereIn("id", ids).
		Fields("id, dept_id, level_id, position_id, province_code, city_code, district_code, street_code").All()
	if err != nil {
		return err
	}
	u := &sUser{}
	levelIds := make([]int64, 0)
	positionIds := make([]int64, 0)
	deptIds := make([]int64, 0)
	fkOf := make(map[int64]gdb.Record, len(rows))
	for _, r := range rows {
		fkOf[r["id"].Int64()] = r
		if v := r["level_id"].Int64(); v > 0 {
			levelIds = append(levelIds, v)
		}
		if v := r["position_id"].Int64(); v > 0 {
			positionIds = append(positionIds, v)
		}
		if v := r["dept_id"].Int64(); v > 0 {
			deptIds = append(deptIds, v)
		}
	}
	nameOfLevel := u.namesById(ctx, dao.Level.Ctx(ctx), levelIds)
	nameOfPosition := u.namesById(ctx, dao.Position.Ctx(ctx), positionIds)
	nameOfDept := u.namesById(ctx, dao.Dept.Ctx(ctx), deptIds)
	roleRefMap, err := u.userRoleRefs(ctx, ids)
	if err != nil {
		return err
	}
	for _, item := range list {
		item.Roles = roleRefMap[item.Id]
		if item.Roles == nil {
			item.Roles = []v1.UserRoleRef{}
		}
		if fk, ok := fkOf[item.Id]; ok {
			item.LevelName = nameOfLevel[fk["level_id"].Int64()]
			item.PositionName = nameOfPosition[fk["position_id"].Int64()]
			item.DeptName = nameOfDept[fk["dept_id"].Int64()]
			city := make([]string, 0, 4)
			for _, col := range []string{"province_code", "city_code", "district_code", "street_code"} {
				if v := fk[col].String(); v != "" {
					city = append(city, v)
				}
			}
			item.City = city
		}
		if item.City == nil {
			item.City = []string{}
		}
	}
	return nil
}

// Page 用户分页
//
// 支持关键词、状态、部门、角色、职级、岗位等条件，行内冗余名称批量补全
func (s *sUser) Page(ctx context.Context, req *v1.UserPageReq) (res *v1.UserPageRes, err error) {
	list, total, err := userSpec.Page(ctx, req, req.GetPageNo(), req.GetPageSize())
	if err != nil {
		return nil, err
	}
	return v1.NewPageData(req.GetPageNo(), req.GetPageSize(), total, derefSlice(list)), nil
}

// List 用户全量列表
//
// 供下拉选择使用，角色名在委托层后处理
func (s *sUser) List(ctx context.Context, req *v1.UserListReq) (res v1.UserListRes, err error) {
	list, err := userSpec.List(ctx, req)
	if err != nil {
		return nil, err
	}
	// 精简列表不挂基座钩子 → 角色名在委托层后处理
	roleMap, err := s.userRoleNames(ctx)
	if err != nil {
		return nil, err
	}
	for _, item := range list {
		item.Role = roleMap[item.Id]
	}
	return derefSlice(list), nil
}

// Detail 用户详情
//
// 含角色ID数组与四级区划编码，城市信息为空时按编码回填名称
func (s *sUser) Detail(ctx context.Context, req *v1.UserDetailReq) (res *v1.UserDetailRes, err error) {
	one, err := dao.User.Ctx(ctx).Where("id", req.Id).One()
	if err != nil {
		return nil, err
	}
	if len(one) == 0 {
		return nil, gerror.NewCode(consts.CodeRecordNotFound)
	}
	roleIds, err := s.userRoleIds(ctx, req.Id)
	if err != nil {
		return nil, err
	}
	detail := s.toDetail(ctx, one, roleIds)
	if detail.CityInfo == "" && len(detail.City) > 0 {
		detail.CityInfo = ResolveCityNames(ctx, detail.City, ",")
	}
	return detail, nil
}

// Add 新增用户
//
// 用户名与手机号租户内唯一，校验租户用户上限，自动生成用户编码并写入 user_role
func (s *sUser) Add(ctx context.Context, req *v1.UserAddReq) (res *v1.IdRes, err error) {
	tenantId := consts.GetTenantID(ctx)
	if exists, e := s.usernameExists(ctx, req.Username, tenantId, 0); e != nil {
		return nil, e
	} else if exists {
		return nil, gerror.NewCodef(consts.CodeRecordExists, "用户名已存在")
	}
	if req.Mobile != "" {
		if exists, e := s.mobileExists(ctx, req.Mobile, tenantId, 0); e != nil {
			return nil, e
		} else if exists {
			return nil, gerror.NewCodef(consts.CodeRecordExists, "手机号已被使用")
		}
	}
	if err = s.checkTenantUserMax(ctx, tenantId); err != nil {
		return nil, err
	}
	// 自动生成用户编码：{租户编码}-{租户内6位序号}（如 T0001-000020；平台租户用 SYS）
	code, err := genUserCode(ctx, tenantId)
	if err != nil {
		return nil, err
	}
	// 双重加盐：外部 salt + bcrypt(password+salt)，两值分别入 password/salt 列
	salt := crypto.GenerateSalt()
	hashed, err := crypto.HashPassword(req.Password, salt)
	if err != nil {
		return nil, err
	}
	status := req.Status
	if status == 0 {
		status = 1
	}
	data := map[string]any{
		"tenant_id":     tenantId,
		"code":          code,
		"username":      req.Username,
		"password":      hashed,
		"salt":          salt,
		"realname":      req.Realname,
		"gender":        req.Gender,
		"mobile":        req.Mobile,
		"email":         req.Email,
		"dept_id":       req.DeptId,
		"level_id":      req.LevelId,
		"position_id":   req.PositionId,
		"city_info":     req.CityInfo,
		"address":       req.Address,
		"avatar":        req.Avatar,
		"intro":         req.Intro,
		"status":        status,
		"sort":          req.Sort,
		"note":          req.Note,
		"province_code": cityCodeAt(req.City, 0),
		"city_code":     cityCodeAt(req.City, 1),
		"district_code": cityCodeAt(req.City, 2),
		"street_code":   cityCodeAt(req.City, 3),
	}
	// 头像 temp → 正式目录（入库形态为相对 uploadDir 的路径，剥离域名）
	data["avatar"] = SaveFileField(ctx, req.Avatar, "user")
	// 城市信息：优先由编码数组解析名称
	if len(req.City) > 0 {
		if info := ResolveCityNames(ctx, req.City, ","); info != "" {
			data["city_info"] = info
		}
	}
	result, err := dao.User.Ctx(ctx).Data(data).Insert()
	if err != nil {
		return nil, err
	}
	idv, _ := result.LastInsertId()
	if err = s.AssignRoles(ctx, idv, req.Roles); err != nil {
		return nil, err
	}
	return &v1.IdRes{Id: idv}, nil
}

// Update 修改用户
//
// 密码留空时不做修改，角色关联全量重写
func (s *sUser) Update(ctx context.Context, req *v1.UserUpdateReq) (res *v1.UserUpdateRes, err error) {
	if exists, e := s.usernameExists(ctx, req.Username, consts.GetTenantID(ctx), req.Id); e != nil {
		return nil, e
	} else if exists {
		return nil, gerror.NewCodef(consts.CodeRecordExists, "用户名已存在")
	}
	if req.Mobile != "" {
		if exists, e := s.mobileExists(ctx, req.Mobile, consts.GetTenantID(ctx), req.Id); e != nil {
			return nil, e
		} else if exists {
			return nil, gerror.NewCodef(consts.CodeRecordExists, "手机号已被使用")
		}
	}
	data := map[string]any{
		"username":      req.Username,
		"realname":      req.Realname,
		"gender":        req.Gender,
		"mobile":        req.Mobile,
		"email":         req.Email,
		"dept_id":       req.DeptId,
		"level_id":      req.LevelId,
		"position_id":   req.PositionId,
		"city_info":     req.CityInfo,
		"address":       req.Address,
		"avatar":        req.Avatar,
		"intro":         req.Intro,
		"status":        req.Status,
		"sort":          req.Sort,
		"note":          req.Note,
		"province_code": cityCodeAt(req.City, 0),
		"city_code":     cityCodeAt(req.City, 1),
		"district_code": cityCodeAt(req.City, 2),
		"street_code":   cityCodeAt(req.City, 3),
	}
	if len(req.City) > 0 {
		if info := ResolveCityNames(ctx, req.City, ","); info != "" {
			data["city_info"] = info
		}
	}
	data["avatar"] = SaveFileField(ctx, req.Avatar, "user")
	if req.Password != "" {
		salt := crypto.GenerateSalt()
		hashed, e := crypto.HashPassword(req.Password, salt)
		if e != nil {
			return nil, e
		}
		data["password"] = hashed
		data["salt"] = salt
	}
	if _, err = dao.User.Ctx(ctx).Where("id", req.Id).Data(data).Update(); err != nil {
		return nil, err
	}
	if err = s.AssignRoles(ctx, req.Id, req.Roles); err != nil {
		return nil, err
	}
	return &v1.UserUpdateRes{}, nil
}

// Status 用户状态
// 设置用户的正常或禁用状态
func (s *sUser) Status(ctx context.Context, req *v1.UserStatusReq) (res *v1.UserStatusRes, err error) {
	if _, err = dao.User.Ctx(ctx).Where("id", req.Id).Data(map[string]any{"status": req.Status}).Update(); err != nil {
		return nil, err
	}
	return &v1.UserStatusRes{}, nil
}

// ResetPwd 重置用户密码
// 未传新密码时重置为系统默认密码
func (s *sUser) ResetPwd(ctx context.Context, req *v1.UserResetPwdReq) (res *v1.UserResetPwdRes, err error) {
	if n, e := dao.User.Ctx(ctx).Where("id", req.UserId).Count(); e != nil {
		return nil, e
	} else if n == 0 {
		return nil, gerror.New("用户不存在")
	}
	password := req.Password
	if password == "" {
		password = getDefaultPassword(ctx)
	}
	salt := crypto.GenerateSalt()
	hashed, err := crypto.HashPassword(password, salt)
	if err != nil {
		return nil, err
	}
	if _, err = dao.User.Ctx(ctx).Where("id", req.UserId).Data(map[string]any{
		"password": hashed,
		"salt":     salt,
	}).Update(); err != nil {
		return nil, err
	}
	return &v1.UserResetPwdRes{}, nil
}

// Delete 删除用户
// 软删记录并清理 user_role 关联
func (s *sUser) Delete(ctx context.Context, req *v1.UserDeleteReq) (res *v1.UserDeleteRes, err error) {
	if err = userSpec.Delete(ctx, req.Id); err != nil {
		return nil, err
	}
	return &v1.UserDeleteRes{}, nil
}

// BatchDelete 批量删除用户
// 按用户ID列表批量删除记录
func (s *sUser) BatchDelete(ctx context.Context, req *v1.UserBatchDeleteReq) (res *v1.UserBatchDeleteRes, err error) {
	if err = userSpec.BatchDelete(ctx, req.Ids); err != nil {
		return nil, err
	}
	return &v1.UserBatchDeleteRes{}, nil
}

// Import 导入用户
//
// 表格列序：姓名、性别、手机号、邮箱、部门、职级、岗位、城市、地址、用户名、简介、状态、备注；
// 密码统一取系统默认密码，用户编码自动生成；
// 性别与状态支持文本或数字，部门、职级、岗位支持名称或ID，城市为逗号分隔的名称串
func (s *sUser) Import(ctx context.Context, req *v1.UserImportReq) (res *v1.UserImportRes, err error) {
	_, rows, err := excel.ReadSheet(req.File)
	if err != nil {
		return nil, err
	}
	res = &v1.UserImportRes{Total: len(rows)}
	tenantId := consts.GetTenantID(ctx)
	for i, row := range rows {
		username := cellAt(row, 9)
		if username == "" {
			res.Failed++
			res.Reasons = append(res.Reasons, fmt.Sprintf("第%d行：用户名为空", i+2))
			continue
		}
		if exists, e := s.usernameExists(ctx, username, tenantId, 0); e != nil {
			return nil, e
		} else if exists {
			res.Failed++
			res.Reasons = append(res.Reasons, fmt.Sprintf("第%d行：用户名已存在", i+2))
			continue
		}
		salt := crypto.GenerateSalt()
		hashed, e := crypto.HashPassword(getDefaultPassword(ctx), salt)
		if e != nil {
			res.Failed++
			res.Reasons = append(res.Reasons, fmt.Sprintf("第%d行：密码加密失败", i+2))
			continue
		}
		code, e := genUserCode(ctx, tenantId)
		if e != nil {
			return nil, e
		}
		cityInfo := cellAt(row, 7)
		codes := ResolveCityCodes(ctx, cityInfo)
		if _, e = dao.User.Ctx(ctx).Data(map[string]any{
			"username":      username,
			"realname":      cellAt(row, 0),
			"code":          code,
			"password":      hashed,
			"salt":          salt,
			"gender":        parseGenderCell(cellAt(row, 1)),
			"mobile":        cellAt(row, 2),
			"email":         cellAt(row, 3),
			"dept_id":       resolveRefID(ctx, dao.Dept.Ctx(ctx), cellAt(row, 4)),
			"level_id":      resolveRefID(ctx, dao.Level.Ctx(ctx), cellAt(row, 5)),
			"position_id":   resolveRefID(ctx, dao.Position.Ctx(ctx), cellAt(row, 6)),
			"city_info":     cityInfo,
			"address":       cellAt(row, 8),
			"intro":         cellAt(row, 10),
			"status":        parseStatusCell(cellAt(row, 11)),
			"note":          cellAt(row, 12),
			"tenant_id":     tenantId,
			"province_code": codes[0],
			"city_code":     codes[1],
			"district_code": codes[2],
			"street_code":   codes[3],
		}).Insert(); e != nil {
			res.Failed++
			res.Reasons = append(res.Reasons, fmt.Sprintf("第%d行：写入失败 %v", i+2, e))
			continue
		}
		res.Success++
	}
	return res, nil
}

// Export 导出用户
//
// 列序对齐导出模板，每批 500 条防 OOM，写出 xlsx 并返回访问地址
func (s *sUser) Export(ctx context.Context, req *v1.UserExportReq) (res *v1.UserExportRes, err error) {
	// 部门/职级/岗位 ID→名称（小维表全量加载，行内引用）
	deptNames, err := idNameMap(ctx, dao.Dept.Ctx(ctx))
	if err != nil {
		return nil, err
	}
	levelNames, err := idNameMap(ctx, dao.Level.Ctx(ctx))
	if err != nil {
		return nil, err
	}
	positionNames, err := idNameMap(ctx, dao.Position.Ctx(ctx))
	if err != nil {
		return nil, err
	}
	headers := []string{"用户编码", "姓名", "性别", "手机号", "邮箱", "部门", "职级", "岗位", "城市", "地址", "用户名", "简介", "状态", "备注"}
	var rows [][]any
	// 分块遍历导出（每页重建查询防 OOM；并发写入下可能有翻页漂移，导出场景可接受）
	if err = ChunkQuery(ctx, func(page, size int) *gdb.Model {
		m := userSpec.applyFilters(ctx, dao.User.Ctx(ctx), req)
		return m.Page(page, size).Order("id DESC")
	}, 500, func(part gdb.Result) error {
		for _, r := range part {
			codes := make([]string, 0, 4)
			for _, col := range []string{"province_code", "city_code", "district_code", "street_code"} {
				if v := r[col].String(); v != "" {
					codes = append(codes, v)
				}
			}
			// 城市优先由四级编码解析名称，编码缺失时回退 city_info 存量值
			city := ResolveCityNames(ctx, codes, ",")
			if city == "" {
				city = r["city_info"].String()
			}
			rows = append(rows, []any{
				r["code"].String(), r["realname"].String(), genderText(r["gender"].Int()),
				r["mobile"].String(), r["email"].String(),
				deptNames[r["dept_id"].Int64()], levelNames[r["level_id"].Int64()],
				positionNames[r["position_id"].Int64()], city, r["address"].String(),
				r["username"].String(), r["intro"].String(),
				userStatusText(r["status"].Int()), r["note"].String(),
			})
		}
		return nil
	}); err != nil {
		return nil, err
	}
	fileName, _, err := excel.WriteSheet(upload.BaseDir(ctx), "用户数据", headers, rows)
	if err != nil {
		return nil, err
	}
	url := upload.GetFileUrl(ctx, fileName)
	return &url, nil
}

// Document 用户打印信息
//
// 在用户详情基础上追加角色、部门、职级、岗位名称
func (s *sUser) Document(ctx context.Context, req *v1.UserDocumentReq) (res *v1.UserDocumentRes, err error) {
	one, err := dao.User.Ctx(ctx).Where("id", req.Id).One()
	if err != nil {
		return nil, err
	}
	if len(one) == 0 {
		return nil, gerror.NewCode(consts.CodeRecordNotFound)
	}
	roleIds, err := s.userRoleIds(ctx, req.Id)
	if err != nil {
		return nil, err
	}
	detail := s.toDetail(ctx, one, roleIds)
	res = &v1.UserDocumentRes{UserDetailRes: *detail, RoleNames: []string{}}
	if len(roleIds) > 0 {
		roleRows, e := dao.Role.Ctx(ctx).WhereIn("id", roleIds).All()
		if e == nil {
			for _, r := range roleRows {
				res.RoleNames = append(res.RoleNames, r["name"].String())
			}
		}
	}
	res.DeptName = s.dictName(ctx, dao.Dept.Ctx(ctx), one["dept_id"].Int())
	res.LevelName = s.dictName(ctx, dao.Level.Ctx(ctx), one["level_id"].Int())
	res.PositionName = s.dictName(ctx, dao.Position.Ctx(ctx), one["position_id"].Int())
	return res, nil
}

// AssignRoles 重写用户角色关联
//
// 供新增与修改调用，完成后失效该用户的身份缓存
func (s *sUser) AssignRoles(ctx context.Context, userId int64, roleIds []int64) error {
	if _, err := dao.UserRole.Ctx(ctx).Where("user_id", userId).Delete(); err != nil {
		return err
	}
	for _, rid := range roleIds {
		if rid <= 0 {
			continue
		}
		if _, err := dao.UserRole.Ctx(ctx).Data(map[string]any{
			"user_id": userId,
			"role_id": rid,
		}).Insert(); err != nil {
			return err
		}
	}
	s.clearIdentityCache(ctx, userId)
	return nil
}

// ---------- 私有辅助 ----------

// clearIdentityCache 权限相关缓存失效
// 采用尽力而为策略
func (s *sUser) clearIdentityCache(ctx context.Context, userId int64) {
	cache.Del(ctx,
		consts.CacheKeyUserIdentity(int(userId)),
		consts.CacheKeyUserPerms(int(userId)),
		consts.CacheKeyUserRoles(int(userId)),
	)
}

// usernameExists 判断用户名是否已存在
// tenantId 限定租户，excludeId 排除自身
func (s *sUser) usernameExists(ctx context.Context, username string, tenantId int, excludeId int64) (bool, error) {
	m := dao.User.Ctx(ctx).Where("username", username).Where("tenant_id", tenantId)
	if excludeId > 0 {
		m = m.WhereNot("id", excludeId)
	}
	count, err := m.Count()
	return count > 0, err
}

// mobileExists 判断手机号是否已存在
func (s *sUser) mobileExists(ctx context.Context, mobile string, tenantId int, excludeId int64) (bool, error) {
	m := dao.User.Ctx(ctx).Where("mobile", mobile).Where("tenant_id", tenantId)
	if excludeId > 0 {
		m = m.WhereNot("id", excludeId)
	}
	count, err := m.Count()
	return count > 0, err
}

// checkTenantUserMax 校验租户用户数上限
func (s *sUser) checkTenantUserMax(ctx context.Context, tenantId int) error {
	if tenantId == 0 {
		return nil
	}
	one, err := dao.Tenant.Ctx(ctx).Where("id", tenantId).One()
	if err != nil || len(one) == 0 {
		return nil
	}
	maxNum := one["max_user_num"].Int()
	if maxNum <= 0 {
		return nil
	}
	count, err := dao.User.Ctx(ctx).Where("tenant_id", tenantId).Count()
	if err != nil {
		return err
	}
	if count >= maxNum {
		return gerror.NewCode(consts.CodeTenantUserLimit)
	}
	return nil
}

// genUserCode 生成用户编码
//
// 格式为 {租户编码}-{租户内6位序号}，如 T0001-000020；平台租户前缀为 SYS。
// 序号取租户内未删除用户数加一，与现有编码顺延
func genUserCode(ctx context.Context, tenantId int) (string, error) {
	prefix := "SYS"
	if tenantId > 0 {
		one, err := dao.Tenant.Ctx(ctx).Where("id", tenantId).Fields("code").One()
		if err != nil {
			return "", err
		}
		if len(one) == 0 {
			return "", gerror.NewCode(consts.CodeTenantNotFound)
		}
		prefix = one["code"].String()
	}
	n, err := dao.User.Ctx(ctx).Where("tenant_id", tenantId).Count()
	if err != nil {
		return "", err
	}
	return fmt.Sprintf("%s-%06d", prefix, n+1), nil
}

// userRoleIds 查询用户的角色ID列表
func (s *sUser) userRoleIds(ctx context.Context, userId int64) ([]int64, error) {
	rows, err := dao.UserRole.Ctx(ctx).Where("user_id", userId).All()
	if err != nil {
		return nil, err
	}
	ids := make([]int64, 0, len(rows))
	for _, r := range rows {
		ids = append(ids, r["role_id"].Int64())
	}
	return ids, nil
}

// userRoleRefs 批量查询用户角色引用数组
//
// 返回用户ID到角色引用的映射，一次查询避免 N+1
func (s *sUser) userRoleRefs(ctx context.Context, userIds []int64) (map[int64][]v1.UserRoleRef, error) {
	result := make(map[int64][]v1.UserRoleRef)
	if len(userIds) == 0 {
		return result, nil
	}
	// 注意：不可给主表起别名——dao.Ctx 注入的软删条件使用完整表名，带别名时 MySQL 无法解析
	urTable := dao.UserRole.Table()
	roleData, err := dao.UserRole.Ctx(ctx).
		LeftJoin(dao.Role.Table()+" r", urTable+".role_id = r.id AND r.del_flag=0").
		WhereIn(urTable+".user_id", userIds).
		Fields(urTable + ".user_id, r.id, r.name").
		Order(urTable + ".role_id").
		All()
	if err != nil {
		return nil, err
	}
	for _, rd := range roleData {
		uid := rd["user_id"].Int64()
		result[uid] = append(result[uid], v1.UserRoleRef{
			Id:   rd["id"].Int64(),
			Name: rd["name"].String(),
		})
	}
	return result, nil
}

// userRoleNames 查询用户ID到角色名的映射
// 多个角色名以逗号分隔
func (s *sUser) userRoleNames(ctx context.Context) (map[int64]string, error) {
	result := make(map[int64]string)
	urRows, err := dao.UserRole.Ctx(ctx).All()
	if err != nil {
		return nil, err
	}
	if len(urRows) == 0 {
		return result, nil
	}
	byUser := make(map[int64][]int64)
	roleIds := make([]int64, 0, len(urRows))
	for _, r := range urRows {
		uid, rid := r["user_id"].Int64(), r["role_id"].Int64()
		byUser[uid] = append(byUser[uid], rid)
		roleIds = append(roleIds, rid)
	}
	nameById := make(map[int64]string)
	roleRows, err := dao.Role.Ctx(ctx).WhereIn("id", roleIds).All()
	if err != nil {
		return nil, err
	}
	for _, r := range roleRows {
		nameById[r["id"].Int64()] = r["name"].String()
	}
	for uid, ids := range byUser {
		names := ""
		for i, rid := range ids {
			if i > 0 {
				names += ","
			}
			names += nameById[rid]
		}
		result[uid] = names
	}
	return result, nil
}

// toDetail 数据库记录转换为用户详情
func (s *sUser) toDetail(ctx context.Context, row gdb.Record, roleIds []int64) *v1.UserDetailRes {
	if roleIds == nil {
		roleIds = []int64{}
	}
	city := make([]string, 0, 4)
	for _, col := range []string{"province_code", "city_code", "district_code", "street_code"} {
		if v := row[col].String(); v != "" {
			city = append(city, v)
		}
	}
	return &v1.UserDetailRes{
		Id:         row["id"].Int64(),
		Username:   row["username"].String(),
		Realname:   row["realname"].String(),
		Avatar:     upload.GetFileUrl(ctx, row["avatar"].String()), // 逃生舱手拼 DTO，直接调底层公共助手补域名
		Gender:     row["gender"].Int(),
		GenderText: DictGetText(ctx, userSerializeMaps["gender"], row["gender"].Int()),
		Mobile:     row["mobile"].String(),
		Email:      row["email"].String(),
		Roles:      roleIds,
		DeptId:     row["dept_id"].Int(),
		LevelId:    row["level_id"].Int(),
		PositionId: row["position_id"].Int(),
		City:       city,
		CityInfo:   row["city_info"].String(),
		Address:    row["address"].String(),
		Intro:      row["intro"].String(),
		Status:     row["status"].Int(),
		StatusText: DictGetText(ctx, userSerializeMaps["status"], row["status"].Int()),
		Sort:       row["sort"].Int(),
		Note:       row["note"].String(),
	}
}

// namesById 查询ID到名称的映射
// 传入的模型需已构造好上下文
func (s *sUser) namesById(ctx context.Context, m *gdb.Model, ids []int64) map[int64]string {
	result := make(map[int64]string)
	if len(ids) == 0 {
		return result
	}
	rows, err := m.WhereIn("id", ids).Fields("id, name").All()
	if err != nil {
		return result
	}
	for _, r := range rows {
		result[r["id"].Int64()] = r["name"].String()
	}
	return result
}

// dictName 按ID查询名称
// 适用于部门、职级、岗位等通用维表
func (s *sUser) dictName(ctx context.Context, m *gdb.Model, idv int) string {
	if idv <= 0 {
		return ""
	}
	one, err := m.Where("id", idv).Fields("name").One()
	if err != nil || len(one) == 0 {
		return ""
	}
	return one["name"].String()
}

// cityCodeAt 按下标取城市编码
// 下标越界时返回空串
func cityCodeAt(cities []string, i int) string {
	if i < len(cities) {
		return cities[i]
	}
	return ""
}

// cellAt 按下标取单元格文本
// 下标越界时返回空串
func cellAt(row []string, i int) string {
	if i < len(row) {
		return row[i]
	}
	return ""
}

// cellInt 按下标取单元格整数
// 解析失败时返回默认值
func cellInt(row []string, i, def int) int {
	if v := cellAt(row, i); v != "" {
		if n, err := strconv.Atoi(v); err == nil {
			return n
		}
	}
	return def
}

// idNameMap 加载维表的ID到名称映射
// 供部门、职级、岗位导出人读化使用
func idNameMap(ctx context.Context, m *gdb.Model) (map[int64]string, error) {
	rows, err := m.Fields("id, name").All()
	if err != nil {
		return nil, err
	}
	result := make(map[int64]string, len(rows))
	for _, r := range rows {
		result[r["id"].Int64()] = r["name"].String()
	}
	return result, nil
}

// resolveRefID 解析引用列
// 数字按ID处理，非数字按名称反查，未命中时返回 0
func resolveRefID(ctx context.Context, m *gdb.Model, v string) int64 {
	v = strings.TrimSpace(v)
	if v == "" {
		return 0
	}
	if n, err := strconv.ParseInt(v, 10, 64); err == nil {
		return n
	}
	id, err := m.Where("name", v).Fields("id").Value()
	if err != nil {
		return 0
	}
	return id.Int64()
}

// parseGenderCell 解析性别单元格
// 支持男、女、保密文本或 1、2、3 数字，其余取保密
func parseGenderCell(v string) int {
	switch strings.TrimSpace(v) {
	case "男":
		return 1
	case "女":
		return 2
	case "保密":
		return 3
	}
	if n, err := strconv.Atoi(strings.TrimSpace(v)); err == nil && n >= 1 && n <= 3 {
		return n
	}
	return 3
}

// parseStatusCell 解析状态单元格
// 支持正常、禁用文本或 1、2 数字，其余取正常
func parseStatusCell(v string) int {
	switch strings.TrimSpace(v) {
	case "正常":
		return 1
	case "禁用":
		return 2
	}
	if n, err := strconv.Atoi(strings.TrimSpace(v)); err == nil && n > 0 {
		return n
	}
	return 1
}

// genderText 性别值转文本
func genderText(g int) string {
	switch g {
	case 1:
		return "男"
	case 2:
		return "女"
	default:
		return "保密"
	}
}

// userStatusText 用户状态值转文本
func userStatusText(st int) string {
	if st == 1 {
		return "正常"
	}
	return "禁用"
}