'use client';

import { useEffect, useState, useCallback } from 'react';
import type { Project, IdeaMotriz, Personaje, Capitulo } from '@/types/project';

interface UseProjectDataReturn {
  project: Project | null;
  ideaMotriz: IdeaMotriz | null;
  personajes: Personaje[];
  capitulos: Capitulo[];
  currentStep: number;
  loading: boolean;
  generating: boolean;
  setIdeaMotriz: (data: IdeaMotriz | null) => void;
  setPersonajes: (data: Personaje[]) => void;
  setGenerating: (v: boolean) => void;
  changeStep: (step: number) => Promise<void>;
  canAdvance: () => boolean;
  handleGenerateIdeaMotriz: (input: string) => Promise<void>;
  handleRefineIdeaMotriz: (feedback: string) => Promise<void>;
  handleSaveIdeaMotriz: () => Promise<void>;
  handleGeneratePersonajes: () => Promise<void>;
  handleSavePersonajes: () => Promise<void>;
  handleMejorarPersonajes: (feedback: string) => Promise<void>;
  handleAddPersonaje: (nuevoPersonaje: { nombre: string; tipo: string; especie: string; aparienciaFisica: string; descripcion: string }) => Promise<Personaje | null>;
  handleUpdatePersonaje: (updated: Personaje) => void;
  handleDeletePersonaje: (id: string) => void;
  showToast: (message: string, type: 'success' | 'error') => void;
  toast: { message: string; type: 'success' | 'error' } | null;
  clearToast: () => void;
}

export function useProjectData(slug: string): UseProjectDataReturn {
  const [project, setProject] = useState<Project | null>(null);
  const [ideaMotriz, setIdeaMotriz] = useState<IdeaMotriz | null>(null);
  const [personajes, setPersonajes] = useState<Personaje[]>([]);
  const [capitulos, setCapitulos] = useState<Capitulo[]>([]);
  const [currentStep, setCurrentStep] = useState(0);
  const [loading, setLoading] = useState(true);
  const [generating, setGenerating] = useState(false);
  const [toast, setToast] = useState<{ message: string; type: 'success' | 'error' } | null>(null);

  const showToast = useCallback((message: string, type: 'success' | 'error') => {
    setToast({ message, type });
  }, []);

  const clearToast = useCallback(() => setToast(null), []);

  useEffect(() => {
    fetchData();
  }, [slug]);

  const fetchData = async () => {
    setLoading(true);
    try {
      const [projectRes, ideaRes, personajesRes, capitulosRes] = await Promise.all([
        fetch(`/api/projects/${slug}`),
        fetch(`/api/projects/${slug}/idea-motriz`),
        fetch(`/api/projects/${slug}/personajes`),
        fetch(`/api/projects/${slug}/capitulos`),
      ]);

      const projectData = await projectRes.json();
      setProject(projectData);

      const ideaData = await ideaRes.json();
      if (ideaData && !ideaData.error) setIdeaMotriz(ideaData);

      const personajesData = await personajesRes.json();
      if (Array.isArray(personajesData)) setPersonajes(personajesData);

      const capitulosData = await capitulosRes.json();
      if (Array.isArray(capitulosData)) setCapitulos(capitulosData);

      const stepMap: Record<string, number> = { idea_motriz: 0, personajes: 1, capitulos: 2 };
      if (projectData?.currentStep && stepMap[projectData.currentStep] !== undefined) {
        setCurrentStep(stepMap[projectData.currentStep]);
      } else if (ideaData && !ideaData.error) {
        if (personajesData.length > 0) {
          setCurrentStep(2);
        } else {
          setCurrentStep(1);
        }
      }
    } catch (error) {
      console.error('Error fetching data:', error);
    } finally {
      setLoading(false);
    }
  };

  const changeStep = async (newStep: number) => {
    setCurrentStep(newStep);
    const stepNames = ['idea_motriz', 'personajes', 'capitulos'];
    try {
      await fetch(`/api/projects/${slug}`, {
        method: 'PATCH',
        headers: { 'Content-Type': 'application/json' },
        body: JSON.stringify({ currentStep: stepNames[newStep] || stepNames[0] }),
      });
    } catch (error) {
      console.error('Error persisting step:', error);
    }
  };

  const canAdvance = () => {
    switch (currentStep) {
      case 0: return ideaMotriz !== null;
      case 1: return personajes.length > 0;
      default: return true;
    }
  };

  // --- Idea Motriz ---

  const handleGenerateIdeaMotriz = async (input: string) => {
    setGenerating(true);
    try {
      const res = await fetch(`/api/projects/${slug}/idea-motriz`, {
        method: 'POST',
        headers: { 'Content-Type': 'application/json' },
        body: JSON.stringify({ action: 'generate', input }),
      });
      const data = await res.json();
      if (data && !data.error) {
        setIdeaMotriz(data);
        showToast('Idea Motriz generada correctamente', 'success');
      } else {
        showToast(data.error || 'Error generando Idea Motriz', 'error');
      }
    } catch (error) {
      console.error('Error generating idea motriz:', error);
      showToast('Error de conexión al generar Idea Motriz', 'error');
    } finally {
      setGenerating(false);
    }
  };

  const handleRefineIdeaMotriz = async (feedback: string) => {
    if (!ideaMotriz) return;
    setGenerating(true);
    try {
      const res = await fetch(`/api/projects/${slug}/idea-motriz`, {
        method: 'POST',
        headers: { 'Content-Type': 'application/json' },
        body: JSON.stringify({ action: 'refine', input: feedback, current: ideaMotriz }),
      });
      const data = await res.json();
      if (data && !data.error) {
        setIdeaMotriz(data);
        showToast('Idea Motriz refinada correctamente', 'success');
      } else {
        showToast(data.error || 'Error refinando Idea Motriz', 'error');
      }
    } catch (error) {
      console.error('Error refining idea motriz:', error);
      showToast('Error de conexión al refinar Idea Motriz', 'error');
    } finally {
      setGenerating(false);
    }
  };

  const handleSaveIdeaMotriz = async () => {
    if (!ideaMotriz) return;
    setGenerating(true);
    try {
      await fetch(`/api/projects/${slug}/idea-motriz`, {
        method: 'POST',
        headers: { 'Content-Type': 'application/json' },
        body: JSON.stringify({ action: 'save', input: ideaMotriz }),
      });
      showToast('Idea Motriz guardada', 'success');
    } catch (error) {
      console.error('Error saving idea motriz:', error);
      showToast('Error al guardar Idea Motriz', 'error');
    } finally {
      setGenerating(false);
    }
  };

  // --- Personajes ---

  const handleGeneratePersonajes = async () => {
    setGenerating(true);
    try {
      const res = await fetch(`/api/projects/${slug}/personajes`, {
        method: 'POST',
        headers: { 'Content-Type': 'application/json' },
        body: JSON.stringify({ action: 'generate' }),
      });
      const data = await res.json();
      if (Array.isArray(data)) {
        setPersonajes(data);
        showToast('Personajes generados correctamente', 'success');
      } else {
        showToast(data.error || 'Error generando personajes', 'error');
      }
    } catch (error) {
      console.error('Error generating personajes:', error);
      showToast('Error de conexión al generar personajes', 'error');
    } finally {
      setGenerating(false);
    }
  };

  const handleSavePersonajes = async () => {
    setGenerating(true);
    try {
      await fetch(`/api/projects/${slug}/personajes`, {
        method: 'POST',
        headers: { 'Content-Type': 'application/json' },
        body: JSON.stringify({ action: 'save', personajes }),
      });
      showToast('Personajes guardados', 'success');
    } catch (error) {
      console.error('Error saving personajes:', error);
      showToast('Error al guardar personajes', 'error');
    } finally {
      setGenerating(false);
    }
  };

  const handleMejorarPersonajes = async (feedback: string) => {
    if (!feedback.trim()) return;
    setGenerating(true);
    try {
      const res = await fetch(`/api/projects/${slug}/personajes`, {
        method: 'POST',
        headers: { 'Content-Type': 'application/json' },
        body: JSON.stringify({ action: 'improve', feedback, personajes }),
      });
      const data = await res.json();
      if (Array.isArray(data)) {
        setPersonajes(data);
        showToast('Personajes mejorados correctamente', 'success');
      } else {
        showToast(data.error || 'Error mejorando personajes', 'error');
      }
    } catch (error) {
      console.error('Error mejorando personajes:', error);
      showToast('Error de conexión al mejorar personajes', 'error');
    } finally {
      setGenerating(false);
    }
  };

  const handleAddPersonaje = async (nuevoPersonaje: { nombre: string; tipo: string; especie: string; aparienciaFisica: string; descripcion: string }): Promise<Personaje | null> => {
    if (!nuevoPersonaje.nombre.trim()) return null;
    setGenerating(true);
    try {
      const res = await fetch(`/api/projects/${slug}/personajes`, {
        method: 'POST',
        headers: { 'Content-Type': 'application/json' },
        body: JSON.stringify({
          action: 'add',
          nuevoPersonaje,
          personajes,
          ideaMotriz,
        }),
      });
      const data = await res.json();
      if (data && !data.error) {
        setPersonajes([...personajes, data]);
        showToast(`Personaje "${data.nombre}" creado`, 'success');
        return data as Personaje;
      } else {
        showToast(data.error || 'Error creando personaje', 'error');
        return null;
      }
    } catch (error) {
      console.error('Error añadiendo personaje:', error);
      showToast('Error de conexión al crear personaje', 'error');
      return null;
    } finally {
      setGenerating(false);
    }
  };

  const handleUpdatePersonaje = (updatedPersonaje: Personaje) => {
    setPersonajes(personajes.map(p => p.id === updatedPersonaje.id ? updatedPersonaje : p));
  };

  const handleDeletePersonaje = (id: string) => {
    setPersonajes(personajes.filter(p => p.id !== id));
  };

  return {
    project,
    ideaMotriz,
    personajes,
    capitulos,
    currentStep,
    loading,
    generating,
    setIdeaMotriz,
    setPersonajes,
    setGenerating,
    changeStep,
    canAdvance,
    handleGenerateIdeaMotriz,
    handleRefineIdeaMotriz,
    handleSaveIdeaMotriz,
    handleGeneratePersonajes,
    handleSavePersonajes,
    handleMejorarPersonajes,
    handleAddPersonaje,
    handleUpdatePersonaje,
    handleDeletePersonaje,
    showToast,
    toast,
    clearToast,
  };
}
