package entity

import (
	"furtuna-be/internal/constants/order"
	"time"
)

type Order struct {
	ID            int64
	BranchID      int64
	BranchName    string
	Status        order.OrderStatus
	Amount        float64
	CustomerName  string `gorm:"column:customer_name" json:"customer_name"`
	CustomerPhone string `gorm:"column:customer_phone" json:"customer_phone"`
	Pax           int    `gorm:"column:pax" json:"pax"`
	CreatedAt     time.Time
	UpdatedAt     time.Time
	CreatedBy     int64
	UpdatedBy     int64
	Transaction   Transaction
	OrderItem     []OrderItem
}

type OrderSearch struct {
	Search       string
	StatusActive order.OrderSearchStatus
	Status       order.OrderStatus
	BranchID     int64
	Limit        int
	Offset       int
}

type OrderTotalRevenueSearch struct {
	Year      int
	Month     int
	BranchID  int64
	DateStart *time.Time
	DateEnd   *time.Time
}

type OrderYearlyRevenueList []OrderYearlyRevenue
type OrderYearlyRevenue struct {
	ItemType string  `gorm:"column:item_type"`
	Month    int     `gorm:"column:month_number"`
	Amount   float64 `gorm:"column:total_amount"`
}

type OrderBranchRevenueSearch struct {
	DateStart *time.Time
	DateEnd   *time.Time
}

type OrderBranchRevenueList []OrderBranchRevenue
type OrderBranchRevenue struct {
	BranchID         string  `gorm:"column:branch_id"`
	BranchName       string  `gorm:"column:name"`
	BranchLocation   string  `gorm:"column:location"`
	TotalTransaction int     `gorm:"column:total_trans"`
	TotalAmount      float64 `gorm:"column:total_amount"`
}

type OrderList []*OrderDB

type OrderDB struct {
	Order
}

func (b *Order) ToOrderDB() *OrderDB {
	var amount float64
	for _, i := range b.OrderItem {
		amount = amount + (i.Price * float64(i.Qty))
	}
	b.Amount = amount
	b.Transaction.Amount = amount

	return &OrderDB{
		Order: *b,
	}
}

func (OrderDB) TableName() string {
	return "orders"
}

func (e *OrderDB) ToOrder() *Order {
	return &Order{
		ID:            e.ID,
		Status:        e.Status,
		BranchID:      e.BranchID,
		BranchName:    e.BranchName,
		Amount:        e.Amount,
		CustomerName:  e.CustomerName,
		CustomerPhone: e.CustomerPhone,
		Pax:           e.Pax,
		Transaction:   e.Transaction,
		OrderItem:     e.OrderItem,
		CreatedAt:     e.CreatedAt,
		UpdatedAt:     e.UpdatedAt,
		CreatedBy:     e.CreatedBy,
		UpdatedBy:     e.UpdatedBy,
	}
}

func (b *OrderList) ToOrderList() []*Order {
	var Orders []*Order
	for _, order := range *b {
		Orders = append(Orders, order.ToOrder())
	}
	return Orders
}

func (o *OrderDB) ToUpdatedOrder(updatedby int64, req Order) {
	o.UpdatedBy = updatedby

	if req.Amount > 0 {
		o.Amount = req.Amount
	}

	if req.Status != "" {
		o.Status = req.Status
	}
}

type OrderItem struct {
	OrderItemID int64
	OrderID     int64
	ItemID      int64
	ItemType    order.ItemType
	ItemName    string
	Price       float64
	Qty         int64
	CreatedAt   time.Time
	UpdatedAt   time.Time
	CreatedBy   int64
	UpdatedBy   int64
}

type OrderItemDB struct {
	OrderItem
}

func (b *OrderItem) ToOrderItemDB() *OrderItemDB {
	return &OrderItemDB{
		OrderItem: *b,
	}
}

func (OrderItemDB) TableName() string {
	return "order_items"
}

func (e *OrderItemDB) ToOrderItem() *OrderItem {
	return &OrderItem{
		OrderItemID: e.OrderItemID,
		OrderID:     e.OrderID,
		ItemID:      e.ItemID,
		ItemType:    e.ItemType,
		Price:       e.Price,
		Qty:         e.Qty,
		CreatedAt:   e.CreatedAt,
		UpdatedAt:   e.UpdatedAt,
		CreatedBy:   e.CreatedBy,
		UpdatedBy:   e.UpdatedBy,
	}
}