package httpapi

import (
	"net/http"
	"strings"

	"git.yeij.top/AskaEth/Scoreboard/server/internal/domain"
)

// ---------- 成绩 ----------

func (s *server) listResultsHandler(w http.ResponseWriter, r *http.Request) (any, error) {
	eventID, _ := int64Query(r, "eventId")
	state := strings.TrimSpace(r.URL.Query().Get("state"))
	if state != "" && state != string(domain.ResultStateDraft) && state != string(domain.ResultStatePublished) {
		return nil, badRequest("state 只能是 draft/published", state)
	}
	page, size := pageQuery(r)
	return s.listResultsPage(r.Context(), eventID, state, page, size)
}

func (s *server) saveDraftHandler(w http.ResponseWriter, r *http.Request) (any, error) {
	var in saveDraftPayload
	if err := decodeJSON(r, &in); err != nil {
		return nil, err
	}
	if in.EventID == 0 {
		return nil, badRequest("eventId 必填", nil)
	}
	if len(in.Results) == 0 {
		return nil, badRequest("results 不能为空", nil)
	}
	return nil, s.idempotent(w, r, in.RequestID, func() (any, error) {
		saved, err := s.upsertDraft(r.Context(), in.EventID, middlewareUserID(r), in.Results)
		if err != nil {
			return nil, err
		}
		s.audit(r.Context(), "result.draft.save", "event", in.EventID, nil, saved)
		return saved, nil
	})
}

func (s *server) publishHandler(w http.ResponseWriter, r *http.Request) (any, error) {
	var in publishPayload
	if err := decodeJSON(r, &in); err != nil {
		return nil, err
	}
	return nil, s.idempotent(w, r, in.RequestID, func() (any, error) {
		return s.publishResults(r.Context(), in, middlewareUserID(r))
	})
}

func (s *server) unpublishHandler(w http.ResponseWriter, r *http.Request) (any, error) {
	var in publishPayload
	if err := decodeJSON(r, &in); err != nil {
		return nil, err
	}
	return nil, s.idempotent(w, r, in.RequestID, func() (any, error) {
		return s.unpublishResults(r.Context(), in, middlewareUserID(r))
	})
}

func (s *server) voidResultHandler(w http.ResponseWriter, r *http.Request) (any, error) {
	id, err := pathID(r, "id")
	if err != nil {
		return nil, err
	}
	var in voidResultPayload
	if err := decodeJSON(r, &in); err != nil {
		return nil, err
	}
	return nil, s.idempotent(w, r, in.RequestID, func() (any, error) {
		return s.voidResult(r.Context(), id, in.Reason, middlewareUserID(r))
	})
}

// ---------- 积分与排名 ----------

func (s *server) standingsHandler(w http.ResponseWriter, r *http.Request) (any, error) {
	return s.standingsSnapshot(r.Context(), s.ev)
}

func (s *server) athleteStandingsHandler(w http.ResponseWriter, r *http.Request) (any, error) {
	in, err := s.loadStandingsInput(r.Context(), s.ev)
	if err != nil {
		return nil, err
	}
	// 展示字段以全量单位表为准（含停用单位），否则停用单位的运动员会显示空白单位名。
	teams, err := s.teamMap(r.Context())
	if err != nil {
		return nil, err
	}
	genders := make(map[int64]*string, len(in.Athletes))
	for _, a := range in.Athletes {
		if a.Gender != "" {
			g := a.Gender
			genders[a.ID] = &g
		}
	}
	rows := domain.BuildAthleteStandings(in)
	out := make([]athleteStandingDTO, 0, len(rows))
	for _, row := range rows {
		item := athleteStandingDTO{
			Rank:        row.Rank,
			AthleteID:   row.AthleteID,
			AthleteName: row.Name,
			Gender:      genders[row.AthleteID],
			TeamID:      row.TeamID,
			TeamCode:    row.TeamCode,
			TeamName:    row.TeamName,
			TotalPoints: row.Points,
			Gold:        row.Gold,
			Silver:      row.Silver,
			Bronze:      row.Bronze,
		}
		if t, ok := teams[row.TeamID]; ok {
			item.TeamCode = t.Code
			item.TeamName = t.Name
			item.ShortName = t.ShortName
			// 单位表里可能存的是空串，下发前统一收敛成 null，与总积分榜口径一致。
			item.LogoPath = nilIfEmpty(strValue(t.LogoPath))
		}
		out = append(out, item)
	}
	return out, nil
}

func (s *server) breakdownHandler(w http.ResponseWriter, r *http.Request) (any, error) {
	id, err := pathID(r, "id")
	if err != nil {
		return nil, err
	}
	return s.teamBreakdown(r.Context(), id)
}

// ---------- 人工调整 ----------

func (s *server) listAdjustmentsHandler(w http.ResponseWriter, r *http.Request) (any, error) {
	teamID, _ := int64Query(r, "teamId")
	page, size := pageQuery(r)
	return s.listAdjustments(r.Context(), teamID, page, size)
}

func (s *server) createAdjustmentHandler(w http.ResponseWriter, r *http.Request) (any, error) {
	var in adjustmentInput
	if err := decodeJSON(r, &in); err != nil {
		return nil, err
	}
	return nil, s.idempotent(w, r, in.RequestID, func() (any, error) {
		return s.createAdjustment(r.Context(), in, middlewareUserID(r))
	})
}

func (s *server) voidAdjustmentHandler(w http.ResponseWriter, r *http.Request) (any, error) {
	id, err := pathID(r, "id")
	if err != nil {
		return nil, err
	}
	var in voidAdjustmentPayload
	if err := decodeJSON(r, &in); err != nil {
		return nil, err
	}
	return nil, s.idempotent(w, r, in.RequestID, func() (any, error) {
		return s.voidAdjustment(r.Context(), id, middlewareUserID(r), in.Reason)
	})
}

// ---------- 纪录 ----------

func (s *server) listRecordsHandler(w http.ResponseWriter, r *http.Request) (any, error) {
	eventID, _ := int64Query(r, "eventId")
	return s.listRecords(r.Context(), eventID)
}

func (s *server) createRecordBreakHandler(w http.ResponseWriter, r *http.Request) (any, error) {
	var in recordBreakInput
	if err := decodeJSON(r, &in); err != nil {
		return nil, err
	}
	return nil, s.idempotent(w, r, in.RequestID, func() (any, error) {
		created, err := s.createRecordBreak(r.Context(), in, middlewareUserID(r))
		if err != nil {
			return nil, err
		}
		s.audit(r.Context(), "record_break.create", "record_break", created.ID, nil, created)
		return created, nil
	})
}

func (s *server) approveRecordBreakHandler(w http.ResponseWriter, r *http.Request) (any, error) {
	id, err := pathID(r, "id")
	if err != nil {
		return nil, err
	}
	return s.approveRecordBreak(r.Context(), id, middlewareUserID(r))
}

// ---------- 大屏控制与运维 ----------

func (s *server) displayCommandHandler(w http.ResponseWriter, r *http.Request) (any, error) {
	var in displayCommandInput
	if err := decodeJSON(r, &in); err != nil {
		return nil, err
	}
	if in.Action == "" {
		return nil, badRequest("action 必填", nil)
	}
	if s.display != nil {
		if err := s.display.SendDisplayCommand(in.Action, in.Payload); err != nil {
			return nil, internal(err)
		}
	}
	s.audit(r.Context(), "display.command", "display", 0, nil, in)
	return nil, nil
}

func (s *server) listAuditLogsHandler(w http.ResponseWriter, r *http.Request) (any, error) {
	page, size := pageQuery(r)
	entityType := strings.TrimSpace(r.URL.Query().Get("entityType"))
	userID, _ := int64Query(r, "userId")
	return s.listAuditLogs(r.Context(), page, size, entityType, userID)
}

func (s *server) backupHandler(w http.ResponseWriter, r *http.Request) (any, error) {
	return s.backup(r.Context())
}