package logic

import (
	"context"
	"sort"
	"strconv"
	"strings"

	"github.com/gogf/gf/v2/database/gdb"
	"github.com/gogf/gf/v2/errors/gcode"
	"github.com/gogf/gf/v2/errors/gerror"
	"github.com/gogf/gf/v2/frame/g"
	"github.com/gogf/gf/v2/os/gtime"

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

// ============================================================================
// 年会域：活动 / 布局 / 桌 / 座 / 自动排座
// 依据：PRD-02 §4.2.1-4.2.2、§5.3；架构 §4.2、§5.2 A9-A17、§8.6.5。
//
// 关键约定：
//   - 桌与座必须一致：建桌即生成 1..capacity 座；改 capacity 联动补/删座；
//   - 座位号默认 1..capacity（顺时针自桌正上方 12 点起）；is_manual 标记人工改号；
//   - 布局并发编辑用 CAS（layout_version）；冲突返回 code=4009；
//   - 自动排座 fill 保留手工号 / reorder 覆盖手工号（§4.2.2）。
// ============================================================================

// seatBrief 座位规划用的轻量快照（纯函数入参，便于单测）
type seatBrief struct {
	Id         int64
	TableId    int64
	SeatNo     int
	IsManual   bool
	EmployeeId int64 // 0 = 空位
	Excluded   bool  // true = 所属桌「不参与自动排序」（该桌座位与人员完全不被触碰）
}

// seatAssign 一条待写入的座位绑定
type seatAssign struct {
	SeatId     int64
	EmployeeId int64
}

// tableBrief 桌的「排除校验」用轻量快照（纯函数入参，便于单测）
type tableBrief struct {
	Id          int64
	TableNo     string
	Name        string
	ExcludeAuto int
}

// tableDisplayName 桌的可读名（用于错误提示列出被排除的桌）
func tableDisplayName(t tableBrief) string {
	if t.Name != "" {
		return t.Name
	}
	if t.TableNo != "" {
		return t.TableNo + " 号桌"
	}
	return "桌#" + strconv.FormatInt(t.Id, 10)
}

// planAutoGuards 自动排座的前置校验（纯函数，单测直接覆盖）。
//
// fail-closed（D4）：**全部桌被排除**（无 exclude_auto=0 的桌）→ 返回 4018，
// message 列出被排除的桌，不静默「排成功 0 人」。仅 1 张桌可参与时**允许**执行（提示由前端据本地桌数据给出）。
func planAutoGuards(tables []tableBrief) error {
	if len(tables) == 0 {
		return nil // 无桌：交由后续逻辑自然得到 0 结果（保持老行为）
	}
	participants := 0
	excluded := make([]string, 0)
	for _, t := range tables {
		if t.ExcludeAuto == 1 {
			excluded = append(excluded, tableDisplayName(t))
		} else {
			participants++
		}
	}
	if participants == 0 {
		return gerror.NewCode(gcode.New(consts.CodeSeatAutoInvalid, "", nil),
			"没有可参与自动排序的桌（已排除："+strings.Join(excluded, "、")+"）；请先取消部分桌的「不参与自动排序」")
	}
	return nil
}

// gcodeLayoutConflict 布局版本冲突（4009）
func gcodeLayoutConflict() gcode.Code {
	return gcode.New(consts.CodeLayoutConflict, "", nil)
}

// ============================================================================
// 纯规划函数（不碰 DB，单测直接覆盖）
// ============================================================================

// planSeatNumbers 生成默认座位号 1..capacity。
func planSeatNumbers(capacity int) []int {
	if capacity < 0 {
		capacity = 0
	}
	out := make([]int, 0, capacity)
	for n := 1; n <= capacity; n++ {
		out = append(out, n)
	}
	return out
}

// planCapacityChange 计算 capacity 变更需要补出的座位号与需要移除的座位。
//   - toAddNos：1..newCapacity 中当前不存在的号（升序）；
//   - toRemove：seat_no > newCapacity 的现有座位（其 EmployeeId 会被调用方计入「未分配」）。
func planCapacityChange(seats []seatBrief, newCapacity int) (toAddNos []int, toRemove []seatBrief) {
	if newCapacity < 0 {
		newCapacity = 0
	}
	existing := make(map[int]bool, len(seats))
	for _, s := range seats {
		existing[s.SeatNo] = true
	}
	toAddNos = make([]int, 0)
	for n := 1; n <= newCapacity; n++ {
		if !existing[n] {
			toAddNos = append(toAddNos, n)
		}
	}
	toRemove = make([]seatBrief, 0)
	for _, s := range seats {
		if s.SeatNo > newCapacity {
			toRemove = append(toRemove, s)
		}
	}
	sort.SliceStable(toRemove, func(i, j int) bool { return toRemove[i].SeatNo < toRemove[j].SeatNo })
	return toAddNos, toRemove
}

// planAutoAssign 计算自动排座结果。
//
//	mode=fill    ：候选 = 非手工且空位的座位（跳过 is_manual=1），编号不动；manualOverridden=0；
//	mode=reorder ：先视为清空全部手工标记，候选 = 全部空位座位；manualOverridden=手工座位数。
//
// **排除桌（s.Excluded=true）**：其座位**完全不被触碰** —— 不分配人、不重编座号、
// 不清其手工标记、也不计入 manualOverridden（N4 / S14）。已坐人的座位一律保持不动；
// 未分配员工按 (tableId, seatNo) 升序依次填位。
func planAutoAssign(seats []seatBrief, unassignedEmp []int64, mode string) (assigns []seatAssign, remaining []int64, manualOverridden int) {
	ordered := make([]seatBrief, len(seats))
	copy(ordered, seats)
	sort.SliceStable(ordered, func(i, j int) bool {
		if ordered[i].TableId != ordered[j].TableId {
			return ordered[i].TableId < ordered[j].TableId
		}
		return ordered[i].SeatNo < ordered[j].SeatNo
	})

	candidates := make([]seatBrief, 0, len(ordered))
	for _, s := range ordered {
		if s.Excluded {
			continue // 排除桌：座位与人员完全不被触碰
		}
		if mode == consts.SeatModeReorder && s.IsManual {
			manualOverridden++
		}
		if s.EmployeeId != 0 {
			continue // 已坐人，保持不动
		}
		if mode == consts.SeatModeFill && s.IsManual {
			continue // fill 跳过手工座位（保留其编号与空位状态）
		}
		candidates = append(candidates, s)
	}

	assigns = make([]seatAssign, 0, len(candidates))
	remaining = make([]int64, 0)
	for i, emp := range unassignedEmp {
		if i < len(candidates) {
			assigns = append(assigns, seatAssign{SeatId: candidates[i].Id, EmployeeId: emp})
		} else {
			remaining = append(remaining, emp)
		}
	}
	return assigns, remaining, manualOverridden
}

// ============================================================================
// 活动
// ============================================================================

// eventRow 读取活动，不存在报错。
func eventRow(ctx context.Context, eventId int64) (*entity.AnnualEvents, error) {
	record, err := g.Model(consts.TableAnnualEvents).Where("id", eventId).One()
	if err != nil {
		return nil, err
	}
	if record.IsEmpty() {
		return nil, gerror.New("活动不存在")
	}
	event := &entity.AnnualEvents{}
	if err = record.Struct(event); err != nil {
		return nil, err
	}
	return event, nil
}

// AdminEventList 活动列表
func AdminEventList(ctx context.Context, req *v1.EventListReq) (*v1.EventListRes, error) {
	model := g.Model(consts.TableAnnualEvents)
	if req.EnterpriseId > 0 {
		model = model.Where("enterprise_id", req.EnterpriseId)
	}
	total, err := model.Count()
	if err != nil {
		return nil, err
	}
	page, size := normalizeAdminPage(req.Page, req.PageSize)
	records, err := model.OrderDesc("id").Page(page, size).All()
	if err != nil {
		return nil, err
	}

	list := make([]v1.EventItem, 0, len(records))
	for _, r := range records {
		event := &entity.AnnualEvents{}
		if err = r.Struct(event); err != nil {
			continue
		}
		name := ""
		if ent, err := g.Model(consts.TableEnterprises).Where("id", event.EnterpriseId).One(); err == nil && !ent.IsEmpty() {
			name = ent["name"].String()
		}
		tableCount, err := g.Model(consts.TableEventTables).Where("event_id", event.Id).Count()
		if err != nil {
			return nil, err
		}
		list = append(list, v1.EventItem{
			Id:             event.Id,
			EnterpriseId:   event.EnterpriseId,
			EnterpriseName: name,
			Title:          event.Title,
			Venue:          event.Venue,
			EventTime:      formatGTime(event.EventTime),
			Status:         event.Status,
			LayoutVersion:  event.LayoutVersion,
			CodeUrl:        event.CodeUrl,
			TableCount:     int64(tableCount),
		})
	}
	return &v1.EventListRes{List: list, Total: total}, nil
}

// AdminEventSave 建/改活动。新建默认 status=draft、layout_version=0。
func AdminEventSave(ctx context.Context, req *v1.EventSaveReq) (*v1.EventSaveRes, error) {
	if exists, err := g.Model(consts.TableEnterprises).Where("id", req.EnterpriseId).Count(); err != nil {
		return nil, err
	} else if exists == 0 {
		return nil, gerror.New("企业不存在")
	}
	eventTime, err := parseEventTime(req.EventTime)
	if err != nil {
		return nil, err
	}
	now := gtime.Now()
	if req.Id > 0 {
		result, err := g.Model(consts.TableAnnualEvents).Where("id", req.Id).Data(g.Map{
			"enterprise_id": req.EnterpriseId,
			"title":         req.Title,
			"venue":         req.Venue,
			"event_time":    eventTime,
			"updated_at":    now,
		}).Update()
		if err != nil {
			return nil, err
		}
		if affected, _ := result.RowsAffected(); affected == 0 {
			if exists, err := g.Model(consts.TableAnnualEvents).Where("id", req.Id).Count(); err != nil {
				return nil, err
			} else if exists == 0 {
				return nil, gerror.New("活动不存在")
			}
		}
		return &v1.EventSaveRes{Id: req.Id}, nil
	}

	id, err := g.Model(consts.TableAnnualEvents).Data(g.Map{
		"enterprise_id":  req.EnterpriseId,
		"title":          req.Title,
		"venue":          req.Venue,
		"event_time":     eventTime,
		"status":         consts.EventStatusDraft,
		"hall_layout":    "",
		"code_url":       "",
		"layout_version": 0,
		"created_at":     now,
		"updated_at":     now,
	}).InsertAndGetId()
	if err != nil {
		return nil, err
	}
	return &v1.EventSaveRes{Id: id}, nil
}

// AdminEventStatus 发布/结束/回草稿
func AdminEventStatus(ctx context.Context, req *v1.EventStatusReq) (*v1.EventStatusRes, error) {
	before, err := eventRow(ctx, req.EventId)
	if err != nil {
		return nil, err
	}
	if _, err := g.Model(consts.TableAnnualEvents).Where("id", req.EventId).Data(g.Map{
		"status":     req.Status,
		"updated_at": gtime.Now(),
	}).Update(); err != nil {
		return nil, err
	}
	// T17 审计：发布/结束活动属敏感操作
	WriteAudit(ctx, AuditEntry{
		Action:     "event.status",
		TargetType: "event",
		TargetId:   auditId(req.EventId),
		Before:     g.Map{"status": before.Status},
		After:      g.Map{"status": req.Status},
		Result:     consts.AuditResultSuccess,
	})
	return &v1.EventStatusRes{}, nil
}

// AdminEventDetail 设计器全量：活动 + 桌（含座）+ 候场数 + 未分配池。
func AdminEventDetail(ctx context.Context, req *v1.EventDetailReq) (*v1.EventDetailRes, error) {
	event, err := eventRow(ctx, req.EventId)
	if err != nil {
		return nil, err
	}
	tables, err := loadTables(ctx, req.EventId)
	if err != nil {
		return nil, err
	}
	seats, err := loadSeats(ctx, req.EventId)
	if err != nil {
		return nil, err
	}
	nameMap, err := loadEmployeeNames(ctx, collectEmployeeIds(seats))
	if err != nil {
		return nil, err
	}

	seatsByTable := map[int64][]v1.SeatOut{}
	seatCount := 0
	for _, s := range seats {
		seatCount++
		empId := int64(0)
		if s.EmployeeId != nil {
			empId = *s.EmployeeId
		}
		seatsByTable[s.TableId] = append(seatsByTable[s.TableId], v1.SeatOut{
			Id:           s.Id,
			SeatNo:       s.SeatNo,
			IsManual:     s.IsManual == 1,
			EmployeeId:   empId,
			EmployeeName: nameMap[empId],
		})
	}

	tableOuts := make([]v1.TableOut, 0, len(tables))
	for _, t := range tables {
		tableOuts = append(tableOuts, v1.TableOut{
			Id:          t.Id,
			TableNo:     t.TableNo,
			Name:        t.Name,
			X:           t.X,
			Y:           t.Y,
			Capacity:    t.Capacity,
			Rotation:    t.Rotation,
			TableType:   t.TableType,
			Remark:      t.Remark,
			ExcludeAuto: t.ExcludeAuto,
			Seats:       seatsByTable[t.Id],
		})
	}

	participantCount, err := g.Model(consts.TableEventParticipants).Where("event_id", req.EventId).Count()
	if err != nil {
		return nil, err
	}
	unassigned, err := unassignedParticipants(ctx, req.EventId)
	if err != nil {
		return nil, err
	}

	return &v1.EventDetailRes{
		Id:               event.Id,
		EnterpriseId:     event.EnterpriseId,
		Title:            event.Title,
		Venue:            event.Venue,
		EventTime:        formatGTime(event.EventTime),
		Status:           event.Status,
		LayoutVersion:    event.LayoutVersion,
		HallLayout:       event.HallLayout,
		Tables:           tableOuts,
		ParticipantCount: participantCount,
		SeatCount:        seatCount,
		Unassigned:       unassigned,
	}, nil
}

// ============================================================================
// 布局保存（CAS）
// ============================================================================

// AdminEventLayoutSave 保存大厅布局：CAS 更新 layout_version，冲突返回 4009；同时 upsert 桌。
func AdminEventLayoutSave(ctx context.Context, req *v1.EventLayoutSaveReq) (*v1.EventLayoutSaveRes, error) {
	event, err := eventRow(ctx, req.EventId) // 先确保活动存在
	if err != nil {
		return nil, err
	}
	if req.LayoutVersion < 0 {
		return nil, gerror.NewCode(gcode.CodeValidationFailed, "缺少布局版本号")
	}

	newVersion := req.LayoutVersion + 1
	now := gtime.Now()
	err = g.DB().Transaction(ctx, func(ctx context.Context, tx gdb.TX) error {
		result, err := tx.Model(consts.TableAnnualEvents).
			Where("id", req.EventId).
			Where("layout_version", req.LayoutVersion).
			Data(g.Map{
				"hall_layout":    req.HallLayout,
				"layout_version": gdb.Raw("layout_version + 1"),
				"updated_at":     now,
			}).Update()
		if err != nil {
			return err
		}
		if affected, _ := result.RowsAffected(); affected == 0 {
			return gerror.NewCode(gcodeLayoutConflict(),
				"布局已被他人修改（当前版本 "+itoa(event.LayoutVersion)+"），请刷新后重试")
		}
		for _, tbl := range req.Tables {
			if _, _, _, _, err = saveTableRow(ctx, tx, req.EventId, tbl); err != nil {
				return err
			}
		}
		return nil
	})
	if err != nil {
		return nil, err
	}
	return &v1.EventLayoutSaveRes{LayoutVersion: newVersion}, nil
}

// ============================================================================
// 桌（含座位联动）
// ============================================================================

// saveTableRow 事务内 upsert 一张桌并同步座位。
// 返回：桌 id、补座数、删座数、因减座移入未分配的人数。
func saveTableRow(ctx context.Context, tx gdb.TX, eventId int64, in v1.TableIn) (tableId int64, added, removed, moved int, err error) {
	now := gtime.Now()
	capacity := in.Capacity

	// 新建
	if in.Id == 0 {
		if capacity < 0 {
			capacity = 0 // 特殊桌（签到台/媒体席/备用桌）允许 0 座
		}
		tableId, err = tx.Model(consts.TableEventTables).Data(g.Map{
			"event_id":     eventId,
			"table_no":     in.TableNo,
			"name":         in.Name,
			"x":            in.X,
			"y":            in.Y,
			"capacity":     capacity,
			"rotation":     in.Rotation,
			"table_type":   in.TableType,
			"remark":       in.Remark,
			"exclude_auto": in.ExcludeAuto,
			"created_at":   now,
			"updated_at":   now,
		}).InsertAndGetId()
		if err != nil {
			return 0, 0, 0, 0, err
		}
		for _, no := range planSeatNumbers(capacity) {
			if _, err = tx.Model(consts.TableEventSeats).Data(g.Map{
				"event_id":    eventId,
				"table_id":    tableId,
				"seat_no":     no,
				"is_manual":   0,
				"employee_id": nil,
				"created_at":  now,
				"updated_at":  now,
			}).Insert(); err != nil {
				return 0, 0, 0, 0, err
			}
		}
		return tableId, capacity, 0, 0, nil
	}

	// 更新：行锁读取现有桌
	tableId = in.Id
	record, err := tx.Model(consts.TableEventTables).
		Where("id", in.Id).Where("event_id", eventId).LockUpdate().One()
	if err != nil {
		return 0, 0, 0, 0, err
	}
	if record.IsEmpty() {
		return 0, 0, 0, 0, gerror.New("桌不存在")
	}
	oldCapacity := record["capacity"].Int()
	if capacity < 0 {
		capacity = oldCapacity
	}

	// 现有座位快照
	briefs, err := loadSeatBriefs(ctx, tx, eventId, tableId)
	if err != nil {
		return 0, 0, 0, 0, err
	}
	toAddNos, toRemove := planCapacityChange(briefs, capacity)

	// 减座：删除多余座位；其上员工自动回到「未分配」池
	for _, s := range toRemove {
		if s.EmployeeId != 0 {
			moved++
		}
		if _, err = tx.Model(consts.TableEventSeats).Where("id", s.Id).Delete(); err != nil {
			return 0, 0, 0, 0, err
		}
	}
	// 增座：补出空位
	for _, no := range toAddNos {
		if _, err = tx.Model(consts.TableEventSeats).Data(g.Map{
			"event_id":    eventId,
			"table_id":    tableId,
			"seat_no":     no,
			"is_manual":   0,
			"employee_id": nil,
			"created_at":  now,
			"updated_at":  now,
		}).Insert(); err != nil {
			return 0, 0, 0, 0, err
		}
	}
	// 更新桌
	if _, err = tx.Model(consts.TableEventTables).Where("id", tableId).Data(g.Map{
		"table_no":     in.TableNo,
		"name":         in.Name,
		"x":            in.X,
		"y":            in.Y,
		"capacity":     capacity,
		"rotation":     in.Rotation,
		"table_type":   in.TableType,
		"remark":       in.Remark,
		"exclude_auto": in.ExcludeAuto,
		"updated_at":   now,
	}).Update(); err != nil {
		return 0, 0, 0, 0, err
	}
	return tableId, len(toAddNos), len(toRemove), moved, nil
}

// AdminTableSave 建/改桌（改人数联动补/删座）。
func AdminTableSave(ctx context.Context, req *v1.TableSaveReq) (*v1.TableSaveRes, error) {
	if _, err := eventRow(ctx, req.EventId); err != nil {
		return nil, err
	}
	var (
		tableId int64
		added   int
		removed int
		moved   int
	)
	err := g.DB().Transaction(ctx, func(ctx context.Context, tx gdb.TX) error {
		var e error
		tableId, added, removed, moved, e = saveTableRow(ctx, tx, req.EventId, v1.TableIn{
			Id:          req.Id,
			TableNo:     req.TableNo,
			Name:        req.Name,
			X:           req.X,
			Y:           req.Y,
			Capacity:    req.Capacity,
			Rotation:    req.Rotation,
			TableType:   req.TableType,
			Remark:      req.Remark,
			ExcludeAuto: req.ExcludeAuto,
		})
		return e
	})
	if err != nil {
		return nil, err
	}
	return &v1.TableSaveRes{
		TableId:           tableId,
		AddedSeats:        added,
		RemovedSeats:      removed,
		MovedToUnassigned: moved,
	}, nil
}

// AdminTableDelete 删桌（连同座位；其上员工回到未分配池）。
func AdminTableDelete(ctx context.Context, req *v1.TableDeleteReq) (*v1.TableDeleteRes, error) {
	if _, err := eventRow(ctx, req.EventId); err != nil {
		return nil, err
	}
	moved := 0
	err := g.DB().Transaction(ctx, func(ctx context.Context, tx gdb.TX) error {
		occupied, err := tx.Model(consts.TableEventSeats).
			Where("event_id", req.EventId).Where("table_id", req.TableId).
			WhereNotNull("employee_id").Count()
		if err != nil {
			return err
		}
		moved = occupied
		if _, err = tx.Model(consts.TableEventSeats).
			Where("event_id", req.EventId).Where("table_id", req.TableId).Delete(); err != nil {
			return err
		}
		result, err := tx.Model(consts.TableEventTables).
			Where("id", req.TableId).Where("event_id", req.EventId).Delete()
		if err != nil {
			return err
		}
		if affected, _ := result.RowsAffected(); affected == 0 {
			return gerror.New("桌不存在")
		}
		return nil
	})
	if err != nil {
		return nil, err
	}
	// T17 审计：删桌属敏感（会移动已绑定员工）
	WriteAudit(ctx, AuditEntry{
		Action:     "event.table_delete",
		TargetType: "table",
		TargetId:   auditId(req.TableId),
		After:      g.Map{"event_id": req.EventId, "moved_to_unassigned": moved},
		Result:     consts.AuditResultSuccess,
	})
	return &v1.TableDeleteRes{MovedToUnassigned: moved}, nil
}

// ============================================================================
// 座位：改号（对调语义）/ 绑定 / 解绑
// ============================================================================

// seatSwapPlan 座位对调计划（纯计算结果）
type seatSwapPlan struct {
	SeatAId    int64 // 被改号的座位
	SeatANewNo int   // 目标号
	SeatBId    int64 // 原占目标号的座位（0 = 无需对调，幂等）
	SeatBNewNo int   // B 的新号（= A 的原号）
	TempNo     int   // 交换过程中 B 的中转号（避开 uk_evt_tbl_seat）
}

// planSeatSwap 计算把 seatAId 的座位号改为 targetNo 的**对调**计划。
//
// 语义（用户拍板 = 对调编号）：
//   - 目标号必须已在同一桌存在 —— 对调两者编号，而非新增编号；
//   - targetNo 不存在于该桌（含超出 1..capacity）→ 报错「该桌没有 N 号座位」；
//   - targetNo == 当前号 → 幂等（SeatBId=0）。
//
// 注意：对调仅交换「编号标签」，座位行与其上员工绑定均不动（员工不随号迁移）。
func planSeatSwap(seats []seatBrief, seatAId int64, targetNo int) (*seatSwapPlan, error) {
	var cur *seatBrief
	for i := range seats {
		if seats[i].Id == seatAId {
			cur = &seats[i]
			break
		}
	}
	if cur == nil {
		return nil, gerror.New("座位不存在")
	}
	if targetNo <= 0 {
		return nil, gerror.New("座位号非法")
	}
	if targetNo == cur.SeatNo {
		return &seatSwapPlan{SeatAId: seatAId, SeatANewNo: targetNo}, nil
	}
	var target *seatBrief
	for i := range seats {
		if seats[i].SeatNo == targetNo {
			target = &seats[i]
			break
		}
	}
	if target == nil {
		return nil, gerror.Newf("该桌没有 %d 号座位", targetNo)
	}
	return &seatSwapPlan{
		SeatAId:    cur.Id,
		SeatANewNo: targetNo,
		SeatBId:    target.Id,
		SeatBNewNo: cur.SeatNo,
		TempNo:     maxSeatNo(seats) + 100000,
	}, nil
}

// maxSeatNo 桌上最大座位号（用于生成安全的中转号）。
func maxSeatNo(seats []seatBrief) int {
	m := 0
	for _, s := range seats {
		if s.SeatNo > m {
			m = s.SeatNo
		}
	}
	return m
}

// AdminSeatSave 改座位号（**对调语义**）/ 绑定 / 解绑。
//
// 改号：把座位 A（当前 cur）改为 N 时，与同桌上 seat_no=N 的座位 B **对调编号**
// （A→N、B→cur），二者 is_manual 均置 1（后续 fill 会跳过它们，不被自动排座抹掉）。
// **员工跟随座位行不动**（只换编号标签）：例如原「3 号·张三」「8 号·李四」对调后
// 变为「8 号·张三」「3 号·李四」，两人都没离开自己的物理位置 —— 这决定了查座页显示什么。
func AdminSeatSave(ctx context.Context, req *v1.SeatSaveReq) (*v1.SeatSaveRes, error) {
	record, err := g.Model(consts.TableEventSeats).
		Where("id", req.SeatId).Where("event_id", req.EventId).One()
	if err != nil {
		return nil, err
	}
	if record.IsEmpty() {
		return nil, gerror.New("座位不存在")
	}
	tableId := record["table_id"].Int64()
	curSeatNo := record["seat_no"].Int()

	bindChanged := false
	var bindValue interface{} // nil=解绑；非 nil=绑定
	if req.EmployeeId != nil {
		bindChanged = true
		if *req.EmployeeId == 0 {
			bindValue = nil
		} else {
			bindValue = *req.EmployeeId
		}
	}

	renumber := req.SeatNo > 0 && req.SeatNo != curSeatNo

	// 仅改绑定（或幂等无操作）
	if !renumber {
		if bindChanged {
			if _, err = g.Model(consts.TableEventSeats).Where("id", req.SeatId).Data(g.Map{
				"employee_id": bindValue,
				"updated_at":  gtime.Now(),
			}).Update(); err != nil {
				return nil, err
			}
		}
		return &v1.SeatSaveRes{}, nil
	}

	// 改号：事务内三步走对调（规避 UNIQUE(event_id, table_id, seat_no)）
	now := gtime.Now()
	err = g.DB().Transaction(ctx, func(ctx context.Context, tx gdb.TX) error {
		briefs, e := loadSeatBriefs(ctx, tx, req.EventId, tableId)
		if e != nil {
			return e
		}
		plan, e := planSeatSwap(briefs, req.SeatId, req.SeatNo)
		if e != nil {
			return e
		}
		if plan.SeatBId == 0 {
			return nil // 幂等
		}
		// 1) B 先挪到中转号（确保后续写入不撞唯一键）
		if _, e = tx.Model(consts.TableEventSeats).Where("id", plan.SeatBId).Data(g.Map{
			"seat_no":    plan.TempNo,
			"updated_at": now,
		}).Update(); e != nil {
			return e
		}
		// 2) A 设为目标号（含可能的绑定变更）；置 is_manual=1
		aData := g.Map{"seat_no": plan.SeatANewNo, "is_manual": 1, "updated_at": now}
		if bindChanged {
			aData["employee_id"] = bindValue
		}
		if _, e = tx.Model(consts.TableEventSeats).Where("id", plan.SeatAId).Data(aData).Update(); e != nil {
			return e
		}
		// 3) B 落到 A 的原号；B 亦被人工调整 → is_manual=1
		if _, e = tx.Model(consts.TableEventSeats).Where("id", plan.SeatBId).Data(g.Map{
			"seat_no":    plan.SeatBNewNo,
			"is_manual":  1,
			"updated_at": now,
		}).Update(); e != nil {
			return e
		}
		return nil
	})
	if err != nil {
		return nil, err
	}
	return &v1.SeatSaveRes{}, nil
}

// ============================================================================
// 自动排座
// ============================================================================

// AdminSeatAuto 自动排座：mode=fill 增量补位（保留手工号）/ reorder 全部重排（覆盖手工号）。
//
// N4 排除语义：
//   - 「不参与自动排序」的桌（exclude_auto=1）：其座位与人员**完全不被触碰**（不分配、不重编、
//     不清手工号、不计入 manual_overridden）；
//   - 「不参与排座」的员工（event_participants.exclude_assign=1）：**永不被分配**，一直留在员工池，
//     并计入响应的 excluded；
//   - fail-closed（D4）：**全部桌被排除** → 返回 4018，message 列出被排除的桌，不静默「排成功 0 人」。
func AdminSeatAuto(ctx context.Context, req *v1.SeatAutoReq) (*v1.SeatAutoRes, error) {
	if _, err := eventRow(ctx, req.EventId); err != nil {
		return nil, err
	}

	// 1) 桌快照 + fail-closed 前置校验
	tables, err := loadTableBriefs(ctx, req.EventId)
	if err != nil {
		return nil, err
	}
	if err = planAutoGuards(tables); err != nil {
		return nil, err
	}
	excludedTables := map[int64]bool{}
	excludedTableIds := make([]int64, 0)
	for _, t := range tables {
		if t.ExcludeAuto == 1 {
			excludedTables[t.Id] = true
			excludedTableIds = append(excludedTableIds, t.Id)
		}
	}

	// 2) 座位快照，标记排除桌
	briefs, err := loadSeatBriefs(ctx, g.DB(), req.EventId, 0)
	if err != nil {
		return nil, err
	}
	for i := range briefs {
		if excludedTables[briefs[i].TableId] {
			briefs[i].Excluded = true
		}
	}

	// 3) 未分配员工，剔除「不参与排座」者
	unassigned, err := unassignedEmployeeIds(ctx, req.EventId)
	if err != nil {
		return nil, err
	}
	parts, err := g.Model(consts.TableEventParticipants).Where("event_id", req.EventId).All()
	if err != nil {
		return nil, err
	}
	excludedEmp := map[int64]bool{}
	excludedCount := 0
	for _, p := range parts {
		if p["exclude_assign"].Int() == 1 {
			excludedEmp[p["employee_id"].Int64()] = true
			excludedCount++
		}
	}
	if excludedCount > 0 {
		kept := make([]int64, 0, len(unassigned))
		for _, id := range unassigned {
			if !excludedEmp[id] {
				kept = append(kept, id)
			}
		}
		unassigned = kept
	}

	assigns, remaining, manualOverridden := planAutoAssign(briefs, unassigned, req.Mode)
	now := gtime.Now()
	err = g.DB().Transaction(ctx, func(ctx context.Context, tx gdb.TX) error {
		if req.Mode == consts.SeatModeReorder {
			// 覆盖含手工号在内的编号并清空手工标记；但**排除桌的手工号不动**
			model := tx.Model(consts.TableEventSeats).
				Where("event_id", req.EventId).Where("is_manual", 1)
			if len(excludedTableIds) > 0 {
				model = model.WhereNotIn("table_id", excludedTableIds)
			}
			if _, err := model.Data(g.Map{"is_manual": 0, "updated_at": now}).Update(); err != nil {
				return err
			}
		}
		for _, a := range assigns {
			if _, err := tx.Model(consts.TableEventSeats).Where("id", a.SeatId).Data(g.Map{
				"employee_id": a.EmployeeId,
				"updated_at":  now,
			}).Update(); err != nil {
				return err
			}
		}
		return nil
	})
	if err != nil {
		return nil, err
	}
	return &v1.SeatAutoRes{
		Assigned:         len(assigns),
		Unassigned:       len(remaining),
		ManualOverridden: manualOverridden,
		Excluded:         excludedCount,
	}, nil
}

// loadTableBriefs 读取该活动的桌（排除校验用快照）。
func loadTableBriefs(ctx context.Context, eventId int64) ([]tableBrief, error) {
	records, err := g.Model(consts.TableEventTables).Where("event_id", eventId).OrderAsc("id").All()
	if err != nil {
		return nil, err
	}
	out := make([]tableBrief, 0, len(records))
	for _, r := range records {
		out = append(out, tableBrief{
			Id:          r["id"].Int64(),
			TableNo:     r["table_no"].String(),
			Name:        r["name"].String(),
			ExcludeAuto: r["exclude_auto"].Int(),
		})
	}
	return out, nil
}

// ============================================================================
// 数据读取辅助
// ============================================================================

// querier 抽象 g.DB() 与 gdb.TX 的公共查询能力（Model 方法）
type querier interface {
	Model(tableNameOrStruct ...interface{}) *gdb.Model
}

func loadTables(ctx context.Context, eventId int64) ([]*entity.EventTables, error) {
	records, err := g.Model(consts.TableEventTables).Where("event_id", eventId).OrderAsc("id").All()
	if err != nil {
		return nil, err
	}
	out := make([]*entity.EventTables, 0, len(records))
	for _, r := range records {
		t := &entity.EventTables{}
		if err = r.Struct(t); err != nil {
			continue
		}
		out = append(out, t)
	}
	return out, nil
}

func loadSeats(ctx context.Context, eventId int64) ([]*entity.EventSeats, error) {
	records, err := g.Model(consts.TableEventSeats).
		Where("event_id", eventId).
		OrderAsc("table_id").OrderAsc("seat_no").All()
	if err != nil {
		return nil, err
	}
	out := make([]*entity.EventSeats, 0, len(records))
	for _, r := range records {
		s := &entity.EventSeats{}
		if err = r.Struct(s); err != nil {
			continue
		}
		out = append(out, s)
	}
	return out, nil
}

// loadSeatBriefs 读取座位快照；tableId=0 表示整场活动。
func loadSeatBriefs(ctx context.Context, q querier, eventId, tableId int64) ([]seatBrief, error) {
	model := q.Model(consts.TableEventSeats).Where("event_id", eventId)
	if tableId > 0 {
		model = model.Where("table_id", tableId)
	}
	records, err := model.OrderAsc("table_id").OrderAsc("seat_no").All()
	if err != nil {
		return nil, err
	}
	out := make([]seatBrief, 0, len(records))
	for _, r := range records {
		empId := int64(0)
		if v := r["employee_id"]; !v.IsNil() {
			empId = v.Int64()
		}
		out = append(out, seatBrief{
			Id:         r["id"].Int64(),
			TableId:    r["table_id"].Int64(),
			SeatNo:     r["seat_no"].Int(),
			IsManual:   r["is_manual"].Int() == 1,
			EmployeeId: empId,
		})
	}
	return out, nil
}

// unassignedParticipants 候场名单中未绑定任何座位的成员（含姓名/手机/部门）。
func unassignedParticipants(ctx context.Context, eventId int64) ([]v1.UnassignedItem, error) {
	ids, err := unassignedEmployeeIds(ctx, eventId)
	if err != nil {
		return nil, err
	}
	out := make([]v1.UnassignedItem, 0, len(ids))
	if len(ids) == 0 {
		return out, nil
	}
	records, err := g.Model(consts.TableEmployees).WhereIn("id", ids).All()
	if err != nil {
		return nil, err
	}
	nameMap := map[int64]v1.UnassignedItem{}
	for _, r := range records {
		nameMap[r["id"].Int64()] = v1.UnassignedItem{
			EmployeeId: r["id"].Int64(),
			Name:       r["name"].String(),
			Phone:      r["phone"].String(),
			Dept:       r["dept"].String(),
		}
	}
	for _, id := range ids {
		if item, ok := nameMap[id]; ok {
			out = append(out, item)
		} else {
			out = append(out, v1.UnassignedItem{EmployeeId: id})
		}
	}
	return out, nil
}

// unassignedEmployeeIds 候场名单员工 id，剔除已绑定座位的；保持候场顺序（按 participant id）。
func unassignedEmployeeIds(ctx context.Context, eventId int64) ([]int64, error) {
	parts, err := g.Model(consts.TableEventParticipants).
		Where("event_id", eventId).OrderAsc("id").All()
	if err != nil {
		return nil, err
	}
	boundRecords, err := g.Model(consts.TableEventSeats).
		Where("event_id", eventId).WhereNotNull("employee_id").All()
	if err != nil {
		return nil, err
	}
	bound := make(map[int64]bool, len(boundRecords))
	for _, r := range boundRecords {
		bound[r["employee_id"].Int64()] = true
	}
	out := make([]int64, 0, len(parts))
	for _, p := range parts {
		id := p["employee_id"].Int64()
		if !bound[id] {
			out = append(out, id)
		}
	}
	return out, nil
}

func collectEmployeeIds(seats []*entity.EventSeats) []int64 {
	seen := map[int64]bool{}
	out := make([]int64, 0)
	for _, s := range seats {
		if s.EmployeeId != nil && !seen[*s.EmployeeId] {
			seen[*s.EmployeeId] = true
			out = append(out, *s.EmployeeId)
		}
	}
	return out
}

func loadEmployeeNames(ctx context.Context, ids []int64) (map[int64]string, error) {
	out := map[int64]string{}
	if len(ids) == 0 {
		return out, nil
	}
	records, err := g.Model(consts.TableEmployees).WhereIn("id", ids).All()
	if err != nil {
		return nil, err
	}
	for _, r := range records {
		out[r["id"].Int64()] = r["name"].String()
	}
	return out, nil
}

// parseEventTime 解析活动时间字符串；空串表示不设。
func parseEventTime(s string) (*gtime.Time, error) {
	s = strings.TrimSpace(s)
	if s == "" {
		return nil, nil
	}
	t, err := gtime.StrToTime(s)
	if err != nil {
		return nil, gerror.NewCode(gcode.CodeValidationFailed, "活动时间格式不正确")
	}
	return t, nil
}

// formatGTime 时间格式化为 yyyy-MM-dd HH:mm:ss；空返回空串。
func formatGTime(t *gtime.Time) string {
	if t == nil || t.IsZero() {
		return ""
	}
	return t.Format("Y-m-d H:i:s")
}