'use client';

/**
 * Delivery Templates Hook
 * 
 * Save and reuse common delivery patterns
 */

import { useState, useEffect, useCallback } from 'react';

export interface DeliveryTemplate {
  id: string;
  name: string;
  createdAt: number;
  lastUsedAt: number;
  useCount: number;
  data: {
    school_id?: number;
    school_name?: string;
    commodity_id?: number;
    commodity_name?: string;
    supplier_id?: number;
    supplier_name?: string;
    typical_quantity?: number;
    units?: any[];
    notes?: string;
  };
}

const TEMPLATES_KEY = 'gcx_fshs_delivery_templates';
const MAX_TEMPLATES = 20;

const generateId = (): string => {
  return `tpl_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
};

export function useDeliveryTemplates() {
  const [templates, setTemplates] = useState<DeliveryTemplate[]>([]);
  const [isLoaded, setIsLoaded] = useState(false);

  // Load templates from localStorage
  const loadTemplates = useCallback(() => {
    try {
      const stored = localStorage.getItem(TEMPLATES_KEY);
      if (stored) {
        const parsed = JSON.parse(stored);
        setTemplates(Array.isArray(parsed) ? parsed : []);
      }
      setIsLoaded(true);
    } catch (e) {
      console.error('Failed to load templates:', e);
      setIsLoaded(true);
    }
  }, []);

  // Save templates to localStorage
  const saveTemplates = useCallback((newTemplates: DeliveryTemplate[]) => {
    try {
      // Sort by last used and limit
      const sorted = [...newTemplates]
        .sort((a, b) => b.lastUsedAt - a.lastUsedAt)
        .slice(0, MAX_TEMPLATES);
      
      localStorage.setItem(TEMPLATES_KEY, JSON.stringify(sorted));
      setTemplates(sorted);
    } catch (e) {
      console.error('Failed to save templates:', e);
    }
  }, []);

  // Create new template
  const createTemplate = useCallback((
    name: string,
    data: DeliveryTemplate['data']
  ): DeliveryTemplate => {
    const template: DeliveryTemplate = {
      id: generateId(),
      name,
      createdAt: Date.now(),
      lastUsedAt: Date.now(),
      useCount: 0,
      data,
    };

    saveTemplates([template, ...templates]);
    return template;
  }, [templates, saveTemplates]);

  // Update existing template
  const updateTemplate = useCallback((
    id: string,
    updates: Partial<Pick<DeliveryTemplate, 'name' | 'data'>>
  ) => {
    const updated = templates.map(t =>
      t.id === id ? { ...t, ...updates } : t
    );
    saveTemplates(updated);
  }, [templates, saveTemplates]);

  // Delete template
  const deleteTemplate = useCallback((id: string) => {
    saveTemplates(templates.filter(t => t.id !== id));
  }, [templates, saveTemplates]);

  // Use template (increment counter, update lastUsed)
  const useTemplate = useCallback((id: string): DeliveryTemplate | null => {
    const template = templates.find(t => t.id === id);
    if (!template) return null;

    const updated = templates.map(t =>
      t.id === id ? {
        ...t,
        lastUsedAt: Date.now(),
        useCount: t.useCount + 1,
      } : t
    );
    saveTemplates(updated);

    return { ...template, lastUsedAt: Date.now(), useCount: template.useCount + 1 };
  }, [templates, saveTemplates]);

  // Auto-create template from delivery (smart suggestion)
  const suggestTemplate = useCallback((deliveryData: DeliveryTemplate['data']): boolean => {
    // Check if similar template exists
    const exists = templates.some(t => 
      t.data.school_id === deliveryData.school_id &&
      t.data.commodity_id === deliveryData.commodity_id
    );
    
    return !exists;
  }, [templates]);

  // Get frequently used templates
  const frequentTemplates = templates
    .filter(t => t.useCount >= 2)
    .sort((a, b) => b.useCount - a.useCount)
    .slice(0, 5);

  // Get recent templates
  const recentTemplates = templates
    .sort((a, b) => b.lastUsedAt - a.lastUsedAt)
    .slice(0, 5);

  // Search templates
  const searchTemplates = useCallback((query: string): DeliveryTemplate[] => {
    const lowerQuery = query.toLowerCase();
    return templates.filter(t =>
      t.name.toLowerCase().includes(lowerQuery) ||
      t.data.school_name?.toLowerCase().includes(lowerQuery) ||
      t.data.commodity_name?.toLowerCase().includes(lowerQuery)
    );
  }, [templates]);

  // Initialize
  useEffect(() => {
    loadTemplates();
  }, [loadTemplates]);

  return {
    templates,
    isLoaded,
    frequentTemplates,
    recentTemplates,
    createTemplate,
    updateTemplate,
    deleteTemplate,
    useTemplate,
    suggestTemplate,
    searchTemplates,
  };
}