package main

import (
	"log/slog"
	"net/http"
	"strings"
	"time"

	"git.loyso.art/frx/kurious/assets/kurious"
	"git.loyso.art/frx/kurious/internal/common/config"
	"git.loyso.art/frx/kurious/internal/common/generator"
	"git.loyso.art/frx/kurious/internal/common/xcontext"
	xhttp "git.loyso.art/frx/kurious/internal/kurious/ports/http"
	"github.com/gorilla/mux"
)

func makePathTemplate(params ...string) string {
	var sb strings.Builder
	for _, param := range params {
		sb.Grow(len(param) + 3)

		sb.WriteRune('/')
		sb.WriteRune('{')
		sb.WriteString(param)
		sb.WriteRune('}')
	}

	return sb.String()
}

func setupHTTPWithTempl(srv xhttp.Server, router *mux.Router, log *slog.Logger) {
	coursesRouter := router.PathPrefix("/courses").Subrouter().StrictSlash(true)

	coursesAPI := srv.CoursesByTempl()

	coursesRouter.HandleFunc("/", coursesAPI.List).Methods(http.MethodGet)
	coursesListLearningOnlyPath := makePathTemplate(xhttp.LearningTypePathParam)
	coursesRouter.HandleFunc(coursesListLearningOnlyPath, coursesAPI.List).Methods(http.MethodGet)
	coursesListFullPath := makePathTemplate(xhttp.LearningTypePathParam, xhttp.ThematicTypePathParam)
	coursesRouter.HandleFunc(coursesListFullPath, coursesAPI.List).Methods(http.MethodGet)
}

func setupHTTPWithGoTemplates(srv xhttp.Server, router *mux.Router, log *slog.Logger) {
	coursesAPI := srv.Courses()

	coursesRouter := router.PathPrefix("/courses").Subrouter().StrictSlash(true)
	coursesRouter.HandleFunc("/", coursesAPI.List).Methods(http.MethodGet)
	coursesListLearningOnlyPath := makePathTemplate(xhttp.LearningTypePathParam)
	coursesRouter.HandleFunc(coursesListLearningOnlyPath, coursesAPI.List).Methods(http.MethodGet)
	coursesListFullPath := makePathTemplate(xhttp.LearningTypePathParam, xhttp.ThematicTypePathParam)
	coursesRouter.HandleFunc(coursesListFullPath, coursesAPI.List).Methods(http.MethodGet)

	courseRouter := router.PathPrefix("/course").PathPrefix("/{course_id}").Subrouter()
	courseRouter.HandleFunc("/", coursesAPI.Get).Methods(http.MethodGet)
	courseRouter.HandleFunc("/short", coursesAPI.GetShort).Methods(http.MethodGet)
	courseRouter.HandleFunc("/editdesc", coursesAPI.RenderEditDescription).Methods(http.MethodGet)
	courseRouter.HandleFunc("/description", coursesAPI.UpdateCourseDescription).Methods(http.MethodPut)
}

func setupHTTP(cfg config.HTTP, srv xhttp.Server, log *slog.Logger) *http.Server {
	router := mux.NewRouter()

	router.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
		w.WriteHeader(http.StatusOK)
	})

	router.Use(mux.CORSMethodMiddleware(router))
	router.Use(middlewareLogger(log, cfg.Engine))

	if cfg.Engine == "templ" {
		setupHTTPWithTempl(srv, router, log)
	} else {
		setupHTTPWithGoTemplates(srv, router, log)
	}

	if cfg.MountLive {
		fs := http.FileServer(http.Dir("./assets/kurious/static/"))
		router.PathPrefix("/static/").Handler(http.StripPrefix("/static/", fs)).Methods(http.MethodGet)

		registerFile := func(filepath string) {
			if !strings.HasPrefix(filepath, "/") {
				filepath = "/" + filepath
			}

			relativePath := "./assets/kurious" + filepath
			router.HandleFunc(filepath, func(w http.ResponseWriter, r *http.Request) {
				http.ServeFile(w, r, relativePath)
			}).Methods(http.MethodGet)
		}

		for _, file := range []string{
			"robots.txt",
			"android-chrome-192x192.png",
			"android-chrome-512x512.png",
			"apple-touch-icon.png",
			"favicon-16x16.png",
			"favicon-32x32.png",
			"favicon.ico",
			"site.webmanifest",
		} {
			registerFile(file)
		}
	} else {
		fs := kurious.AsHTTPFileHandler()
		router.PathPrefix("/").Handler(fs).Methods(http.MethodGet)
	}

	return &http.Server{
		Addr:    cfg.ListenAddr,
		Handler: router,
	}
}

func middlewareLogger(log *slog.Logger, engine string) mux.MiddlewareFunc {
	return func(next http.Handler) http.Handler {
		return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
			ctx := r.Context()
			requestID := r.Header.Get("x-request-id")
			if requestID == "" {
				requestID = generator.RandomInt64ID()
			}
			ctx = xcontext.WithLogFields(
				ctx,
				slog.String("request_id", requestID),
				slog.String("engine", engine),
			)

			xcontext.LogInfo(
				ctx, log, "incoming request",
				slog.String("method", r.Method),
				slog.String("path", r.URL.Path),
			)

			start := time.Now()
			next.ServeHTTP(w, r.WithContext(ctx))
			elapsed := time.Since(start).Truncate(time.Millisecond)

			xcontext.LogInfo(
				ctx, log, "request processed",
				slog.Duration("elapsed", elapsed),
			)
		})
	}
}