package httpapi

import (
	"context"
	"database/sql"
	"errors"
	"fmt"
)

func (s *server) lookupID(ctx context.Context, query string, args ...any) (int64, error) {
	var id int64
	if err := s.ev.QueryRowContext(ctx, query, args...).Scan(&id); err != nil {
		return 0, err
	}
	return id, nil
}

// athleteImportRow 是报名表里一行的人员信息（Gender 已归一为 男/女 或空，Age 为空表示表里没填）。
type athleteImportRow struct {
	Line     int
	Name     string
	Gender   string
	TeamID   int64
	TeamCode string
	IDCard   string
	Bib      string
	Age      *int
}

// decisionKey 是冲突决策的键：优先证件号，没有证件号时用号码布。
func (in athleteImportRow) decisionKey() string {
	if in.IDCard != "" {
		return in.IDCard
	}
	return in.Bib
}

// athleteImportMatch 是人员匹配结果；Conflict 非空表示本轮不落库，等用户决策。
// SameNameNewPerson 非空表示本次按「同名的另一个人」新建了档案（只作报告，不拦截）。
type athleteImportMatch struct {
	AthleteID         int64
	TeamID            int64
	Conflict          *importConflict
	SameNameNewPerson *sameNameNewPerson
}

// sameNameNewPerson 是「号码布不同 → 按同名的另一个人新建」的清单项：
// 导入响应里单独列出来给现场看，避免新建了档案却毫无提示。
type sameNameNewPerson struct {
	Name        string `json:"name"`
	TeamCode    string `json:"teamCode"`
	NewBib      string `json:"newBib"`
	ExistingBib string `json:"existingBib"`
}

// existingAthlete 是库中已有人员的可比字段。
type existingAthlete struct {
	ID         int64
	Name       string
	Gender     *string
	TeamID     int64
	EmployeeNo *string
	IDCard     *string
	Bib        *string
	Age        *int
}

// matchImportedAthlete 按新口径匹配人员：号码布 → 姓名 + 单位 → 新建。
// 号码布是单人唯一标识，证件号不参与匹配（只作为可选档案信息写入/更新）。
// 命中人员字段与表里不一致时记为冲突；decisions 里对同一身份有决策时按决策落库。
func (s *server) matchImportedAthlete(ctx context.Context, in athleteImportRow, decisions map[string]string) (athleteImportMatch, error) {
	if in.Bib != "" {
		ex, err := s.athleteByBib(ctx, in.Bib)
		switch {
		case err == nil:
			return s.matchExistingAthlete(ctx, in, ex, decisions)
		case !errors.Is(err, sql.ErrNoRows):
			return athleteImportMatch{}, internal(err)
		}
	}
	return s.matchByNameTeam(ctx, in, decisions)
}

// matchByNameTeam 处理「号码布为空、或按号码布没找到」的情况，按姓名 + 单位找候选：
// 0 条 → 新建；1 条且对方没有号码布 → 命中并回填；1 条但对方号码布不同 → 同名的另一个人，新建并报告；
// 多条 → 仍有歧义，进冲突面板等用户决策。
func (s *server) matchByNameTeam(ctx context.Context, in athleteImportRow, decisions map[string]string) (athleteImportMatch, error) {
	candidates, err := s.athletesByNameTeam(ctx, in.Name, in.TeamID)
	if err != nil {
		return athleteImportMatch{}, internal(err)
	}
	switch len(candidates) {
	case 0:
		return s.createImportedAthlete(ctx, in)
	case 1:
		ex := candidates[0]
		// 只有表里也给了号码布、且与库里不同时才算「同名的另一个人」：
		// 表里没给号码布只是「未指定」，不能凭空多建一个没有号码布的同名人。
		if ex.Bib != nil && *ex.Bib != "" && in.Bib != "" && *ex.Bib != in.Bib {
			created, err := s.createImportedAthlete(ctx, in)
			if err != nil {
				return athleteImportMatch{}, err
			}
			created.SameNameNewPerson = &sameNameNewPerson{
				Name:        in.Name,
				TeamCode:    in.TeamCode,
				NewBib:      in.Bib,
				ExistingBib: *ex.Bib,
			}
			return created, nil
		}
		return s.matchExistingAthlete(ctx, in, ex, decisions)
	default:
		return s.matchAmbiguousCandidates(ctx, in, candidates, decisions)
	}
}

// matchAmbiguousCandidates 处理姓名 + 单位命中多条候选：不能替用户挑人，一律进冲突面板。
// 决策键是整行身份（证件号优先、否则号码布），无法区分同一行的多个候选，
// 所以面板只以第一条候选为代表；有决策时按决策作用于该候选。
func (s *server) matchAmbiguousCandidates(ctx context.Context, in athleteImportRow, candidates []existingAthlete, decisions map[string]string) (athleteImportMatch, error) {
	ex := candidates[0]
	if _, decided := decisions[in.decisionKey()]; decided {
		return s.matchExistingAthlete(ctx, in, ex, decisions)
	}
	conflict, err := s.importConflictFor(ctx, in, ex, changedAthleteFields(ex, in))
	if err != nil {
		return athleteImportMatch{}, err
	}
	return athleteImportMatch{Conflict: &conflict}, nil
}

// createImportedAthlete 新建人员：证件号只作为可选档案信息写入，
// 但它与库里另一个人撞号时仍然明确报错（id_card 的部分唯一索引保留不动，防的是录入错误）。
func (s *server) createImportedAthlete(ctx context.Context, in athleteImportRow) (athleteImportMatch, error) {
	if err := s.idCardTakenError(ctx, in.IDCard, 0); err != nil {
		return athleteImportMatch{}, err
	}
	res, err := s.ev.ExecContext(ctx,
		`INSERT INTO athletes (name, gender, team_id, id_card, bib, age, active) VALUES (?, ?, ?, ?, ?, ?, 1)`,
		in.Name, nullStr(&in.Gender), in.TeamID, nullStr(&in.IDCard), nullStr(&in.Bib), nullInt(in.Age))
	switch {
	case isIDCardConflict(err):
		// 并发下唯一索引兜底：再查一次占用者，把「撞上谁」说清楚。
		if taken := s.idCardTakenError(ctx, in.IDCard, 0); taken != nil {
			return athleteImportMatch{}, taken
		}
		return athleteImportMatch{}, internal(err)
	case isBibConflict(err):
		return athleteImportMatch{}, conflict(fmt.Sprintf("号码布 %s 已被其它人员使用", in.Bib))
	case err != nil:
		return athleteImportMatch{}, internal(err)
	}
	id, err := lastInsertID(res)
	if err != nil {
		return athleteImportMatch{}, internal(err)
	}
	return athleteImportMatch{AthleteID: id, TeamID: in.TeamID}, nil
}

// idCardTakenError 检查证件号是否已被另一个人占用，占用时返回可直接给现场看的中文错误。
// 证件号不参与匹配，但库里一个证件号只能属于一个人（唯一索引保留）：撞号时必须报清楚占用者是谁，
// 不允许静默改库或静默跳过。excludeID 是被更新的人（新建传 0），允许他自己继续持有该证件号。
func (s *server) idCardTakenError(ctx context.Context, idCard string, excludeID int64) error {
	if idCard == "" {
		return nil
	}
	var (
		name string
		bib  sql.NullString
	)
	err := s.ev.QueryRowContext(ctx,
		`SELECT name, bib FROM athletes WHERE id_card = ? AND id <> ? ORDER BY id LIMIT 1`, idCard, excludeID).
		Scan(&name, &bib)
	switch {
	case errors.Is(err, sql.ErrNoRows):
		return nil
	case err != nil:
		return internal(err)
	}
	occupied := "未填"
	if bib.Valid && bib.String != "" {
		occupied = bib.String
	}
	return conflict(fmt.Sprintf("证件号 %s 已被另一个人占用（姓名 %s，号码布 %s）", idCard, name, occupied))
}

// importRowMessage 把业务错误转成行级提示：去掉「CONFLICT:」这类 code 前缀，只留中文 message。
func importRowMessage(err error) string {
	var api *apiError
	if errors.As(err, &api) && api.message != "" {
		return api.message
	}
	return err.Error()
}

// matchExistingAthlete 处理号码布或姓名 + 单位命中的人员：无差异时直接复用并补空字段，
// 有差异时走冲突流程，decisions 里对该身份有决策才落库。
func (s *server) matchExistingAthlete(ctx context.Context, in athleteImportRow, ex existingAthlete, decisions map[string]string) (athleteImportMatch, error) {
	changed := changedAthleteFields(ex, in)
	if len(changed) == 0 {
		if err := s.backfillEmptyAthleteFields(ctx, ex, in); err != nil {
			return athleteImportMatch{}, err
		}
		return athleteImportMatch{AthleteID: ex.ID, TeamID: in.TeamID}, nil
	}
	conflict, err := s.importConflictFor(ctx, in, ex, changed)
	if err != nil {
		return athleteImportMatch{}, err
	}
	action, decided := decisions[in.decisionKey()]
	switch {
	case !decided:
		return athleteImportMatch{Conflict: &conflict}, nil
	case action == decisionKeepExisting:
		// 人员字段保持库里的值，报名也跟随库里的单位。
		return athleteImportMatch{AthleteID: ex.ID, TeamID: ex.TeamID}, nil
	default:
		if err := s.overwriteAthleteFromImport(ctx, ex.ID, in); err != nil {
			return athleteImportMatch{}, err
		}
		return athleteImportMatch{AthleteID: ex.ID, TeamID: in.TeamID}, nil
	}
}

// importAthleteColumns 是人员匹配要读的字段，证件号/号码布/年龄用于回填与冲突判断。
const importAthleteColumns = `id, name, gender, team_id, employee_no, id_card, bib, age`

func scanExistingAthlete(row interface{ Scan(...any) error }) (existingAthlete, error) {
	var (
		a                          existingAthlete
		gender, empNo, idCard, bib sql.NullString
		teamID, age                sql.NullInt64
	)
	if err := row.Scan(&a.ID, &a.Name, &gender, &teamID, &empNo, &idCard, &bib, &age); err != nil {
		return existingAthlete{}, err
	}
	a.Gender = strPtr(gender)
	a.EmployeeNo = strPtr(empNo)
	a.IDCard = strPtr(idCard)
	a.Bib = strPtr(bib)
	a.Age = intPtr(age)
	a.TeamID = teamID.Int64
	return a, nil
}

func (s *server) athleteByBib(ctx context.Context, bib string) (existingAthlete, error) {
	return scanExistingAthlete(s.ev.QueryRowContext(ctx,
		`SELECT `+importAthleteColumns+` FROM athletes WHERE bib = ? LIMIT 1`, bib))
}

// athletesByNameTeam 按「姓名 + 单位」列出全部候选，供调用方按候选数量决定是回填、新建还是进冲突面板。
// 证件号不参与匹配，所以这里不再过滤证件号为空的人。
func (s *server) athletesByNameTeam(ctx context.Context, name string, teamID int64) ([]existingAthlete, error) {
	rows, err := s.ev.QueryContext(ctx,
		`SELECT `+importAthleteColumns+` FROM athletes WHERE name = ? AND team_id = ? ORDER BY id`, name, teamID)
	if err != nil {
		return nil, err
	}
	defer func() { _ = rows.Close() }()

	out := make([]existingAthlete, 0, 1)
	for rows.Next() {
		ex, err := scanExistingAthlete(rows)
		if err != nil {
			return nil, err
		}
		out = append(out, ex)
	}
	return out, rows.Err()
}

// changedAthleteFields 列出表里与库中不一致的字段名，顺序固定便于前端展示。
// 证件号/号码布只在两边都有值且不同时算冲突；库中为空属于待回填，不算冲突。
func changedAthleteFields(ex existingAthlete, in athleteImportRow) []string {
	var changed []string
	if ex.Name != in.Name {
		changed = append(changed, "name")
	}
	// 性别只认 男/女：表里没填或填了其它值时不做比较，避免误报冲突。
	if in.Gender != "" && (ex.Gender == nil || *ex.Gender != in.Gender) {
		changed = append(changed, "gender")
	}
	// 年龄只在两边都有值且不同时算冲突：历史数据没有年龄，缺一边属于待补，不算冲突。
	if in.Age != nil && ex.Age != nil && *ex.Age != *in.Age {
		changed = append(changed, "age")
	}
	if ex.TeamID != in.TeamID {
		changed = append(changed, "teamCode")
	}
	if identityDiffers(ex.IDCard, in.IDCard) {
		changed = append(changed, "idCard")
	}
	if identityDiffers(ex.Bib, in.Bib) {
		changed = append(changed, "bib")
	}
	return changed
}

// identityDiffers 判断身份字段（证件号/号码布）是否冲突：两边都有值且不同才算。
func identityDiffers(dbVal *string, inVal string) bool {
	return inVal != "" && dbVal != nil && *dbVal != "" && *dbVal != inVal
}

// backfillEmptyAthleteFields 只补库中为空的证件号/号码布/年龄，已有值不动（差异已由 changedAthleteFields 判过）。
func (s *server) backfillEmptyAthleteFields(ctx context.Context, ex existingAthlete, in athleteImportRow) error {
	if in.IDCard != "" && (ex.IDCard == nil || *ex.IDCard == "") {
		if err := s.idCardTakenError(ctx, in.IDCard, ex.ID); err != nil {
			return err
		}
		if _, err := s.ev.ExecContext(ctx, `UPDATE athletes SET id_card = ? WHERE id = ?`, in.IDCard, ex.ID); err != nil {
			if isIDCardConflict(err) {
				if taken := s.idCardTakenError(ctx, in.IDCard, ex.ID); taken != nil {
					return taken
				}
			}
			return internal(err)
		}
	}
	if in.Bib != "" && (ex.Bib == nil || *ex.Bib == "") {
		if _, err := s.ev.ExecContext(ctx, `UPDATE athletes SET bib = ? WHERE id = ?`, in.Bib, ex.ID); err != nil {
			return internal(err)
		}
	}
	if in.Age != nil && ex.Age == nil {
		if _, err := s.ev.ExecContext(ctx, `UPDATE athletes SET age = ? WHERE id = ?`, *in.Age, ex.ID); err != nil {
			return internal(err)
		}
	}
	return nil
}

func (s *server) importConflictFor(ctx context.Context, in athleteImportRow, ex existingAthlete, changed []string) (importConflict, error) {
	existingCode, err := s.teamCodeByID(ctx, ex.TeamID)
	if err != nil {
		return importConflict{}, err
	}
	return importConflict{
		Row:       in.Line,
		IDCard:    in.IDCard,
		Bib:       in.Bib,
		AthleteID: ex.ID,
		Existing: importAthleteView{
			Name: ex.Name, Gender: ex.Gender, TeamCode: existingCode, EmployeeNo: ex.EmployeeNo,
			IDCard: ex.IDCard, Bib: ex.Bib, Age: ex.Age,
		},
		Incoming: importAthleteView{
			Name: in.Name, Gender: nilIfEmpty(in.Gender), TeamCode: in.TeamCode,
			IDCard: nilIfEmpty(in.IDCard), Bib: nilIfEmpty(in.Bib), Age: in.Age,
		},
		ChangedFields: changed,
	}, nil
}

func (s *server) teamCodeByID(ctx context.Context, id int64) (string, error) {
	if id == 0 {
		return "", nil
	}
	var code string
	if err := s.ev.QueryRowContext(ctx, `SELECT code FROM teams WHERE id = ?`, id).Scan(&code); err != nil {
		return "", internal(err)
	}
	return code, nil
}

// overwriteAthleteFromImport 用表里的字段覆盖库中人员（keep-new 决策）。
// 表里没填的字段保留库里的值，避免决策后反而丢字段。
func (s *server) overwriteAthleteFromImport(ctx context.Context, id int64, in athleteImportRow) error {
	if in.IDCard != "" {
		if err := s.idCardTakenError(ctx, in.IDCard, id); err != nil {
			return err
		}
	}
	if _, err := s.ev.ExecContext(ctx,
		`UPDATE athletes SET name = ?, team_id = ?, gender = COALESCE(?, gender),
		        id_card = COALESCE(?, id_card), bib = COALESCE(?, bib), age = COALESCE(?, age) WHERE id = ?`,
		in.Name, in.TeamID, nullStr(&in.Gender), nullStr(&in.IDCard), nullStr(&in.Bib), nullInt(in.Age), id); err != nil {
		switch {
		case isIDCardConflict(err):
			if taken := s.idCardTakenError(ctx, in.IDCard, id); taken != nil {
				return taken
			}
		case isBibConflict(err):
			return conflict(fmt.Sprintf("号码布 %s 已被其它人员使用", in.Bib))
		}
		return internal(err)
	}
	return nil
}

// upsertImportedEntry 按「组别 + 单位 + 运动员」去重；返回 true 表示新建。
func (s *server) upsertImportedEntry(ctx context.Context, in entryDTO) (bool, error) {
	var existing int64
	var err error
	if in.AthleteID != nil {
		err = s.ev.QueryRowContext(ctx,
			`SELECT id FROM entries WHERE category_id = ? AND team_id = ? AND athlete_id = ?`,
			in.CategoryID, in.TeamID, *in.AthleteID).Scan(&existing)
	} else {
		err = s.ev.QueryRowContext(ctx,
			`SELECT id FROM entries WHERE category_id = ? AND team_id = ? AND athlete_id IS NULL`,
			in.CategoryID, in.TeamID).Scan(&existing)
	}

	switch {
	case errors.Is(err, sql.ErrNoRows):
		if _, err := s.ev.ExecContext(ctx,
			`INSERT INTO entries (event_id, category_id, team_id, athlete_id, member_names, bib, seed, heat, status)
			 VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`,
			in.EventID, in.CategoryID, in.TeamID, nullI64(in.AthleteID), marshalNames(in.MemberNames),
			nullStr(in.Bib), nullStr(in.Seed), nullI64(in.Heat), orDefault(in.Status, "registered")); err != nil {
			return false, err
		}
		return true, nil
	case err != nil:
		return false, err
	default:
		if _, err := s.ev.ExecContext(ctx,
			`UPDATE entries SET member_names = ?, bib = ?, seed = ?, heat = ?, status = ? WHERE id = ?`,
			marshalNames(in.MemberNames), nullStr(in.Bib), nullStr(in.Seed), nullI64(in.Heat),
			orDefault(in.Status, "registered"), existing); err != nil {
			return false, err
		}
		return false, nil
	}
}