package loads

import (
	"context"
	"git.siteworxpro.com/reloading-manager/backend/database"
	"git.siteworxpro.com/reloading-manager/backend/handlers"
	"git.siteworxpro.com/reloading-manager/backend/handlers/bullets"
	"git.siteworxpro.com/reloading-manager/backend/handlers/primers"
	"git.siteworxpro.com/reloading-manager/backend/models/loads"
	"github.com/labstack/echo/v4"
	"net/http"
)

type loadResponseResults struct {
	Id        string                 `json:"id"`
	Cartridge string                 `json:"cartridge"`
	Col       float32                `json:"col"`
	Powder    handlers.Powder        `json:"powder"`
	PowderGr  float32                `json:"powder_gr"`
	Primer    primers.PrimerResponse `json:"primer"`
	Bullet    bullets.BulletResponse `json:"bullet"`
}

type loadResponse struct {
	Total   int                   `json:"total"`
	Results []loadResponseResults `json:"results"`
}

type ResultChan[T any] struct {
	Result T
	Err    error
}

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

	cartridgeID, err := handlers.ParseUuid(c.FormValue("cartridge_id"))
	if err != nil {
		return handlers.BadRequest(c, "cartridge_id is not a valid UUID")
	}

	powderId, err := handlers.ParseUuid(c.FormValue("powder_id"))
	if err != nil {
		return handlers.BadRequest(c, "powder_id is not a valid UUID")
	}

	primerId, err := handlers.ParseUuid(c.FormValue("primer_id"))
	if err != nil {
		return handlers.BadRequest(c, "primer_id is not a valid UUID")
	}

	bulletId, err := handlers.ParseUuid(c.FormValue("bullet_id"))
	if err != nil {
		return handlers.BadRequest(c, "bullet_id is not a valid UUID")
	}

	file, err := handlers.ReadFile(c, "photo")
	if err != nil {
		return handlers.BadRequest(c, "photo is not valid")
	}

	meta := c.FormValue("meta")
	if meta == "" {
		meta = "{}"
	}

	powderGr := c.FormValue("powder_gr")
	if powderGr == "" {
		return handlers.BadRequest(c, "powder_gr is not valid")
	}

	powderGrFl, err := handlers.ParseFloat32(powderGr)
	if err != nil {
		return handlers.BadRequest(c, "powder_gr is not valid")
	}

	col := c.FormValue("col")
	if col == "" {
		return handlers.BadRequest(c, "col is not valid")
	}
	colFl, err := handlers.ParseFloat32(col)
	if err != nil {
		return handlers.BadRequest(c, "col is not valid")
	}

	uid, err := db.Loads.CreateLoad(context.Background(), loads.CreateLoadParams{
		CartridgeID: *cartridgeID,
		Col:         colFl,
		PowderID:    *powderId,
		PowderGr:    powderGrFl,
		PrimerID:    *primerId,
		BulletID:    *bulletId,
		Photo:       file,
		Meta:        []byte(meta),
	})

	if err != nil {
		return err
	}

	return c.JSON(http.StatusCreated, handlers.Response[string]{Payload: uid.String()})
}

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

	cTotal := make(chan ResultChan[int64])
	cResults := make(chan ResultChan[[]loadResponseResults])

	go func(c chan ResultChan[int64]) {
		db := database.GetNewDatabase()
		defer db.Db.Close(context.Background())

		total, err := db.Loads.TotalLoads(context.Background())

		if err != nil {
			c <- ResultChan[int64]{Err: err}
		} else {
			c <- ResultChan[int64]{Result: total}
		}

	}(cTotal)

	go func(ch chan ResultChan[[]loadResponseResults]) {

		rows, err := db.Loads.GetLoads(context.Background(), loads.GetLoadsParams{
			Limit:  handlers.ParseInt32WithDefault(c.QueryParam("limit"), 50),
			Offset: handlers.ParseInt32WithDefault(c.QueryParam("offset"), 0),

			OrderBy: "cartridge_name asc",

			SearchCartridge:          c.QueryParam("search_cartridge") != "",
			Cartridge:                c.QueryParam("search_cartridge"),
			SearchBullet:             c.QueryParam("search_bullet") != "",
			Bullet:                   c.QueryParam("search_bullet") + "%",
			SearchBulletManufacturer: c.QueryParam("search_bullet_manufacturer") != "",
			BulletManufacturer:       c.QueryParam("search_bullet_manufacturer") + "%",
			SearchPrimer:             c.QueryParam("search_primer") != "",
			Primer:                   c.QueryParam("search_primer") + "%",
			SearchPrimerManufacturer: c.QueryParam("search_primer_manufacturer") != "",
			PrimeManufacturer:        c.QueryParam("search_primer_manufacturer") + "%",
			SearchPowder:             c.QueryParam("search_powder") != "",
			Powder:                   c.QueryParam("search_powder") + "%",
			SearchPowderManufacturer: c.QueryParam("search_powder_manufacturer") != "",
			PowderManufacturer:       c.QueryParam("search_powder_manufacturer") + "%",

			SearchCartridgeID: c.QueryParam("search_cartridge_id") != "",
			CartridgeID:       *handlers.ParseUuidOrEmpty(c.QueryParam("search_cartridge_id")),
			SearchBulletID:    c.QueryParam("search_bullet_id") != "",
			BulletID:          *handlers.ParseUuidOrEmpty(c.QueryParam("search_bullet_id")),
			SearchPrimerID:    c.QueryParam("search_primer_id") != "",
			PrimerID:          *handlers.ParseUuidOrEmpty(c.QueryParam("search_primer_id")),
			SearchPowderID:    c.QueryParam("search_powder_id") != "",
			PowderID:          *handlers.ParseUuidOrEmpty(c.QueryParam("search_powder_id")),
		})
		if err != nil {
			ch <- ResultChan[[]loadResponseResults]{Err: err}

			return
		}

		results := make([]loadResponseResults, 0)
		for _, row := range rows {
			results = append(results, loadResponseResults{
				Id:        row.ID.String(),
				Cartridge: row.CartridgeName,
				Col:       row.Col,
				Powder: handlers.Powder{
					Id:   row.PowderID.String(),
					Name: row.PowderName,
					Meta: string(row.PowderMeta),
					Manufacturer: handlers.Manufacturer{
						Name: row.PowderManufacturerName,
						Url:  row.PowderManufacturerUrl.String,
					},
				},
				PowderGr: row.PowderGr,
				Primer: primers.PrimerResponse{
					ID:   row.PrimerID.String(),
					Name: row.PrimerName,
					Manufacturer: handlers.Manufacturer{
						Name: row.PrimerManufacturerName,
						Url:  row.PrimerManufacturerUrl.String,
					},
				},
				Bullet: bullets.BulletResponse{
					Id:       row.BulletID.String(),
					Name:     row.BulletName,
					Diameter: row.BulletDiameter,
					Weight:   row.BulletWeight,
					Manufacturer: handlers.Manufacturer{
						Name: row.BulletManufacturerName,
						Url:  row.BulletManufacturerUrl.String,
					},
				},
			})
		}

		ch <- ResultChan[[]loadResponseResults]{Result: results}
	}(cResults)

	total := <-cTotal
	if total.Err != nil {
		return total.Err
	}

	results := <-cResults
	if results.Err != nil {
		return results.Err
	}

	return c.JSON(http.StatusOK, handlers.Response[loadResponse]{Status: http.StatusText(http.StatusOK), Payload: loadResponse{Total: int(total.Result), Results: results.Result}})
}