import { create } from "zustand"
import { generateId } from "@/lib/id"
import { mockOrders } from "@/lib/mock"
import type { Order, OrderStatus, PlayerService } from "@/lib/types"

interface CreateOrderInput {
  consumerId: string
  consumerName: string
  playerId: string
  playerName: string
  shopId?: string
  shopName?: string
  service: PlayerService
  totalPrice: number
  note?: string
  status?: OrderStatus
}

interface OrderState {
  orders: Order[]
  createOrder: (input: CreateOrderInput) => Order
  updateOrderStatus: (orderId: string, status: OrderStatus) => void
}

export const useOrderStore = create<OrderState>((set) => ({
  orders: mockOrders,
  createOrder: (input) => {
    const order: Order = {
      id: generateId("ord"),
      consumerId: input.consumerId,
      consumerName: input.consumerName,
      playerId: input.playerId,
      playerName: input.playerName,
      shopId: input.shopId,
      shopName: input.shopName,
      service: input.service,
      status: input.status ?? "pending_payment",
      totalPrice: input.totalPrice,
      note: input.note?.trim() ? input.note.trim() : undefined,
      createdAt: new Date().toISOString(),
    }

    set((state) => ({
      orders: [order, ...state.orders],
    }))

    return order
  },
  updateOrderStatus: (orderId, status) =>
    set((state) => ({
      orders: state.orders.map((order) => {
        if (order.id !== orderId) return order

        const now = new Date().toISOString()

        switch (status) {
          case "in_progress":
            return {
              ...order,
              status,
              acceptedAt: order.acceptedAt ?? now,
            }
          case "pending_review":
            return {
              ...order,
              status,
              closedAt: order.closedAt ?? now,
            }
          case "completed":
            return {
              ...order,
              status,
              closedAt: order.closedAt ?? now,
              completedAt: order.completedAt ?? now,
            }
          default:
            return {
              ...order,
              status,
            }
        }
      }),
    })),
}))