import { NextRequest, NextResponse } from 'next/server'
import { requireAdminToken } from '@/lib/server/admin-auth'

// Order types
interface OrderItem {
  productId: string
  productName: string
  price: number
  quantity: number
  priceId: string
}

interface Order {
  id: string
  customerId: string | null
  customerEmail: string
  items: OrderItem[]
  totalAmount: number
  currency: string
  status: 'pending' | 'paid' | 'fulfilled' | 'cancelled' | 'refunded'
  paymentIntentId: string | null
  stripeSessionId: string | null
  createdAt: string
  updatedAt: string
  shippingAddress?: {
    name: string
    address: string
    city: string
    state: string
    zipCode: string
    country: string
  }
}

// In-memory storage for demo purposes
// In a real application, you would use a database
let orders: Order[] = []

// Generate a simple ID for demo
function generateOrderId(): string {
  return 'ORD-' + Date.now() + '-' + Math.floor(Math.random() * 1000)
}

export async function GET(request: NextRequest) {
  const authError = requireAdminToken(request)
  if (authError) {
    return authError
  }

  try {
    const { searchParams } = new URL(request.url)
    const page = parseInt(searchParams.get('page') || '1')
    const limit = parseInt(searchParams.get('limit') || '10')
    const status = searchParams.get('status') || undefined
    const customerEmail = searchParams.get('customerEmail') || undefined

    // Filter orders
    let filteredOrders = [...orders]
    
    if (status) {
      filteredOrders = filteredOrders.filter(order => order.status === status)
    }
    
    if (customerEmail) {
      filteredOrders = filteredOrders.filter(order => 
        order.customerEmail.toLowerCase().includes(customerEmail.toLowerCase())
      )
    }

    // Sort by creation date (newest first)
    filteredOrders.sort((a, b) => new Date(b.createdAt).getTime() - new Date(a.createdAt).getTime())

    // Pagination
    const startIndex = (page - 1) * limit
    const endIndex = startIndex + limit
    const paginatedOrders = filteredOrders.slice(startIndex, endIndex)

    return NextResponse.json({
      orders: paginatedOrders,
      pagination: {
        page,
        limit,
        total: filteredOrders.length,
        totalPages: Math.ceil(filteredOrders.length / limit)
      }
    })
  } catch (error) {
    console.error('Error fetching orders:', error)
    return NextResponse.json(
      { error: 'Failed to fetch orders' },
      { status: 500 }
    )
  }
}

export async function POST(request: NextRequest) {
  const authError = requireAdminToken(request)
  if (authError) {
    return authError
  }

  try {
    const body = await request.json()
    const { items, customerEmail, paymentIntentId, stripeSessionId, shippingAddress } = body

    // Validate required fields
    if (!items || !Array.isArray(items) || items.length === 0) {
      return NextResponse.json(
        { error: 'Items are required' },
        { status: 400 }
      )
    }

    if (!customerEmail) {
      return NextResponse.json(
        { error: 'Customer email is required' },
        { status: 400 }
      )
    }

    if (!paymentIntentId) {
      return NextResponse.json(
        { error: 'Payment intent ID is required' },
        { status: 400 }
      )
    }

    if (!stripeSessionId) {
      return NextResponse.json(
        { error: 'Stripe session ID is required' },
        { status: 400 }
      )
    }

    // Calculate total
    const totalAmount = items.reduce((total: number, item: OrderItem) => {
      return total + (item.price * item.quantity)
    }, 0)

    // Create order
    const newOrder: Order = {
      id: generateOrderId(),
      customerId: null, // TODO: Implement customer accounts
      customerEmail,
      items,
      totalAmount,
      currency: 'usd',
      status: 'paid', // Assume payment was successful since webhook was triggered
      paymentIntentId,
      stripeSessionId,
      createdAt: new Date().toISOString(),
      updatedAt: new Date().toISOString(),
      shippingAddress
    }

    orders.unshift(newOrder) // Add to beginning of array

    return NextResponse.json(newOrder, { status: 201 })
  } catch (error) {
    console.error('Error creating order:', error)
    return NextResponse.json(
      { error: 'Failed to create order' },
      { status: 500 }
    )
  }
}