go.charczuk.com@v0.0.0-20240327042549-bc490516bd1a/projects/kana-server/pkg/controller/quiz.go

/*

Copyright (c) 2023 - Present. Will Charczuk. All rights reserved.
Use of this source code is governed by a MIT license that can be found in the LICENSE file at the root of the repository.

*/

package controller

import (
	"net/http"
	"time"

	"go.charczuk.com/sdk/apputil"
	"go.charczuk.com/sdk/uuid"
	"go.charczuk.com/sdk/web"

	"go.charczuk.com/projects/kana-server/pkg/config"
	"go.charczuk.com/projects/kana-server/pkg/kana"
	"go.charczuk.com/projects/kana-server/pkg/model"
	"go.charczuk.com/projects/kana-server/pkg/types"
)

// Quiz is the quiz controller.
type Quiz struct {
	apputil.BaseController

	Config config.Config
	Model  model.Manager
}

// Register adds the controller methods to the app.
func (q Quiz) Register(app *web.App) {
	app.Get("/quiz.new", web.SessionRequired(q.getQuizNew))
	app.Post("/quiz.new", web.SessionRequired(q.postQuizNew))
	app.Get("/quiz/:id", web.SessionRequired(q.getQuizPrompt))
	app.Post("/quiz/:id/answer", web.SessionRequired(q.postQuizAnswer))
}

// GET /quiz.new
func (q Quiz) getQuizNew(ctx web.Context) web.Result {
	return ctx.Views().ViewStatus(http.StatusOK, "quiz_new", nil)
}

// POST /quiz.new
func (q Quiz) postQuizNew(ctx web.Context) web.Result {
	userID := q.GetUserID(ctx)

	maxQuestions, _ := web.FormValue[int](ctx, "maxQuestions")
	maxPrompts, _ := web.FormValue[int](ctx, "maxPrompts")
	maxRepeatHistory, _ := web.FormValue[int](ctx, "maxRepeatHistory")

	includeHiragana, _ := web.FormValue[string](ctx, "hiragana")
	includeKatakana, _ := web.FormValue[string](ctx, "katakana")

	var inputs []map[string]string
	if includeHiragana != "" {
		inputs = append(inputs, kana.Hiragana)
	}
	if includeKatakana != "" {
		inputs = append(inputs, kana.Katakana)
	}
	prompts := kana.SelectCount(kana.Merge(inputs...), maxPrompts)
	promptWeights := kana.CreateWeights(prompts)

	quiz := types.Quiz{
		ID:               uuid.V4(),
		UserID:           userID,
		CreatedUTC:       time.Now().UTC(),
		Hiragana:         includeHiragana != "",
		Katakana:         includeKatakana != "",
		MaxPrompts:       maxPrompts,
		MaxQuestions:     maxQuestions,
		MaxRepeatHistory: maxRepeatHistory,
		Results:          nil,
		Prompts:          prompts,
		PromptWeights:    promptWeights,
		PromptHistory:    nil,
	}
	if err := q.Model.CreateQuiz(ctx, quiz); err != nil {
		return ctx.Views().InternalError(err)
	}
	return web.RedirectWithMethodf(http.MethodGet, "/quiz/%s", quiz.ID.String())
}

// GET /quiz/:id
func (q Quiz) getQuizPrompt(ctx web.Context) web.Result {
	userID := q.GetUserID(ctx)
	quizID, err := web.RouteValue[uuid.UUID](ctx, "id")
	if err != nil {
		return ctx.Views().BadRequest(err)
	}
	quiz, found, err := q.Model.GetQuiz(ctx, quizID)
	if err != nil {
		return ctx.Views().InternalError(err)
	}
	if !found || !quiz.UserID.Equal(userID) {
		return ctx.Views().NotFound()
	}

	// filter out the prompts (and weights)
	// for which we have recent history
	nonQueried := make(map[string]string)
	for key, value := range quiz.Prompts {
		nonQueried[key] = value
	}
	nonQueriedWeights := make(map[string]float64)
	for key, value := range quiz.PromptWeights {
		nonQueriedWeights[key] = value
	}
	for _, queried := range quiz.PromptHistory {
		delete(nonQueried, queried)
		delete(nonQueriedWeights, queried)
	}
	prompt, expected := kana.SelectWeighted(nonQueried, nonQueriedWeights)
	return ctx.Views().ViewStatus(http.StatusOK, "quiz", types.QuizPrompt{
		Quiz:       quiz,
		CreatedUTC: time.Now().UTC(),
		Prompt:     prompt,
		Expected:   expected,
	})
}

// POST /quiz/:id/answer
func (q Quiz) postQuizAnswer(ctx web.Context) web.Result {
	userID := q.GetUserID(ctx)
	quizID, err := web.RouteValue[uuid.UUID](ctx, "id")
	if err != nil {
		return ctx.Views().BadRequest(err)
	}
	quiz, found, err := q.Model.GetQuiz(ctx, quizID)
	if err != nil {
		return ctx.Views().InternalError(err)
	}
	if !found || !quiz.UserID.Equal(userID) {
		return ctx.Views().NotFound()
	}
	createdUTC, err := web.FormValue[int64](ctx, "createdUTC")
	if err != nil {
		return ctx.Views().BadRequest(err)
	}
	prompt, err := web.FormValue[string](ctx, "prompt")
	if err != nil {
		return ctx.Views().BadRequest(err)
	}
	expected, err := web.FormValue[string](ctx, "expected")
	if err != nil {
		return ctx.Views().BadRequest(err)
	}
	actual, err := web.FormValue[string](ctx, "actual")
	if err != nil {
		return ctx.Views().BadRequest(err)
	}

	quizResult := types.QuizResult{
		ID:          uuid.V4(),
		UserID:      userID,
		QuizID:      quiz.ID,
		CreatedUTC:  time.Unix(0, createdUTC).UTC(),
		AnsweredUTC: time.Now().UTC(),
		Prompt:      prompt,
		Expected:    expected,
		Actual:      actual,
	}
	if quizResult.Correct() {
		kana.DecreaseWeight(quiz.PromptWeights, prompt)
	} else {
		kana.IncreaseWeight(quiz.PromptWeights, prompt)
	}
	quiz.LastAnsweredUTC = time.Now().UTC()
	quiz.PromptHistory = kana.ListAddFixedLength(quiz.PromptHistory, prompt, quiz.MaxRepeatHistory)
	if err := q.Model.UpdateQuiz(ctx, quiz); err != nil {
		return ctx.Views().InternalError(err)
	}
	if err := q.Model.AddQuizResult(ctx, quizResult); err != nil {
		return ctx.Views().InternalError(err)
	}

	if quiz.MaxQuestions > 0 {
		if len(quiz.Results)+1 >= quiz.MaxQuestions {
			return web.RedirectWithMethodf(http.MethodGet, "/home/%s", quiz.ID.String())
		}
	}

	return web.RedirectWithMethodf(http.MethodGet, "/quiz/%s", quiz.ID.String())
}