package routers

import (
	"encoding/json"
	"net/http"
	"recipe-manager/data"
	"recipe-manager/models"
	"recipe-manager/services/sheet"
	"sort"
	"strconv"
	"strings"

	"github.com/go-chi/chi/v5"
)

type RecipeRouter struct {
	data         *data.Data
	sheetService sheet.SheetService
}

func NewRecipeRouter(data *data.Data, sheetService sheet.SheetService) *RecipeRouter {
	return &RecipeRouter{
		data:         data,
		sheetService: sheetService,
	}
}

func (rr *RecipeRouter) Route(r chi.Router) {
	r.Route("/recipes", func(r chi.Router) {
		r.Get("/", func(w http.ResponseWriter, r *http.Request) {
			w.Header().Add("Content-Type", "application/json")
			var take, offset uint64 = 10, 0
			if newOffset, err := strconv.ParseUint(r.URL.Query().Get("offset"), 10, 64); err == nil {
				offset = newOffset
			}

			if newTake, err := strconv.ParseUint(r.URL.Query().Get("take"), 10, 64); err == nil {
				take = newTake
			}

			version := r.URL.Query().Get("version")

			recipe := rr.data.GetRecipe(version)
			searchQuery := r.URL.Query().Get("search")

			if searchQuery != "" {
				recipe.Recipe01 = []models.Recipe01{}
				for _, v := range rr.data.GetRecipe01() {
					if strings.Contains(strings.ToLower(v.ProductCode), strings.ToLower(searchQuery)) ||
						strings.Contains(strings.ToLower(v.Name), strings.ToLower(searchQuery)) ||
						strings.Contains(strings.ToLower(v.OtherName), strings.ToLower(searchQuery)) {
						recipe.Recipe01 = append(recipe.Recipe01, v)
					}
				}
			}

			isHasMore := len(recipe.Recipe01) >= int(take+offset)
			if isHasMore {
				recipe.Recipe01 = recipe.Recipe01[offset : take+offset]
				sort.Slice(recipe.Recipe01, func(i, j int) bool {
					return recipe.Recipe01[i].ID < recipe.Recipe01[j].ID
				})
			} else if len(recipe.Recipe01) > int(offset) {
				recipe.Recipe01 = recipe.Recipe01[offset:]
			} else {
				recipe.Recipe01 = []models.Recipe01{}
			}

			json.NewEncoder(w).Encode(map[string]interface{}{
				"fileName": rr.data.CurrentVersion,
				"recipes":  recipe,
				"hasMore":  isHasMore,
			})
		})

		r.Get("/{id}", func(w http.ResponseWriter, r *http.Request) {
			w.Header().Add("Content-Type", "application/json")
			id, err := strconv.ParseUint(chi.URLParam(r, "id"), 10, 64)
			if err != nil {
				http.Error(w, "Invalid ID", http.StatusBadRequest)
				return
			}

			recipe := rr.data.GetRecipe01()
			for _, v := range recipe {
				if uint64(v.ID) == id {
					json.NewEncoder(w).Encode(v)
					return
				}
			}

			http.Error(w, "Recipe not found", http.StatusNotFound)
		})

		r.Get("/{version}/json", func(w http.ResponseWriter, r *http.Request) {
			version := chi.URLParam(r, "version")

			w.Header().Add("Content-Type", "application/json")
			json.NewEncoder(w).Encode(rr.data.GetRecipe(version))
		})

		r.Get("/versions", func(w http.ResponseWriter, r *http.Request) {
			json.NewEncoder(w).Encode(rr.data.AllVersions)
		})

		r.Get("/test/sheet", func(w http.ResponseWriter, r *http.Request) {
			result := rr.sheetService.GetSheet(r.Context(), "1rSUKcc5POR1KeZFGoeAZIoVoI7LPGztBhPw5Z_ConDE")
			json.NewEncoder(w).Encode(result)
		})
	})
}