package productsmodule

import (
	productdto "api/application/products/dto"
	"api/libs/logger"
	"api/libs/postgres"

	"api/models/api"
	"api/models/products"
	"context"

	"github.com/gofiber/fiber/v2"
	"github.com/jackc/pgx/v5"
)

type ProductsService interface {
	CreateProduct(userId string, data *productdto.ProductDto) (*api.Response, int, error)
	UpdateProduct(userId string, data *productdto.ProductDto) (*api.Response, int, error)
	VerifyCode(data *productdto.ValidateCodeDto) (*api.Response, int, error)
	GetProducts() (*api.Response, int, error)
	DeleteProduct(data *productdto.DeleteProductDto) (*api.Response, int, error)
}

type productsService struct {
	productsRepository *products.Queries
	ctx                context.Context
}

func newService() ProductsService {
	return &productsService{
		productsRepository: products.New(postgres.Pool),
		ctx:                context.Background(),
	}
}

func (p *productsService) CreateProduct(userId string, data *productdto.ProductDto) (*api.Response, int, error) {

	estoqueDisponivel := data.EstoqueTotal - data.EstoqueCorte

	newProduct, err := p.productsRepository.CreateProduct(p.ctx, userId, products.CreateProductParams{
		Nome:              data.Nome,
		Codigo:            data.Codigo,
		EstoqueTotal:      data.EstoqueTotal,
		EstoqueCorte:      data.EstoqueCorte,
		EstoqueDisponivel: estoqueDisponivel,
		PrecoDe:           data.PrecoDe,
		PrecoPor:          data.PrecoPor,
	})
	if err != nil {
		logger.Production.Info(err.Error())
		return &api.Response{Error: true, ErrorMessage: err.Error(), Payload: "error insert product"}, fiber.StatusInternalServerError, err
	}

	return &api.Response{Error: false, Payload: newProduct}, fiber.StatusOK, nil
}

func (p *productsService) VerifyCode(data *productdto.ValidateCodeDto) (*api.Response, int, error) {

	_, err := p.productsRepository.GetProduct(p.ctx, data.Codigo)
	if err != nil {
		if err == pgx.ErrNoRows {
			return &api.Response{Error: false, Payload: false}, fiber.StatusOK, nil
		}
		logger.Production.Info(err.Error())
		return &api.Response{Error: true, ErrorMessage: err.Error(), Payload: "error verify code product"}, fiber.StatusInternalServerError, err
	}

	return &api.Response{Error: false, Payload: true}, fiber.StatusOK, nil
}

func (p *productsService) UpdateProduct(userId string, data *productdto.ProductDto) (*api.Response, int, error) {

	estoqueDisponivel := data.EstoqueTotal - data.EstoqueCorte

	err := p.productsRepository.UpdateProduct(p.ctx, userId, products.UpdateProductParams{
		Nome:              data.Nome,
		Codigo:            data.Codigo,
		EstoqueTotal:      data.EstoqueTotal,
		EstoqueCorte:      data.EstoqueCorte,
		EstoqueDisponivel: estoqueDisponivel,
		PrecoDe:           data.PrecoDe,
		PrecoPor:          data.PrecoPor,
	})
	if err != nil {
		logger.Production.Info(err.Error())
		return &api.Response{Error: true, ErrorMessage: err.Error(), Payload: "error update product"}, fiber.StatusInternalServerError, err
	}

	return &api.Response{Error: false, Payload: nil}, fiber.StatusOK, nil
}

func (p *productsService) GetProducts() (*api.Response, int, error) {

	products, err := p.productsRepository.ListProducts(p.ctx)
	if err != nil {
		logger.Production.Info(err.Error())
		return &api.Response{Error: true, ErrorMessage: err.Error(), Payload: "error get products"}, fiber.StatusInternalServerError, err
	}

	return &api.Response{Error: false, Payload: products}, fiber.StatusOK, nil
}

func (p *productsService) DeleteProduct(data *productdto.DeleteProductDto) (*api.Response, int, error) {

	err := p.productsRepository.DeleteProduct(p.ctx, data.Codigo)
	if err != nil {
		logger.Production.Info(err.Error())
		return &api.Response{Error: true, ErrorMessage: err.Error(), Payload: "error delete product"}, fiber.StatusInternalServerError, err
	}

	return &api.Response{Error: false, Payload: nil}, fiber.StatusOK, nil
}