package tag

import (
	"fmt"
	"net/http"
	"spend-sparrow/internal/core"

	"github.com/google/uuid"
)

const (
	DECIMALS_MULTIPLIER = 100
)

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

type HandlerImpl struct {
	s Service
	r *core.Render
}

func NewHandler(s Service, r *core.Render) Handler {
	return HandlerImpl{
		s: s,
		r: r,
	}
}

func (h HandlerImpl) Handle(r *http.ServeMux) {
	r.Handle("GET /tag", h.handlePage())
	r.Handle("POST /tag/search", h.handleInlineEditSearch())
	r.Handle("GET /tag/new", h.handleNew())
	r.Handle("GET /tag/{id}", h.handleEdit())
	r.Handle("POST /tag/{id}", h.handlePost())
	r.Handle("DELETE /tag/{id}", h.handleDelete())
}

func (h HandlerImpl) handlePage() http.HandlerFunc {
	return func(w http.ResponseWriter, r *http.Request) {
		core.UpdateSpan(r)

		user := core.GetUser(r)
		if user == nil {
			core.DoRedirect(w, r, "/auth/signin")
			return
		}

		tags, err := h.s.getAll(r.Context(), user)
		if err != nil {
			h.r.RenderLayout(r, w, core.ErrorComp(err), user)
			return
		}

		comp := page(tags)
		h.r.RenderLayout(r, w, comp, user)
	}
}
func (h HandlerImpl) handleInlineEditSearch() http.HandlerFunc {
	return func(w http.ResponseWriter, r *http.Request) {
		core.UpdateSpan(r)

		user := core.GetUser(r)
		if user == nil {
			core.DoRedirect(w, r, "/auth/signin")
			return
		}

		search := r.FormValue("search")
		tags, err := h.s.find(r.Context(), user, search)
		if err != nil {
			core.HandleError(w, r, fmt.Errorf("Could not find tags: %w", core.ErrInternal))
		}

		comp := inlineEditSearch(tags)
		h.r.Render(r, w, comp)
	}
}

func (h HandlerImpl) handleNew() http.HandlerFunc {
	return func(w http.ResponseWriter, r *http.Request) {
		core.UpdateSpan(r)

		user := core.GetUser(r)
		if user == nil {
			core.DoRedirect(w, r, "/auth/signin")
			return
		}

		comp := editNew()
		h.r.RenderLayout(r, w, comp, user)
	}
}

func (h HandlerImpl) handleEdit() http.HandlerFunc {
	return func(w http.ResponseWriter, r *http.Request) {
		core.UpdateSpan(r)

		user := core.GetUser(r)
		if user == nil {
			core.DoRedirect(w, r, "/auth/signin")
			return
		}

		id, err := uuid.Parse(r.PathValue("id"))
		if err != nil {
			core.HandleError(w, r, fmt.Errorf("could not parse Id: %w", core.ErrBadRequest))
			return
		}

		tag, err := h.s.get(r.Context(), user, id)
		if err != nil {
			core.HandleError(w, r, fmt.Errorf("could not parse Id: %w", core.ErrBadRequest))
			return
		}

		comp := edit(*tag)
		h.r.RenderLayout(r, w, comp, user)
	}
}

func (h HandlerImpl) handlePost() http.HandlerFunc {
	return func(w http.ResponseWriter, r *http.Request) {
		core.UpdateSpan(r)

		user := core.GetUser(r)
		if user == nil {
			core.DoRedirect(w, r, "/auth/signin")
			return
		}

		var (
			id  uuid.UUID
			err error
		)

		idStr := r.PathValue("id")
		if idStr != "new" {
			id, err = uuid.Parse(idStr)
			if err != nil {
				core.HandleError(w, r, fmt.Errorf("could not parse Id: %w", core.ErrBadRequest))
				return
			}
		}

		if err != nil {
			core.HandleError(w, r, fmt.Errorf("could not parse value: %w", core.ErrBadRequest))
			return
		}

		input := Tag{
			Id:   id,
			Name: r.FormValue("name"),
		}

		if idStr == "new" {
			_, err = h.s.add(r.Context(), user, input)
			if err != nil {
				core.HandleError(w, r, err)
				return
			}
		} else {
			_, err = h.s.update(r.Context(), user, input)
			if err != nil {
				core.HandleError(w, r, err)
				return
			}
		}

		core.DoRedirect(w, r, "/tag")
	}
}

func (h HandlerImpl) handleDelete() http.HandlerFunc {
	return func(w http.ResponseWriter, r *http.Request) {
		core.UpdateSpan(r)

		user := core.GetUser(r)
		if user == nil {
			core.DoRedirect(w, r, "/auth/signin")
			return
		}

		idStr := r.PathValue("id")
		id, err := uuid.Parse(idStr)
		if err != nil {
			core.HandleError(w, r, fmt.Errorf("could not parse Id: %w", core.ErrBadRequest))
			return
		}

		err = h.s.delete(r.Context(), user, id)
		if err != nil {
			core.HandleError(w, r, err)
			return
		}

		core.DoRedirect(w, r, "/tag")
	}
}