package handlers

import (
	database "app/database"
	"app/models"
	"app/repositories"
	"net/http"
	"strconv"

	"github.com/labstack/echo/v4"
)

// Create(o *models.Order) error
// GetOrders(id uint) ([]models.Order, error)
// GetOrdersByDate(start time.Time, end time.Time) ([]models.Order, error)
// Delete(id uint) error

type Status string

const (
	StatusPending   Status = "pending"
	StatusPurchased Status = "purchased"
	StatusRejected  Status = "rejected"
)

func initOrder() *repositories.Orders_repository {
	db := database.Db()
	orderRepository := new(repositories.Orders_repository)
	orderRepository.DB = &db

	return orderRepository
}

func getTotalPrice(items []models.Cart_items) uint64 {
	var totalPrice uint64
	totalPrice = 0
	for i := 0; i < len(items); i++ {
		totalPrice += items[i].Price
	}

	return totalPrice
}

func CreateOrder(c echo.Context, cart models.Carts, TransportationFee uint64) error {
	db := database.Db()
	order := new(models.Order)
	var order_products []models.Order_products
	itemsRepository := new(repositories.Cart_items_repository)
	itemsRepository.DB = &db
	// get cart_items related to this user
	items, err := itemsRepository.GetItems(cart.Cart_id, string(StatusPurchased))
	if err != nil {
		return err
	}
	orderRepository := initOrder()
	order.User_id = cart.User_id
	// calculate prices
	order.ProductsTotalPrice = getTotalPrice(items)
	tax := float64(getTotalPrice(items)) * 0.09
	order.Tax = uint64(tax)
	order.TotalPrice = uint64(tax) + TransportationFee + getTotalPrice(items)
	err = orderRepository.Create(order)
	if err != nil {
		panic(err)
	}

	order_productsRepository := new(repositories.Order_Product_repository)
	order_productsRepository.DB = &db

	productRepository := new(repositories.Product_repository)
	productRepository.DB = &db

	for i := 0; i < len(items); i++ {
		order_products[i].Order_id = order.Order_id
		order_products[i].Product_id = items[i].Product_id
		order_products[i].Quantity_ordered = items[i].Quantity
		order_products[i].Price = items[i].Price
		productQuantity, err := productRepository.GetQuantity(items[i].Product_id)
		if err != nil {
			return err
		}
		err = productRepository.UpdateQuantity(productQuantity-items[i].Quantity, items[i].Product_id)
		if err != nil {
			return err
		}
		err = order_productsRepository.Create(&order_products[i])
		if err != nil {
			return err
		}
	}

	for i := 0; i < len(items); i++ {
		itemsRepository.Remove(items[i].Cart_item_id)
	}

	return c.JSON(http.StatusCreated, order)
}

func GetUserOrders(c echo.Context) error {
	id, err := strconv.Atoi(c.Param("id"))
	if err != nil {
		panic(err)
	}

	orderRepository := initOrder()

	orders, err := orderRepository.GetOrders(uint(id))
	if err != nil {
		panic(err)
	}

	return c.JSON(http.StatusAccepted, orders)
}

func GetOrdersByDate(c echo.Context) error {

	return c.String(http.StatusAccepted, "not ready")
}

func DeleteOrder(c echo.Context) error {
	id, err := strconv.Atoi(c.Param("id"))
	if err != nil {
		panic(err)
	}

	orderRepository := initOrder()

	err = orderRepository.Delete(uint(id))
	if err != nil {
		panic(err)
	}

	return c.String(http.StatusAccepted, "removed")
}