package logic

import (
	"context"

	"github.com/gogf/gf/v2/errors/gerror"
	"github.com/gogf/gf/v2/frame/g"

	v1 "tool-api/api/admin/v1"
	"tool-api/internal/consts"
)

// ============================================================================
// 批量操作（T15 批量改值 + T18 软删除）
//
// 设计要点：
//   - 幂等：同一批重复提交结果一致；把值改为当前值仍算成功；对**已软删**的 id 再次
//     执行 delete 也计成功（不塞进 failures）；
//   - 部分成功：不存在的 id 计入 failed 并附原因，不影响其余 id 的更新；
//   - 高效：存在性一次 IN 查询、更新一次 IN 批量，避免 N 次单条请求。
//
// action 白名单：user = status / level / delete；tool = is_enabled / is_hot / delete；
// employee = status / delete。
// ============================================================================

// dedupBatchIds 去重并剔除非法 id（<=0），保持首次出现顺序。
func dedupBatchIds(in []int64) []int64 {
	seen := make(map[int64]bool, len(in))
	out := make([]int64, 0, len(in))
	for _, id := range in {
		if id <= 0 || seen[id] {
			continue
		}
		seen[id] = true
		out = append(out, id)
	}
	return out
}

// partitionBatchIds 按「是否存在」把 id 分为可操作(ok)与缺失(missing)，保持入参顺序。
func partitionBatchIds(requested []int64, existing map[int64]bool) (ok []int64, missing []int64) {
	ok = make([]int64, 0, len(requested))
	missing = make([]int64, 0)
	for _, id := range requested {
		if existing[id] {
			ok = append(ok, id)
			continue
		}
		missing = append(missing, id)
	}
	return ok, missing
}

// batchFailures 把缺失 id 转为失败明细。
func batchFailures(missing []int64, reason string) []v1.BatchFailure {
	out := make([]v1.BatchFailure, 0, len(missing))
	for _, id := range missing {
		out = append(out, v1.BatchFailure{Id: id, Reason: reason})
	}
	return out
}

// existingIdSet 一次 IN 查询出「实际存在的 id 集合」。
//
// 🔴 必须 `.Unscoped()`：GoFrame v2.10 会给所有 Model 查询（select/count/update/delete）
// **自动**追加 `deleted_at IS NULL`（见 softdelete.go 头部不变量）。若不加 Unscoped，
// 已软删的行会被自动过滤掉 → 落进 missing → 被判为「不存在」→ 返回 failed，
// 直接违反「重复删除已删 id 计成功」的幂等契约（且代码注释与实现相反，极隐蔽）。
// Unscoped 让软删行照常出现在结果里、计入 ok —— delete 幂等正是依赖此语义。
func existingIdSet(ctx context.Context, table string, ids []int64) (map[int64]bool, error) {
	set := make(map[int64]bool, len(ids))
	if len(ids) == 0 {
		return set, nil
	}
	records, err := g.Model(table).Unscoped().Fields("id").WhereIn("id", ids).All()
	if err != nil {
		return nil, err
	}
	for _, r := range records {
		set[r["id"].Int64()] = true
	}
	return set, nil
}

// normalizeToggle 归一化为 0/1。
func normalizeToggle(v int) int {
	if v == 1 {
		return 1
	}
	return 0
}

// AdminUserBatch 批量操作用户：status（启停）/ level（改等级）/ delete（软删除，可恢复）。
func AdminUserBatch(ctx context.Context, req *v1.UserBatchReq) (*v1.UserBatchRes, error) {
	ids := dedupBatchIds(req.Ids)
	if len(ids) == 0 {
		return &v1.UserBatchRes{Failures: []v1.BatchFailure{}}, nil
	}
	existing, err := existingIdSet(ctx, consts.TableUsers, ids)
	if err != nil {
		return nil, err
	}
	ok, missing := partitionBatchIds(ids, existing)

	switch req.Action {
	case "delete":
		// 软删除：墓碑化 openid/username，保证可重新注册；已删 id 幂等计成功。
		if err = softDeleteUsers(ctx, ok); err != nil {
			return nil, err
		}
	case "status", "level":
		data := g.Map{}
		if req.Action == "status" {
			data["status"] = normalizeToggle(req.Status)
		} else {
			n, err := g.Model(consts.TableLevels).Where("level_key", req.LevelKey).Count()
			if err != nil {
				return nil, err
			}
			if n == 0 {
				return nil, gerror.New("等级不存在") // 参数错误 → 整体失败，不做「部分成功」
			}
			data["level_key"] = req.LevelKey
		}
		if len(ok) > 0 {
			if _, err = g.Model(consts.TableUsers).WhereIn("id", ok).Data(data).Update(); err != nil {
				return nil, err
			}
		}
	default:
		return nil, gerror.New("不支持的批量动作")
	}

	res := &v1.UserBatchRes{
		Success:  len(ok),
		Failed:   len(missing),
		Failures: batchFailures(missing, "用户不存在"),
	}
	WriteAudit(ctx, AuditEntry{
		Action:     "user.batch_" + req.Action,
		TargetType: "user",
		TargetId:   "batch",
		After: g.Map{
			"action": req.Action, "ids": ok, "status": req.Status, "level_key": req.LevelKey,
			"success": res.Success, "failed": res.Failed,
		},
		Result: consts.AuditResultSuccess,
	})
	return res, nil
}

// AdminToolsBatch 批量操作工具：is_enabled / is_hot（改值）/ delete（软删除，可恢复）。
func AdminToolsBatch(ctx context.Context, req *v1.ToolsBatchReq) (*v1.ToolsBatchRes, error) {
	ids := dedupBatchIds(req.Ids)
	if len(ids) == 0 {
		return &v1.ToolsBatchRes{Failures: []v1.BatchFailure{}}, nil
	}
	existing, err := existingIdSet(ctx, consts.TableTools, ids)
	if err != nil {
		return nil, err
	}
	ok, missing := partitionBatchIds(ids, existing)

	switch req.Action {
	case "delete":
		// 软删除：仅置 deleted_at（不墓碑化 tool_key，见 softdelete.go 说明）。
		if err = softDeleteSimple(ctx, consts.TableTools, ok); err != nil {
			return nil, err
		}
	case "is_enabled", "is_hot":
		if len(ok) > 0 {
			if _, err = g.Model(consts.TableTools).WhereIn("id", ok).
				Data(g.Map{req.Action: normalizeToggle(req.Value)}).Update(); err != nil {
				return nil, err
			}
		}
	default:
		return nil, gerror.New("不支持的批量动作")
	}

	res := &v1.ToolsBatchRes{
		Success:  len(ok),
		Failed:   len(missing),
		Failures: batchFailures(missing, "工具不存在"),
	}
	WriteAudit(ctx, AuditEntry{
		Action:     "tool.batch_" + req.Action,
		TargetType: "tool",
		TargetId:   "batch",
		After: g.Map{
			"action": req.Action, "value": normalizeToggle(req.Value), "ids": ok,
			"success": res.Success, "failed": res.Failed,
		},
		Result: consts.AuditResultSuccess,
	})
	return res, nil
}

// AdminEmployeeBatch 批量操作员工：status（启停）/ delete（软删除，可恢复）。
func AdminEmployeeBatch(ctx context.Context, req *v1.EmployeeBatchReq) (*v1.EmployeeBatchRes, error) {
	ids := dedupBatchIds(req.Ids)
	if len(ids) == 0 {
		return &v1.EmployeeBatchRes{Failures: []v1.BatchFailure{}}, nil
	}
	existing, err := existingIdSet(ctx, consts.TableEmployees, ids)
	if err != nil {
		return nil, err
	}
	ok, missing := partitionBatchIds(ids, existing)

	switch req.Action {
	case "delete":
		// 软删除：墓碑化 phone，保证同企业同手机号可重新录入。
		if err = softDeleteEmployees(ctx, ok); err != nil {
			return nil, err
		}
	case "status":
		if len(ok) > 0 {
			if _, err = g.Model(consts.TableEmployees).WhereIn("id", ok).
				Data(g.Map{"status": normalizeToggle(req.Status)}).Update(); err != nil {
				return nil, err
			}
		}
	default:
		return nil, gerror.New("不支持的批量动作")
	}

	res := &v1.EmployeeBatchRes{
		Success:  len(ok),
		Failed:   len(missing),
		Failures: batchFailures(missing, "员工不存在"),
	}
	// T17/T18：员工批量也纳入审计（与 user/tool 批量保持一致）
	WriteAudit(ctx, AuditEntry{
		Action:     "employee.batch_" + req.Action,
		TargetType: "employee",
		TargetId:   "batch",
		After: g.Map{
			"action": req.Action, "ids": ok, "status": req.Status,
			"success": res.Success, "failed": res.Failed,
		},
		Result: consts.AuditResultSuccess,
	})
	return res, nil
}