package service

import (
	"cafe/config"
	"cafe/types"
	"fmt"
	"time"

	"gorm.io/gorm"
)

type (
	Order struct {
		ID          uint64    `gorm:"primaryKey" json:"id" validate:"optional"`
		TableID     uint64    `json:"table_id" validate:"required"`
		OrderItemID uint64    `json:"order_item_id" validate:"required"`
		OrderItem   OrderItem `json:"order_item" validate:"required"`
		UpdatedAt   int64     `json:"updated_at" validate:"optional"`
		IsServed    bool      `json:"is_served" default:"false" validate:"required"`
		Total       float32   `json:"total" validate:"required"`
		OrderCount  uint64    `json:"order_count" validate:"required"`
	}

	OrderItem struct {
		ID          uint64         `gorm:"primaryKey" json:"id" validate:"optional"`
		ItemType    types.ItemType `json:"item_type" validate:"required"`
		Description string         `json:"description" validate:"required"`
		Price       float32        `json:"price" validate:"required"`
	}

	GetOrderOptions struct {
		TableId uint64   `json:"table_id"`
		Grouped bool     `json:"grouped"`
		Filter  []string `json:"filter"`
	}
)

func updateTableUpdatedAt(tx *gorm.DB, o *Order) {
	var table Table
	tx.Where("id = ?", o.TableID).First(&table)
	table.UpdatedAt = time.Now().Unix()
	tx.Save(&table)
}

func (o *Order) AfterCreate(tx *gorm.DB) (err error) {
	updateTableUpdatedAt(tx, o)
	return
}

func (o *Order) AfterDelete(tx *gorm.DB) (err error) {
	updateTableUpdatedAt(tx, o)
	return
}

func DoesOrderItemExist(id string) (OrderItem, error) {
	var orderItem OrderItem
	result := config.Cafe.Database.ORM.Limit(1).Find(&orderItem, id)
	if result.RowsAffected == 0 {
		return orderItem, fmt.Errorf(types.CannotFind.String())
	}
	return orderItem, nil
}

func DoesOrderExist(id string) (Order, error) {
	var order Order
	result := config.Cafe.Database.ORM.Limit(1).Find(&order, id)
	if result.RowsAffected == 0 {
		return order, fmt.Errorf(types.CannotFind.String())
	}
	return order, nil
}

func GetAllActiveOrders() []Order {
	var orders []Order
	config.Cafe.Database.ORM.Model(&Order{}).Joins("OrderItem").Where("is_served = ?", 0).Order("updated_at").Find(&orders)
	return orders
}

func GetAllOrdersForTable(options GetOrderOptions) []Order {
	var orders []Order
	if options.Grouped {
		if len(options.Filter) == 0 {
			config.Cafe.Database.ORM.Model(&Order{}).Joins("OrderItem").Select("table_id, order_item_id, sum(price) as total, count(order_item_id) as order_count").Group("order_item_id").Where("table_id = ?", options.TableId).Order("item_type, description").Find(&orders)
		} else {
			config.Cafe.Database.ORM.Model(&Order{}).Find(&orders, options.Filter).Joins("OrderItem").Select("table_id, order_item_id, sum(price) as total, count(order_item_id) as order_count").Group("order_item_id").Where("table_id = ?", options.TableId).Order("item_type, description").Find(&orders)
		}
	} else {
		if len(options.Filter) == 0 {
			config.Cafe.Database.ORM.Model(&Order{}).Joins("OrderItem").Where("table_id = ?", options.TableId).Order("item_type, description").Find(&orders)
		} else {
			config.Cafe.Database.ORM.Model(&Order{}).Find(&orders, options.Filter).Where("table_id = ?", options.TableId).Find(&orders)
		}
	}
	return orders
}

func CreateOrder(order *Order) error {
	err := config.Cafe.Database.ORM.Create(order).Error
	if err != nil {
		return fmt.Errorf(types.CannotCreate.String())
	}
	config.Cafe.Database.ORM.Model(&Order{}).Joins("OrderItem").First(order)
	LiveCh <- WebSocketMsg{
		Type:    types.Create,
		Payload: []Order{*order},
	}
	return nil
}

func UpdateOrder(old *Order, new *Order) error {
	err := config.Cafe.Database.ORM.First(old).Updates(new).Error
	if err != nil {
		return fmt.Errorf(types.CannotUpdate.String())
	}
	if new.IsServed {
		LiveCh <- WebSocketMsg{
			Type:    types.Delete,
			Payload: []Order{*new},
		}
	}
	return nil
}

func DeleteOrder(tableId string, orderItemId string) error {
	var order Order
	err := config.Cafe.Database.ORM.Where("table_id = ? AND order_item_id = ?", tableId, orderItemId).Last(&order).Error
	if err != nil {
		return fmt.Errorf(types.CannotFind.String())
	}
	err = config.Cafe.Database.ORM.Delete(&order).Error
	if err != nil {
		return fmt.Errorf(types.CannotDelete.String())
	}
	LiveCh <- WebSocketMsg{
		Type:    types.Delete,
		Payload: []Order{order},
	}
	return nil
}

func GetOrderItemsForType(itemType string) []OrderItem {
	var orderItems []OrderItem
	config.Cafe.Database.ORM.Order("description").Where("item_type = ?", types.ParseItemType(itemType)).Find(&orderItems)
	return orderItems
}

func CreateOrderItem(oderItem *OrderItem) error {
	err := config.Cafe.Database.ORM.Create(oderItem).Error
	if err != nil {
		return fmt.Errorf(types.CannotCreate.String())
	}
	return nil
}

func UpdateOrderItem(old *OrderItem, new *OrderItem) error {
	err := config.Cafe.Database.ORM.First(old).Updates(new).Error
	if err != nil {
		return fmt.Errorf(types.CannotUpdate.String())
	}
	return nil
}

func DeleteOrderItem(oderItem *OrderItem) error {
	err := config.Cafe.Database.ORM.Delete(oderItem).Error
	if err != nil {
		return fmt.Errorf(types.CannotDelete.String())
	}
	return nil
}