import { defineStore } from 'pinia'
import { ref, computed } from 'vue'

// 订单状态枚举
export const ORDER_STATUS = {
  PENDING: 'pending',
  PROCESSING: 'processing', 
  SHIPPED: 'shipped',
  delivered: 'Shipped',
  CANCELLED: 'cancelled',
  REFUNDED: 'refunded'
}

// 订单状态标签
export const STATUS_LABELS = {
  [ORDER_STATUS.PENDING]: '待处理',
  [ORDER_STATUS.PROCESSING]: '处理中',
  [ORDER_STATUS.SHIPPED]: '已发货',
  [ORDER_STATUS.DELIVERED]: '已送达',
  [ORDER_STATUS.CANCELLED]: '已取消',
  [ORDER_STATUS.REFUNDED]: '已退款'
}

// 订单状态颜色
export const STATUS_COLORS = {
  [ORDER_STATUS.PENDING]: '#f59e0b',
  [ORDER_STATUS.PROCESSING]: '#3b82f6', 
  [ORDER_STATUS.SHIPPED]: '#8b5cf6',
  [ORDER_STATUS.DELIVERED]: '#10b981',
  [ORDER_STATUS.CANCELLED]: '#ef4444',
  [ORDER_STATUS.REFUNDED]: '#6b7280'
}

export const useOrderStore = defineStore('orders', () => {
  // 状态定义
  const orders = ref([])
  const currentOrder = ref(null)
  const loading = ref(false)
  const error = ref(null)
  
  // 筛选和搜索状态
  const filters = ref({
    status: null,
    search: '',
    sortBy: 'created_at',
    sortOrder: 'desc',
    dateRange: null
  })
  
  // 分页状态
  const pagination = ref({
    currentPage: 1,
    pageSize: 10,
    total: 0
  })

  // 计算属性
  const filteredOrders = computed(() => {
    let result = [...orders.value]
    
    // 状态筛选
    if (filters.value.status) {
      result = result.filter(order => order.status === filters.value.status)
    }
    
    // 搜索筛选
    if (filters.value.search) {
      const searchLower = filters.value.search.toLowerCase()
      result = result.filter(order => 
        order.orderId?.toLowerCase().includes(searchLower) ||
        order.customerName?.toLowerCase().includes(searchLower) ||
        order.customerEmail?.toLowerCase().includes(searchLower)
      )
    }
    
    // 日期范围筛选
    if (filters.value.dateRange?.start && filters.value.dateRange?.end) {
      const start = new Date(filters.value.dateRange.start)
      const end = new Date(filters.value.dateRange.end)
      result = result.filter(order => {
        const orderDate = new Date(order.created_at)
        return orderDate >= start && orderDate <= end
      })
    }
    
    // 排序
    result.sort((a, b) => {
      const { sortBy, sortOrder } = filters.value
      let aVal = a[sortBy]
      let bVal = b[sortBy]
      
      // 处理日期排序
      if (sortBy === 'created_at' || sortBy === 'updatedAt') {
        aVal = new Date(aVal).getTime()
        bVal = new Date(bVal).getTime()
      }
      
      // 处理字符串排序
      if (typeof aVal === 'string') {
        aVal = aVal.toLowerCase()
        bVal = bVal.toLowerCase()
      }
      
      if (sortOrder === 'asc') {
        return aVal > bVal ? 1 : -1
      } else {
        return aVal < bVal ? 1 : -1
      }
    })
    
    return result
  })

  // 分页后的订单列表
  const paginatedOrders = computed(() => {
    const { currentPage, pageSize } = pagination.value
    const start = (currentPage - 1) * pageSize
    const end = start + pageSize
    return filteredOrders.value.slice(start, end)
  })

  // 订单统计
  const orderStats = computed(() => {
    const total = orders.value.length
    const pending = orders.value.filter(o => o.status === ORDER_STATUS.PENDING).length
    const processing = orders.value.filter(o => o.status === ORDER_STATUS.PROCESSING).length
    const shipped = orders.value.filter(o => o.status === ORDER_STATUS.SHIPPED).length
    const delivered = orders.value.filter(o => o.status === ORDER_STATUS.DELIVERED).length
    const cancelled = orders.value.filter(o => o.status === ORDER_STATUS.CANCELLED).length
    const refunded = orders.value.filter(o => o.status === ORDER_STATUS.REFUNDED).length
    
    const totalRevenue = orders.value
      .filter(o => o.status !== ORDER_STATUS.CANCELLED)
      .reduce((sum, order) => sum + (order.total || 0), 0)
    
    return {
      total,
      pending,
      processing,
      shipped,
      delivered,
      cancelled,
      refunded,
      totalRevenue
    }
  })

  // 获取订单总数（用于分页）
  const totalOrders = computed(() => filteredOrders.value.length)

  // 方法定义
  
  // 设置订单数据
  const setOrders = (orderList) => {
    orders.value = orderList.map(order => ({
      ...order,
      created_at: order.created_at || new Date().toISOString(),
      updatedAt: order.updatedAt || new Date().toISOString()
    }))
    pagination.value.total = orders.value.length
  }

  // 添加订单
  const addOrder = (order) => {
    const newOrder = {
      ...order,
      id: Date.now().toString(),
      created_at: new Date().toISOString(),
      updatedAt: new Date().toISOString(),
      status: order.status || ORDER_STATUS.PENDING
    }
    orders.value.unshift(newOrder)
    pagination.value.total = orders.value.length
    return newOrder
  }

  // 更新订单
  const updateOrder = (orderId, updates) => {
    const index = orders.value.findIndex(order => order.id === orderId)
    if (index !== -1) {
      orders.value[index] = {
        ...orders.value[index],
        ...updates,
        updatedAt: new Date().toISOString()
      }
    }
    return orders.value[index]
  }

  // 删除订单
  const deleteOrder = (orderId) => {
    const index = orders.value.findIndex(order => order.id === orderId)
    if (index !== -1) {
      orders.value.splice(index, 1)
      pagination.value.total = orders.value.length
      return true
    }
    return false
  }

  // 获取单个订单
  const getOrder = (orderId) => {
    return orders.value.find(order => order.id === orderId)
  }

  // 设置当前订单
  const setCurrentOrder = (order) => {
    currentOrder.value = order
  }

  // 更新订单状态
  const updateOrderStatus = (orderId, newStatus) => {
    return updateOrder(orderId, { 
      status: newStatus,
      statusHistory: [
        ...(orders.value.find(o => o.id === orderId)?.statusHistory || []),
        {
          status: newStatus,
          timestamp: new Date().toISOString(),
          note: `状态更新为 ${STATUS_LABELS[newStatus]}`
        }
      ]
    })
  }

  // 更新筛选条件
  const updateFilters = (newFilters) => {
    filters.value = { ...filters.value, ...newFilters }
    pagination.value.currentPage = 1 // 重置到第一页
  }

  // 更新分页
  const updatePagination = (newPagination) => {
    pagination.value = { ...pagination.value, ...newPagination }
  }

  // 重置筛选
  const resetFilters = () => {
    filters.value = {
      status: null,
      search: '',
      sortBy: 'created_at',
      sortOrder: 'desc',
      dateRange: null
    }
    pagination.value.currentPage = 1
  }

  // 获取状态历史
  const getStatusHistory = (orderId) => {
    const order = getOrder(orderId)
    return order?.statusHistory || []
  }

  // 导出订单数据
  const exportOrders = (format = 'json') => {
    const data = filteredOrders.value
    
    if (format === 'csv') {
      // 转换为CSV格式
      const headers = ['订单ID', '客户姓名', '客户邮箱', '状态', '总金额', '创建时间', '更新时间']
      const csvRows = [
        headers.join(','),
        ...data.map(order => [
          order.orderId || '',
          order.customerName || '',
          order.customerEmail || '',
          STATUS_LABELS[order.status] || '',
          order.total || 0,
          order.created_at,
          order.updatedAt
        ].join(','))
      ]
      return csvRows.join('\n')
    }
    
    return JSON.stringify(data, null, 2)
  }

  // 初始化示例数据（用于测试）
  const initSampleData = () => {
    const sampleOrders = []
    setOrders(sampleOrders)
  }

  return {
    // 状态
    orders,
    currentOrder,
    loading,
    error,
    filters,
    pagination,
    
    // 计算属性
    filteredOrders,
    paginatedOrders,
    orderStats,
    totalOrders,
    
    // 方法
    setOrders,
    addOrder,
    updateOrder,
    deleteOrder,
    getOrder,
    setCurrentOrder,
    updateOrderStatus,
    updateFilters,
    updatePagination,
    resetFilters,
    getStatusHistory,
    exportOrders,
    initSampleData
  }
}, {
  persist: {
    key: 'orders',
    storage: localStorage,
    paths: ['filters', 'pagination']
  }
})