package primers

import (
	"context"
	"encoding/json"
	"fmt"
	"git.siteworxpro.com/reloading-manager/backend/database"
	"git.siteworxpro.com/reloading-manager/backend/handlers"
	"git.siteworxpro.com/reloading-manager/backend/models/primers"
	"github.com/google/uuid"
	"github.com/labstack/echo/v4"
	"net/http"
)

type PrimerResponse struct {
	ID           string                `json:"id"`
	Name         string                `json:"name"`
	Manufacturer handlers.Manufacturer `json:"manufacturer"`
}

func Delete(c echo.Context) error {
	db := c.(*database.CustomContext).Db
	defer func() {
		_ = db.Db.Close(context.Background())
	}()

	id := c.Param("id")
	uid, err := handlers.ParseUuid(id)
	if err != nil {
		return handlers.BadRequest(c, "Invalid UUID.")
	}

	err = db.Primer.DeletePrimer(context.Background(), *uid)
	if err != nil {
		return err
	}

	return c.JSON(http.StatusNoContent, handlers.Response[string]{})
}

func Post(c echo.Context) error {
	db := c.(*database.CustomContext).Db
	defer func() {
		_ = db.Db.Close(context.Background())
	}()

	if c.Param("id") != "" {
		id := c.Param("id")
		uid, err := handlers.ParseUuidOrBadRequest(c, id)
		if err != nil || uid == nil {
			return echo.NewHTTPError(http.StatusBadRequest, "Invalid UUID.")
		}

		p, err := db.Primer.GetPrimerById(context.Background(), *uid)
		if err != nil {
			return handlers.NotFound(c, "Primer not found.")
		}

		if c.FormValue("name") != "" {
			p.Name = c.FormValue("name")
		}

		if c.FormValue("manufacturer_id") != "" {
			mid, err := handlers.ParseUuidOrBadRequest(c, c.FormValue("manufacturer_id"))
			if err != nil || mid == nil {
				return echo.NewHTTPError(http.StatusBadRequest, "Invalid Manufacturer ID.")
			}

			p.ManufacturerID = *mid
		}

		if c.FormValue("meta") != "" {
			p.Meta = json.RawMessage(c.Param("meta"))
		}

		file, _ := c.FormFile("photo")
		if file != nil {
			photo, err := handlers.ReadFile(c, "photo")
			if err != nil {
				return err
			}
			p.Photo = photo
		}

		err = db.Primer.UpdatePrimer(context.Background(), primers.UpdatePrimerParams{
			ID:             p.ID,
			Name:           p.Name,
			ManufacturerID: p.ManufacturerID,
			Meta:           p.Meta,
			Photo:          p.Photo,
		})

		if err != nil {
			return err
		}

		return c.JSON(http.StatusOK, handlers.Response[string]{Payload: p.ID.String(), Status: http.StatusText(http.StatusOK)})
	}

	buf, err := handlers.ReadFile(c, "photo")
	if err != nil {
		return err
	}

	name := c.FormValue("name")
	manufacturerId := c.FormValue("manufacturer_id")
	metaString := c.FormValue("meta")

	if name == "" {
		return handlers.BadRequest(c, "Name is required.")
	}

	if manufacturerId == "" {
		return handlers.BadRequest(c, "Manufacturer ID is required.")
	}

	if metaString == "" {
		metaString = "{}"
	}

	meta := []byte(metaString)

	newUuid := uuid.New().String()
	uid, _ := handlers.ParseUuid(newUuid)
	mid, err := handlers.ParseUuidOrBadRequest(c, manufacturerId)
	if err != nil || mid == nil {
		return echo.NewHTTPError(http.StatusBadRequest, "Invalid Manufacturer ID.")
	}

	err = db.Primer.InsertPrimer(context.Background(), primers.InsertPrimerParams{
		ID:             *uid,
		Name:           name,
		ManufacturerID: *mid,
		Meta:           meta,
		Photo:          buf,
	})

	if err != nil {
		return err
	}

	return c.JSON(http.StatusCreated, handlers.Response[struct {
		Id string `json:"id"`
	}]{
		Status: http.StatusText(http.StatusCreated),
		Payload: struct {
			Id string `json:"id"`
		}{Id: newUuid},
	})
}

func Photo(c echo.Context) error {
	db := c.(*database.CustomContext).Db
	defer func() {
		_ = db.Db.Close(context.Background())
	}()

	id := c.Param("id")
	uid, err := handlers.ParseUuidOrBadRequest(c, id)
	if err != nil || uid == nil {
		return echo.NewHTTPError(http.StatusBadRequest, "Invalid UUID.")
	}

	byId, err := db.Primer.GetPrimerById(context.Background(), *uid)
	if err != nil {
		return echo.NewHTTPError(http.StatusNotFound, "Not found")
	}

	mime := http.DetectContentType(byId.Photo)

	c.Response().Header().Set("Content-Type", mime)
	c.Response().Header().Set("Cache-Control", "no-cache, no-store, must-revalidate")
	c.Response().Header().Set("Pragma", "no-cache")
	c.Response().Header().Set("Expires", "0")

	_, err = c.Response().Write(byId.Photo)

	return err
}

func Get(c echo.Context) error {
	db := c.(*database.CustomContext).Db
	defer func() {
		_ = db.Db.Close(context.Background())
	}()

	if c.Param("id") != "" {
		id := c.Param("id")
		uid, err := handlers.ParseUuidOrBadRequest(c, id)
		if err != nil || uid == nil {
			return echo.NewHTTPError(http.StatusBadRequest, "Invalid UUID.")
		}

		row, err := db.Primer.GetPrimerById(context.Background(), *uid)
		if err != nil {
			return fmt.Errorf("primer not found: %v", err)
		}

		return c.JSON(http.StatusOK, handlers.Response[PrimerResponse]{
			Status: http.StatusText(http.StatusOK),
			Payload: PrimerResponse{
				ID:   row.ID.String(),
				Name: row.Name,
				Manufacturer: handlers.Manufacturer{
					Id:   row.ManufacturerID.String(),
					Name: row.ManufacturerName,
					Url:  row.ManufacturerUrl.String,
				},
			},
		})
	}

	rows, err := db.Primer.GetPrimers(context.Background())
	if err != nil {
		return err
	}

	response := handlers.Response[[]PrimerResponse]{
		Status:  "OK",
		Payload: make([]PrimerResponse, 0),
	}

	for _, row := range rows {
		response.Payload = append(response.Payload, PrimerResponse{
			ID:   row.ID.String(),
			Name: row.Name,
			Manufacturer: handlers.Manufacturer{
				Id:   row.ManufacturerID.String(),
				Name: row.ManufacturerName,
				Url:  row.ManufacturerUrl.String,
			},
		})
	}

	return c.JSON(http.StatusOK, response)
}