package response

import (
	"enaklo-pos-be/internal/entity"
	"time"
)

type OrderInquiryResponse struct {
	ID                  string              `json:"id"`
	Status              string              `json:"status"`
	Amount              float64             `json:"amount"`
	Tax                 float64             `json:"tax"`
	Total               float64             `json:"total"`
	CustomerID          int64               `json:"customer_id"`
	PaymentType         string              `json:"payment_type"`
	CustomerName        string              `json:"customer_name"`
	CustomerPhoneNumber string              `json:"customer_phone_number"`
	CustomerEmail       string              `json:"customer_email"`
	ExpiresAt           time.Time           `json:"expires_at"`
	CreatedAt           time.Time           `json:"created_at"`
	Items               []OrderItemResponse `json:"items"`
	Token               string              `json:"token"`
}

type OrderItemResponse struct {
	OrderItemID int64   `json:"order_item_id"`
	ProductID   int64   `json:"product_id"`
	ProductName string  `json:"product_name"`
	Price       float64 `json:"price"`
	Quantity    int     `json:"quantity"`
	Subtotal    float64 `json:"subtotal"`
	Notes       string  `json:"notes"`
	Status      string  `json:"status"`
}

func mapToOrderItemResponses(items []entity.OrderItem) []OrderItemResponse {
	result := make([]OrderItemResponse, 0, len(items))
	for _, item := range items {
		productName := ""
		if item.Product != nil {
			productName = item.Product.Name
		}

		result = append(result, OrderItemResponse{
			ProductID:   item.ItemID,
			ProductName: productName,
			Price:       item.Price,
			Quantity:    item.Quantity,
			Subtotal:    item.Price * float64(item.Quantity),
		})
	}
	return result
}

func MapToInquiryResponse(result *entity.OrderInquiryResponse) OrderInquiryResponse {
	resp := OrderInquiryResponse{
		ID:                  result.OrderInquiry.ID,
		Status:              result.OrderInquiry.Status,
		Amount:              result.OrderInquiry.Amount,
		Tax:                 result.OrderInquiry.Tax,
		Total:               result.OrderInquiry.Total,
		CustomerID:          result.OrderInquiry.CustomerID,
		PaymentType:         result.OrderInquiry.PaymentType,
		ExpiresAt:           result.OrderInquiry.ExpiresAt,
		CreatedAt:           result.OrderInquiry.CreatedAt,
		Items:               mapToOrderItemResponses(result.OrderInquiry.OrderItems),
		Token:               result.Token,
		CustomerName:        result.OrderInquiry.CustomerName,
		CustomerEmail:       result.OrderInquiry.CustomerEmail,
		CustomerPhoneNumber: result.OrderInquiry.CustomerPhoneNumber,
	}

	return resp
}

type OrderResponse struct {
	ID           int64               `json:"id"`
	Status       string              `json:"status"`
	Amount       float64             `json:"amount"`
	Tax          float64             `json:"tax"`
	Total        float64             `json:"total"`
	CustomerName string              `json:"customer_name,omitempty"`
	PaymentType  string              `json:"payment_type"`
	Source       string              `json:"source"`
	CreatedAt    time.Time           `json:"created_at"`
	UpdatedAt    *time.Time          `json:"updated_at,omitempty"`
	Items        []OrderItemResponse `json:"items"`
	TableNumber  string              `json:"table_number"`
	OrderType    string              `json:"order_type"`
}

func MapToOrderResponse(result *entity.OrderResponse) OrderResponse {
	resp := OrderResponse{
		ID:           result.Order.ID,
		Status:       result.Order.Status,
		Amount:       result.Order.Amount,
		Tax:          result.Order.Tax,
		Total:        result.Order.Total,
		PaymentType:  formatPayment(result.Order.PaymentType, result.Order.PaymentProvider),
		CreatedAt:    result.Order.CreatedAt,
		Items:        MapToOrderItemResponses(result.Order.OrderItems),
		CustomerName: result.Order.CustomerName,
		TableNumber:  result.Order.TableNumber,
		OrderType:    result.Order.OrderType,
	}

	return resp
}

func MapToOrderItemResponses(items []entity.OrderItem) []OrderItemResponse {
	result := make([]OrderItemResponse, 0, len(items))
	for _, item := range items {
		result = append(result, OrderItemResponse{
			OrderItemID: item.ID,
			ProductID:   item.ItemID,
			ProductName: item.ItemName,
			Price:       item.Price,
			Quantity:    item.Quantity,
			Subtotal:    item.Price * float64(item.Quantity),
			Notes:       item.Notes,
			Status:      item.Status,
		})
	}
	return result
}

func formatPayment(payment, provider string) string {
	if payment == "CASH" {
		return payment
	}

	return payment + " " + provider
}