package user

import (
	"context"
	"errors"
	"time"

	"perms-system-server/internal/consts"
	"perms-system-server/internal/loaders"
	authHelper "perms-system-server/internal/logic/auth"
	"perms-system-server/internal/middleware"
	"perms-system-server/internal/model/userrole"
	"perms-system-server/internal/response"
	"perms-system-server/internal/svc"
	"perms-system-server/internal/types"

	"github.com/zeromicro/go-zero/core/logx"
	"github.com/zeromicro/go-zero/core/stores/sqlx"
)

type BindRolesLogic struct {
	logx.Logger
	ctx    context.Context
	svcCtx *svc.ServiceContext
}

func NewBindRolesLogic(ctx context.Context, svcCtx *svc.ServiceContext) *BindRolesLogic {
	return &BindRolesLogic{
		Logger: logx.WithContext(ctx),
		ctx:    ctx,
		svcCtx: svcCtx,
	}
}

// BindRoles 绑定用户角色。对指定用户在当前产品下做角色全量覆盖（diff 后批量新增/删除），支持权限级别校验防止越权分配。
func (l *BindRolesLogic) BindRoles(req *types.BindRolesReq) error {
	caller := middleware.GetUserDetails(l.ctx)
	if caller == nil {
		return response.ErrUnauthorized("未登录")
	}

	// 审计 L-R13-1：在读 target 之前做一次"最低资格"闸——非超管且当前产品上下文里 MemberType
	// 为空的调用方（仅持有 JWT 但不是本产品成员）一定无法通过后续的 CheckManageAccess
	// （checkPermLevel 对 caller MaxInt32 优先级 > 任意 target），提前 403 可以避免通过 404
	// 枚举 userId 存在性。本闸不覆盖 MEMBER/DEVELOPER——他们仍需走 CheckManageAccess 判定
	// 部门链 + permsLevel 是否够高，与现有语义保持一致。
	if !caller.IsSuperAdmin && caller.MemberType == "" {
		return response.ErrForbidden("缺少产品成员上下文")
	}

	targetUser, err := l.svcCtx.SysUserModel.FindOne(l.ctx, req.UserId)
	if err != nil {
		return response.ErrNotFound("用户不存在")
	}

	productCode := middleware.GetProductCode(l.ctx)
	if err := authHelper.CheckManageAccess(l.ctx, l.svcCtx, req.UserId, productCode, authHelper.WithPrefetchedTarget(targetUser)); err != nil {
		return err
	}

	member, err := l.svcCtx.SysProductMemberModel.FindOneByProductCodeUserId(l.ctx, productCode, req.UserId)
	if err != nil {
		return response.ErrBadRequest("目标用户不是当前产品的成员")
	}
	if member.Status != consts.StatusEnabled {
		return response.ErrBadRequest("目标用户的成员资格已被禁用")
	}

	roleIds := req.RoleIds
	if len(roleIds) > 0 {
		seen := make(map[int64]bool, len(roleIds))
		uniqueIds := make([]int64, 0, len(roleIds))
		for _, id := range roleIds {
			if !seen[id] {
				seen[id] = true
				uniqueIds = append(uniqueIds, id)
			}
		}
		roleIds = uniqueIds
	}

	if len(roleIds) > 0 {
		roles, err := l.svcCtx.SysRoleModel.FindByIds(l.ctx, roleIds)
		if err != nil {
			return err
		}
		if int64(len(roles)) != int64(len(roleIds)) {
			return response.ErrBadRequest("包含无效的角色ID")
		}
		// 审计 M-R10-3：caller 在一次请求内不变，loadFreshMinPermsLevel 的结果也不变；改由
		// LoadCallerAssignableLevel 打一次 DB 取 snapshot，循环内对每个角色走 CheckRoleLevelAgainst
		// 做常数时间比较，把"批量绑 N 个 role → N 次 DB" 降到 1 次，同时缩小 caller 降权期间
		// 的 TOCTOU 窗口（原实现每次循环都重新读，反而给"超管在 loop 中途降级 caller"N 个窗口）。
		assignable, err := authHelper.LoadCallerAssignableLevel(l.ctx, l.svcCtx, caller)
		if err != nil {
			return err
		}
		for _, r := range roles {
			if r.ProductCode != productCode {
				return response.ErrBadRequest("不能绑定其他产品的角色")
			}
			if r.Status != consts.StatusEnabled {
				return response.ErrBadRequest("不能绑定已禁用的角色")
			}
			if err := authHelper.CheckRoleLevelAgainst(assignable, r.PermsLevel); err != nil {
				return err
			}
		}
	}

	newSet := make(map[int64]bool, len(roleIds))
	for _, id := range roleIds {
		newSet[id] = true
	}

	// 审计 M-R10-2：把"existing 读 + diff + delete/insert"整段收敛进事务，事务第一步以
	// FindOneForUpdateTx(member.Id) 锁住 sys_product_member 行，相当于把同一 (userId,
	// productCode) 下的并发 BindRoles 串行化；"A 完整覆盖 → B 基于 A 的最终态覆盖" 是唯一
	// 可能的交错，消除 RMW 第三态。member 行 lock 也保证了进入事务期间 member 不会被并发
	// RemoveMember 清零（那条路径本身也持该行 FOR UPDATE）。
	if err := l.svcCtx.SysUserRoleModel.TransactCtx(l.ctx, func(ctx context.Context, session sqlx.Session) error {
		if _, err := l.svcCtx.SysProductMemberModel.FindOneForUpdateTx(ctx, session, member.Id); err != nil {
			return err
		}

		// 审计 M-R12-1：对本次将要出现在 sys_user_role 里的 roleIds（事务外校验通过的入参集合）
		// 加 S 锁，闭合与 DeleteRole 的写偏斜。DeleteRole 末尾对 sys_role[R] 的 X 锁会被本 S 锁
		// 阻塞；等 BindRoles 提交后，DeleteRole 会在 FindUserIdsByRoleIdForUpdateTx 里看到新插入
		// 的绑定行，下游 BatchDel 能覆盖到这批用户缓存，不再留下孤儿 sys_user_role。
		// 注：只锁"本次请求携带的 roleIds"——已有但未出现在本次请求里的 existing 角色会被 diff
		// 到 toRemove，DELETE 自身就会对 sys_user_role 行取 X 锁，不依赖 sys_role 的 S 锁。
		if len(roleIds) > 0 {
			if err := l.svcCtx.SysRoleModel.LockRolesForShareTx(ctx, session, roleIds); err != nil {
				if errors.Is(err, sqlx.ErrNotFound) {
					return response.ErrBadRequest("包含已被删除或已禁用的角色ID")
				}
				return err
			}
		}

		existingRoleIds, err := l.svcCtx.SysUserRoleModel.FindRoleIdsByUserIdForProductTx(ctx, session, req.UserId, productCode)
		if err != nil {
			return err
		}
		existingSet := make(map[int64]bool, len(existingRoleIds))
		for _, id := range existingRoleIds {
			existingSet[id] = true
		}
		var toAdd []int64
		for _, id := range roleIds {
			if !existingSet[id] {
				toAdd = append(toAdd, id)
			}
		}
		var toRemove []int64
		for _, id := range existingRoleIds {
			if !newSet[id] {
				toRemove = append(toRemove, id)
			}
		}
		if len(toAdd) == 0 && len(toRemove) == 0 {
			return nil
		}

		if err := l.svcCtx.SysUserRoleModel.DeleteByUserIdAndRoleIdsTx(ctx, session, req.UserId, toRemove); err != nil {
			return err
		}
		if len(toAdd) > 0 {
			now := time.Now().Unix()
			data := make([]*userrole.SysUserRole, 0, len(toAdd))
			for _, roleId := range toAdd {
				data = append(data, &userrole.SysUserRole{
					UserId:     req.UserId,
					RoleId:     roleId,
					CreateTime: now,
					UpdateTime: now,
				})
			}
			return l.svcCtx.SysUserRoleModel.BatchInsertWithTx(ctx, session, data)
		}
		return nil
	}); err != nil {
		return err
	}

	// 审计 L-R13-5 方案 A：角色变更直接影响 loadRoles + loadPerms，UD 失效与请求 ctx 解耦
	// 避免 client 断连后 5 分钟 TTL 内目标用户继续走旧角色集。
	cleanCtx, cancel := loaders.DetachCacheCleanCtx(l.ctx)
	defer cancel()
	l.svcCtx.UserDetailsLoader.Clean(cleanCtx, req.UserId)
	return nil
}