'use client';

import { createContext, useContext, useState, useEffect, useCallback } from 'react';
import { ComparisonService } from '../services/comparison.service';
import { LocalComparisonRepository } from '../repositories/local-comparison.repository';

interface ComparisonContextType {
  items: string[];
  addItem: (productId: string) => boolean;
  removeItem: (productId: string) => void;
  clearItems: () => void;
  isInComparison: (productId: string) => boolean;
  canAddMore: () => boolean;
  hydrated: boolean;
}

const ComparisonContext = createContext<ComparisonContextType | undefined>(undefined);

const repository = new LocalComparisonRepository();
const service = new ComparisonService(repository);

export function ComparisonProvider({ children }: { children: React.ReactNode }) {
  const [items, setItems] = useState<string[]>([]);
  const [hydrated, setHydrated] = useState(false);

  useEffect(() => {
    const initialItems = service.getItems();
    setItems(initialItems);
    setHydrated(true);
  }, []);

  const addItem = useCallback((productId: string): boolean => {
    if (!service.canAddMore()) return false;
    
    const success = service.addItem(productId);
    if (success) {
      setItems(prev => [...prev, productId]);
    }
    return success;
  }, []);

  const removeItem = useCallback((productId: string) => {
    service.removeItem(productId);
    setItems(prev => prev.filter(id => id !== productId));
  }, []);

  const clearItems = useCallback(() => {
    service.clearItems();
    setItems([]);
  }, []);

  const isInComparison = useCallback((productId: string) => {
    return items.includes(productId);
  }, [items]);

  const canAddMore = useCallback(() => {
    return items.length < 6;
  }, [items]);

  const value = {
    items,
    addItem,
    removeItem,
    clearItems,
    isInComparison,
    canAddMore,
    hydrated,
  };

  return <ComparisonContext.Provider value={value}>{children}</ComparisonContext.Provider>;
}

export function useComparison() {
  const context = useContext(ComparisonContext);
  if (context === undefined) {
    throw new Error('useComparison must be used within a ComparisonProvider');
  }
  return context;
}