package service

import (
	"me-fit/template"
	"me-fit/template/workout"

	"database/sql"
	"net/http"
	"strconv"
	"time"

	"github.com/prometheus/client_golang/prometheus"
	"github.com/prometheus/client_golang/prometheus/promauto"
)

var (
	metrics = promauto.NewCounterVec(
		prometheus.CounterOpts{
			Name: "mefit_api_workout_total",
			Help: "The total number of workout api requests processed",
		},
		[]string{"type"},
	)
)

func HandleWorkoutPage(db *sql.DB) http.HandlerFunc {
	return func(w http.ResponseWriter, r *http.Request) {
		currentDate := time.Now().Format("2006-01-02")
		inner := workout.WorkoutComp(currentDate)
		user_comp := UserInfoComp(verifySessionAndReturnUser(db, r))
		layout := template.Layout(inner, user_comp)
		layout.Render(r.Context(), w)
	}
}

func HandleNewWorkout(db *sql.DB) http.HandlerFunc {
	return func(w http.ResponseWriter, r *http.Request) {
		metrics.WithLabelValues("new").Inc()

		user := verifySessionAndReturnUser(db, r)
		if user == nil {
			http.Error(w, "Unauthorized", http.StatusUnauthorized)
			return
		}

		var dateStr = r.FormValue("date")
		var typeStr = r.FormValue("type")
		var setsStr = r.FormValue("sets")
		var repsStr = r.FormValue("reps")

		if dateStr == "" || typeStr == "" || setsStr == "" || repsStr == "" {
			http.Error(w, "Missing required fields", http.StatusBadRequest)
			return
		}

		date, err := time.Parse("2006-01-02", dateStr)
		if err != nil {
			http.Error(w, err.Error(), http.StatusBadRequest)
			return
		}

		sets, err := strconv.Atoi(setsStr)
		if err != nil {
			http.Error(w, err.Error(), http.StatusBadRequest)
			return
		}

		reps, err := strconv.Atoi(repsStr)
		if err != nil {
			http.Error(w, err.Error(), http.StatusBadRequest)
			return
		}

		_, err = db.Exec("INSERT INTO workout (user_id, date, type, sets, reps) VALUES (?, ?, ?, ?, ?)", user.user_uuid, date, typeStr, sets, reps)

		if err != nil {
			http.Error(w, err.Error(), http.StatusInternalServerError)
			return
		}

		wo := workout.Workout{
			Date: r.FormValue("date"),
			Type: r.FormValue("type"),
			Sets: r.FormValue("sets"),
			Reps: r.FormValue("reps"),
		}

		workout.WorkoutItemComp(wo, true).Render(r.Context(), w)
	}
}

func HandleGetWorkouts(db *sql.DB) http.HandlerFunc {
	return func(w http.ResponseWriter, r *http.Request) {
		metrics.WithLabelValues("get").Inc()

		user := verifySessionAndReturnUser(db, r)
		if user == nil {
			http.Error(w, "Unauthorized", http.StatusUnauthorized)
			return
		}

		rows, err := db.Query("SELECT rowid, date, type, sets, reps FROM workout WHERE user_id = ?", user.user_uuid)
		if err != nil {
			http.Error(w, err.Error(), http.StatusInternalServerError)
			return
		}

		var workouts = make([]workout.Workout, 0)
		for rows.Next() {
			var workout workout.Workout

			err = rows.Scan(&workout.Id, &workout.Date, &workout.Type, &workout.Sets, &workout.Reps)
			if err != nil {
				http.Error(w, err.Error(), http.StatusInternalServerError)
				return
			}

			workouts = append(workouts, workout)
		}

		workout.WorkoutListComp(workouts).Render(r.Context(), w)
	}
}

func HandleDeleteWorkout(db *sql.DB) http.HandlerFunc {
	return func(w http.ResponseWriter, r *http.Request) {
		metrics.WithLabelValues("delete").Inc()

		user := verifySessionAndReturnUser(db, r)

		rowId := r.PathValue("id")
		if rowId == "" {
			http.Error(w, "Missing required fields", http.StatusBadRequest)
			return
		}

		res, err := db.Exec("DELETE FROM workout WHERE user_id = ? AND rowid = ?", user.user_uuid, rowId)
		if err != nil {
			http.Error(w, err.Error(), http.StatusInternalServerError)
			return
		}

		rows, err := res.RowsAffected()
		if err != nil {
			http.Error(w, err.Error(), http.StatusInternalServerError)
			return
		}

		if rows == 0 {
			http.Error(w, "Not found", http.StatusNotFound)
			return
		}
	}
}