package handler

import (
	"net/http"
	"spend-sparrow/handler/middleware"
	"spend-sparrow/service"
	t "spend-sparrow/template/transaction_recurring"
	"spend-sparrow/types"
	"spend-sparrow/utils"

	"github.com/a-h/templ"
)

type TransactionRecurring interface {
	Handle(router *http.ServeMux)
}

type TransactionRecurringImpl struct {
	s service.TransactionRecurring
	r *Render
}

func NewTransactionRecurring(s service.TransactionRecurring, r *Render) TransactionRecurring {
	return TransactionRecurringImpl{
		s: s,
		r: r,
	}
}

func (h TransactionRecurringImpl) Handle(r *http.ServeMux) {
	r.Handle("GET /transaction-recurring/{id}", h.handleTransactionRecurringItemComp())
	r.Handle("POST /transaction-recurring/{id}", h.handleUpdateTransactionRecurring())
	r.Handle("DELETE /transaction-recurring/{id}", h.handleDeleteTransactionRecurring())
}

func (h TransactionRecurringImpl) handleTransactionRecurringItemComp() http.HandlerFunc {
	return func(w http.ResponseWriter, r *http.Request) {
		user := middleware.GetUser(r)
		if user == nil {
			utils.DoRedirect(w, r, "/auth/signin")
			return
		}

		id := r.PathValue("id")
		accountId := r.URL.Query().Get("account-id")
		treasureChestId := r.URL.Query().Get("treasure-chest-id")

		if id == "new" {
			comp := t.EditTransactionRecurring(nil, accountId, treasureChestId)
			h.r.Render(r, w, comp)
			return
		}

		transaction, err := h.s.Get(user, id)
		if err != nil {
			handleError(w, r, err)
			return
		}

		var comp templ.Component
		if r.URL.Query().Get("edit") == "true" {
			comp = t.EditTransactionRecurring(transaction, accountId, treasureChestId)
		} else {
			comp = t.TransactionRecurringItem(transaction)
		}
		h.r.Render(r, w, comp)
	}
}

func (h TransactionRecurringImpl) handleUpdateTransactionRecurring() http.HandlerFunc {
	return func(w http.ResponseWriter, r *http.Request) {
		user := middleware.GetUser(r)
		if user == nil {
			utils.DoRedirect(w, r, "/auth/signin")
			return
		}

		var (
			transaction *types.TransactionRecurring
			err         error
		)
		input := types.TransactionRecurringInput{
			Id:              r.PathValue("id"),
			IntervalMonths:  r.FormValue("interval-months"),
			LastExecution:   r.FormValue("last-execution"),
			Active:          r.FormValue("active"),
			Party:           r.FormValue("party"),
			Description:     r.FormValue("description"),
			AccountId:       r.FormValue("account-id"),
			TreasureChestId: r.FormValue("treasure-chest-id"),
			Value:           r.FormValue("value"),
		}

		if input.Id == "new" {
			transaction, err = h.s.Add(user, input)
			if err != nil {
				handleError(w, r, err)
				return
			}
		} else {
			transaction, err = h.s.Update(user, input)
			if err != nil {
				handleError(w, r, err)
				return
			}
		}

		comp := t.TransactionRecurringItem(transaction)
		h.r.Render(r, w, comp)
	}
}

func (h TransactionRecurringImpl) handleDeleteTransactionRecurring() http.HandlerFunc {
	return func(w http.ResponseWriter, r *http.Request) {
		user := middleware.GetUser(r)
		if user == nil {
			utils.DoRedirect(w, r, "/auth/signin")
			return
		}

		id := r.PathValue("id")

		err := h.s.Delete(user, id)
		if err != nil {
			handleError(w, r, err)
			return
		}
	}
}