'use client'

import React, { createContext, useContext, useState, useEffect, ReactNode } from 'react'

interface BookingData {
  selectedDates: Date[]
  placementType: string
  totalCost: number
  placementDetails: {
    name: string
    price: number
    dimensions: string
  }
  createdAt: number
}

interface BookingContextType {
  bookingData: BookingData | null
  setBookingData: (data: Omit<BookingData, 'createdAt'>) => void
  clearBookingData: () => void
  updateDates: (dates: Date[]) => void
  isBookingValid: () => boolean
  isDatesExpired: () => boolean
  recalculateCost: () => void
}

const BookingContext = createContext<BookingContextType | undefined>(undefined)

const STORAGE_KEY = 'ad_booking_data'
const EXPIRY_HOURS = 1

const placementTypeDetails: Record<string, { name: string; price: number; dimensions: string }> = {
  'top-banner': { name: 'Premium Sponsored', price: 11, dimensions: '1200x450px' },
  'right-side': { name: 'Featured Ad', price: 5, dimensions: '320x600px' },
  'left-side': { name: 'Sponsored Ad', price: 7, dimensions: '320x600px' }
}

export function BookingProvider({ children }: { children: ReactNode }) {
  const [bookingData, setBookingDataState] = useState<BookingData | null>(null)

  // Load from sessionStorage on mount
  useEffect(() => {
    try {
      const stored = sessionStorage.getItem(STORAGE_KEY)
      if (stored) {
        const parsed = JSON.parse(stored) as BookingData
        
        // Convert date strings back to Date objects
        parsed.selectedDates = parsed.selectedDates.map(d => new Date(d))
        
        // Check if expired
        const hoursSinceCreation = (Date.now() - parsed.createdAt) / (1000 * 60 * 60)
        if (hoursSinceCreation < EXPIRY_HOURS) {
          // Check if dates are still in the future
          const today = new Date()
          today.setHours(0, 0, 0, 0)
          const allDatesValid = parsed.selectedDates.every(d => d >= today)
          
          if (allDatesValid) {
            setBookingDataState(parsed)
            console.log('[BookingContext] Loaded booking from storage:', parsed)
          } else {
            console.log('[BookingContext] Booking dates expired, clearing')
            sessionStorage.removeItem(STORAGE_KEY)
          }
        } else {
          console.log('[BookingContext] Booking expired, clearing')
          sessionStorage.removeItem(STORAGE_KEY)
        }
      }
    } catch (error) {
      console.error('[BookingContext] Error loading booking:', error)
      sessionStorage.removeItem(STORAGE_KEY)
    }
  }, [])

  // Save to sessionStorage whenever bookingData changes
  useEffect(() => {
    if (bookingData) {
      try {
        sessionStorage.setItem(STORAGE_KEY, JSON.stringify(bookingData))
        console.log('[BookingContext] Saved booking to storage')
      } catch (error) {
        console.error('[BookingContext] Error saving booking:', error)
      }
    }
  }, [bookingData])

  const setBookingData = (data: Omit<BookingData, 'createdAt'>) => {
    const newBookingData: BookingData = {
      ...data,
      createdAt: Date.now()
    }
    setBookingDataState(newBookingData)
    console.log('[BookingContext] Booking data set:', newBookingData)
  }

  const clearBookingData = () => {
    setBookingDataState(null)
    sessionStorage.removeItem(STORAGE_KEY)
    console.log('[BookingContext] Booking data cleared')
  }

  const updateDates = (dates: Date[]) => {
    if (!bookingData) return
    
    const sortedDates = dates.sort((a, b) => a.getTime() - b.getTime())
    const totalCost = sortedDates.length * bookingData.placementDetails.price
    
    setBookingDataState({
      ...bookingData,
      selectedDates: sortedDates,
      totalCost,
      createdAt: Date.now()
    })
    console.log('[BookingContext] Dates updated:', sortedDates)
  }

  const isBookingValid = (): boolean => {
    if (!bookingData) return false
    
    const hasValidDates = bookingData.selectedDates.length > 0
    const hasValidPlacement = !!(bookingData.placementType && placementTypeDetails[bookingData.placementType])
    const hasValidCost = bookingData.totalCost > 0
    
    return hasValidDates && hasValidPlacement && hasValidCost
  }

  const isDatesExpired = (): boolean => {
    if (!bookingData) return true
    
    // Check if booking is older than EXPIRY_HOURS
    const hoursSinceCreation = (Date.now() - bookingData.createdAt) / (1000 * 60 * 60)
    if (hoursSinceCreation >= EXPIRY_HOURS) return true
    
    // Check if any date is in the past
    const today = new Date()
    today.setHours(0, 0, 0, 0)
    return bookingData.selectedDates.some(d => d < today)
  }

  const recalculateCost = () => {
    if (!bookingData) return
    
    const totalCost = bookingData.selectedDates.length * bookingData.placementDetails.price
    setBookingDataState({
      ...bookingData,
      totalCost
    })
  }

  return (
    <BookingContext.Provider
      value={{
        bookingData,
        setBookingData,
        clearBookingData,
        updateDates,
        isBookingValid,
        isDatesExpired,
        recalculateCost
      }}
    >
      {children}
    </BookingContext.Provider>
  )
}

export function useBooking() {
  const context = useContext(BookingContext)
  if (context === undefined) {
    throw new Error('useBooking must be used within a BookingProvider')
  }
  return context
}