qbank/internal/handlers/test.go

package handlers

import (
	"encoding/binary"
	"encoding/hex"
	"fmt"
	"log/slog"
	"math/rand"
	"net/http"
	"strconv"
	"time"

	"github.com/go-chi/chi/v5"

	"qbank/internal/auth"
	"qbank/internal/db"
	"qbank/internal/models"
	"qbank/internal/sampling"
)

type TestHandler struct {
	auth   *auth.Manager
	repo   *db.Repo
	render *Renderer
}

func NewTestHandler(a *auth.Manager, repo *db.Repo, r *Renderer) *TestHandler {
	return &TestHandler{auth: a, repo: repo, render: r}
}

func (h *TestHandler) NewGet(w http.ResponseWriter, r *http.Request) {
	totalQ, _ := h.repo.CountQuestions()
	sourceCounts, _ := h.repo.CountBySource()

	data := BaseData(h.auth, r)
	data["TotalQ"] = totalQ
	data["SourceStats"] = sourceCounts
	h.render.Render(w, http.StatusOK, "test_new", data)
}

func (h *TestHandler) NewPost(w http.ResponseWriter, r *http.Request) {
	if !h.auth.CheckCSRF(r) {
		HTTPError(w, http.StatusForbidden)
		return
	}
	r.Body = http.MaxBytesReader(w, r.Body, 4096)
	if err := r.ParseForm(); err != nil {
		HTTPError(w, http.StatusBadRequest)
		return
	}

	user := auth.UserFromCtx(r.Context())
	source := r.FormValue("source")
	mode := r.FormValue("mode")

	n, _ := strconv.Atoi(r.FormValue("n"))
	if n <= 0 {
		n = 10
	}

	questions, err := h.repo.ListQuestions(db.ListFilter{Source: source})
	if err != nil {
		slog.Error("list questions for test", "err", err)
		HTTPError(w, http.StatusInternalServerError)
		return
	}

	if len(questions) == 0 {
		totalQ, _ := h.repo.CountQuestions()
		sourceCounts, _ := h.repo.CountBySource()
		data := BaseData(h.auth, r)
		data["TotalQ"] = totalQ
		data["SourceStats"] = sourceCounts
		data["Error"] = "No questions available for the selected filter."
		h.render.Render(w, http.StatusOK, "test_new", data)
		return
	}

	if n > len(questions) {
		n = len(questions)
	}

	ids := make([]string, len(questions))
	for i, q := range questions {
		ids[i] = q.ID
	}

	var candidates []sampling.Candidate
	if mode == "uniform" {
		candidates = make([]sampling.Candidate, len(questions))
		for i, q := range questions {
			candidates[i] = sampling.Candidate{ID: q.ID, Weight: 1.0}
		}
	} else {
		stats, err := h.repo.GetStatsForUser(user.ID, ids)
		if err != nil {
			slog.Error("get stats for test", "err", err)
			HTTPError(w, http.StatusInternalServerError)
			return
		}
		now := time.Now()
		candidates = make([]sampling.Candidate, len(questions))
		for i, q := range questions {
			candidates[i] = sampling.Candidate{
				ID:     q.ID,
				Weight: sampling.ComputeWeight(stats[q.ID], now),
			}
		}
	}

	rng := rand.New(rand.NewSource(time.Now().UnixNano()))
	picked := sampling.SelectWeighted(candidates, n, rng)
	// Shuffle presentation order independently of selection order.
	rng.Shuffle(len(picked), func(i, j int) { picked[i], picked[j] = picked[j], picked[i] })

	pickedIDs := make([]string, len(picked))
	for i, c := range picked {
		pickedIDs[i] = c.ID
	}

	testID, err := h.repo.CreateTest(user.ID, pickedIDs)
	if err != nil {
		slog.Error("create test", "err", err)
		HTTPError(w, http.StatusInternalServerError)
		return
	}

	http.Redirect(w, r, fmt.Sprintf("/test/%d/q/1", testID), http.StatusSeeOther)
}

func (h *TestHandler) QuestionGet(w http.ResponseWriter, r *http.Request) {
	n, test, ok := h.loadTestAndN(w, r)
	if !ok {
		return
	}

	questionID := test.QuestionIDs[n-1]
	q, answers, err := h.repo.GetQuestion(questionID)
	if err != nil {
		slog.Error("get question for test", "err", err)
		HTTPError(w, http.StatusInternalServerError)
		return
	}

	data := BaseData(h.auth, r)
	data["TestID"] = test.ID
	data["N"] = n
	data["Total"] = test.NQuestions
	data["Question"] = q
	data["Answers"] = deterministicShuffle(answers, test.ID, questionID)
	data["ProgressPct"] = (n - 1) * 100 / test.NQuestions

	h.render.Render(w, http.StatusOK, "test_question", data)
}

func (h *TestHandler) QuestionPost(w http.ResponseWriter, r *http.Request) {
	n, test, ok := h.loadTestAndN(w, r)
	if !ok {
		return
	}

	if !h.auth.CheckCSRF(r) {
		HTTPError(w, http.StatusForbidden)
		return
	}
	r.Body = http.MaxBytesReader(w, r.Body, 4096)
	if err := r.ParseForm(); err != nil {
		HTTPError(w, http.StatusBadRequest)
		return
	}

	user := auth.UserFromCtx(r.Context())
	questionID := test.QuestionIDs[n-1]

	_, answers, err := h.repo.GetQuestion(questionID)
	if err != nil {
		slog.Error("get question for answer", "err", err)
		HTTPError(w, http.StatusInternalServerError)
		return
	}

	var selectedID *int64
	var isCorrect bool
	if rawID := r.FormValue("answer_id"); rawID != "" {
		id, err := strconv.ParseInt(rawID, 10, 64)
		if err == nil {
			selectedID = &id
			for _, a := range answers {
				if a.ID == id && a.IsCorrect {
					isCorrect = true
					break
				}
			}
		}
	}

	if err := h.repo.RecordAnswer(test.ID, questionID, selectedID, isCorrect); err != nil {
		slog.Error("record answer", "err", err)
		HTTPError(w, http.StatusInternalServerError)
		return
	}
	if err := h.repo.UpsertStat(user.ID, questionID, isCorrect); err != nil {
		slog.Error("upsert stat", "err", err)
	}

	if n < test.NQuestions {
		http.Redirect(w, r, fmt.Sprintf("/test/%d/q/%d", test.ID, n+1), http.StatusSeeOther)
		return
	}

	if err := h.repo.FinishTest(test.ID); err != nil {
		slog.Error("finish test", "err", err)
	}
	http.Redirect(w, r, fmt.Sprintf("/test/%d/results", test.ID), http.StatusSeeOther)
}

func (h *TestHandler) ResultsGet(w http.ResponseWriter, r *http.Request) {
	user := auth.UserFromCtx(r.Context())
	testID, err := strconv.ParseInt(chi.URLParam(r, "id"), 10, 64)
	if err != nil {
		HTTPError(w, http.StatusNotFound)
		return
	}
	test, err := h.repo.GetTest(testID)
	if err != nil || test.UserID != user.ID {
		HTTPError(w, http.StatusNotFound)
		return
	}
	data := BaseData(h.auth, r)
	data["Test"] = test
	h.render.Render(w, http.StatusOK, "test_results", data)
}

// loadTestAndN extracts and validates the test ID and question number (n) from
// URL params. Returns the 1-based question index and the test, or writes an
// error and returns false.
func (h *TestHandler) loadTestAndN(w http.ResponseWriter, r *http.Request) (int, *models.Test, bool) {
	user := auth.UserFromCtx(r.Context())

	testID, err := strconv.ParseInt(chi.URLParam(r, "id"), 10, 64)
	if err != nil {
		HTTPError(w, http.StatusNotFound)
		return 0, nil, false
	}

	n, err := strconv.Atoi(chi.URLParam(r, "n"))
	if err != nil {
		HTTPError(w, http.StatusNotFound)
		return 0, nil, false
	}

	test, err := h.repo.GetTest(testID)
	if err != nil || test.UserID != user.ID {
		HTTPError(w, http.StatusNotFound)
		return 0, nil, false
	}

	if n < 1 || n > test.NQuestions {
		HTTPError(w, http.StatusNotFound)
		return 0, nil, false
	}

	return n, test, true
}

// deterministicShuffle returns a copy of answers shuffled by a seed derived
// from the test ID and question ID, so the order is stable across page reloads.
func deterministicShuffle(answers []*models.Answer, testID int64, questionID string) []*models.Answer {
	b, _ := hex.DecodeString(questionID)
	qInt := int64(binary.BigEndian.Uint64(b))
	rng := rand.New(rand.NewSource(testID ^ qInt))
	out := make([]*models.Answer, len(answers))
	copy(out, answers)
	rng.Shuffle(len(out), func(i, j int) { out[i], out[j] = out[j], out[i] })
	return out
}