story-generator/src/hooks/useDatabase.ts

import { useState } from 'react';
import { supabase } from '../lib/supabase';
import { School, Teacher, Class, Student, TeacherClass, Story, StoryPage } from '../types/database';

export function useDatabase() {
  const [loading, setLoading] = useState(false);
  const [error, setError] = useState<string | null>(null);

  // Funções para escolas
  const getSchools = async () => {
    try {
      setLoading(true);
      const { data, error } = await supabase
        .from('schools')
        .select('*');
      
      if (error) throw error;
      return data;
    } catch (err) {
      setError('Erro ao buscar escolas');
      console.error(err);
      return null;
    } finally {
      setLoading(false);
    }
  };

  // Funções para professores
  const getTeachersBySchool = async (schoolId: string) => {
    try {
      setLoading(true);
      const { data, error } = await supabase
        .from('teachers')
        .select(`
          id,
          name,
          email,
          subject,
          status
        `)
        .eq('school_id', schoolId);

      if (error) throw error;
      return data;
    } catch (err) {
      setError('Erro ao buscar professores');
      console.error(err);
      return null;
    } finally {
      setLoading(false);
    }
  };

  const inviteTeacher = async (schoolId: string, teacherData: {
    name: string;
    email: string;
    subject?: string;
    message?: string;
  }) => {
    try {
      setLoading(true);
      const { data, error } = await supabase
        .rpc('invite_teacher', {
          p_school_id: schoolId,
          p_name: teacherData.name,
          p_email: teacherData.email,
          p_subject: teacherData.subject || null,
          p_message: teacherData.message || null
        });

      if (error) throw error;
      return data;
    } catch (err) {
      setError('Erro ao enviar convite');
      console.error(err);
      return null;
    } finally {
      setLoading(false);
    }
  };

  // Funções para turmas
  const getClassesBySchool = async (schoolId: string) => {
    try {
      setLoading(true);
      const { data, error } = await supabase
        .from('classes')
        .select(`
          *,
          students (*)
        `)
        .eq('school_id', schoolId);
      
      if (error) throw error;
      return data;
    } catch (err) {
      setError('Erro ao buscar turmas');
      console.error(err);
      return null;
    } finally {
      setLoading(false);
    }
  };

  // Funções para alunos
  const getStudentsByClass = async (classId: string) => {
    try {
      setLoading(true);
      const { data, error } = await supabase
        .from('students')
        .select('*')
        .eq('class_id', classId);
      
      if (error) throw error;
      return data;
    } catch (err) {
      setError('Erro ao buscar alunos');
      console.error(err);
      return null;
    } finally {
      setLoading(false);
    }
  };

  // Funções para histórias
  const getStoriesByStudent = async (studentId: string) => {
    try {
      setLoading(true);
      const { data, error } = await supabase
        .from('stories')
        .select('*')
        .eq('student_id', studentId)
        .order('created_at', { ascending: false });
      
      if (error) throw error;
      return data;
    } catch (err) {
      setError('Erro ao buscar histórias');
      console.error(err);
      return null;
    } finally {
      setLoading(false);
    }
  };

  const createStory = async (studentId: string, story: Omit<Story, 'id' | 'created_at' | 'updated_at'>) => {
    try {
      setLoading(true);
      const { data, error } = await supabase
        .from('stories')
        .insert([
          {
            student_id: studentId,
            title: story.title,
            theme: story.theme,
            content: story.content,
            status: story.status
          }
        ])
        .select()
        .single();
      
      if (error) throw error;
      return data;
    } catch (err) {
      setError('Erro ao criar história');
      console.error(err);
      return null;
    } finally {
      setLoading(false);
    }
  };

  const updateStory = async (storyId: string, updates: Partial<Story>) => {
    try {
      setLoading(true);
      const { data, error } = await supabase
        .from('stories')
        .update(updates)
        .eq('id', storyId)
        .select()
        .single();
      
      if (error) throw error;
      return data;
    } catch (err) {
      setError('Erro ao atualizar história');
      console.error(err);
      return null;
    } finally {
      setLoading(false);
    }
  };

  const addPageToStory = async (storyId: string, page: StoryPage) => {
    try {
      setLoading(true);
      const { data: story, error: fetchError } = await supabase
        .from('stories')
        .select('content')
        .eq('id', storyId)
        .single();

      if (fetchError) throw fetchError;

      const updatedContent = {
        ...story.content,
        pages: [...story.content.pages, page]
      };

      const { data, error } = await supabase
        .from('stories')
        .update({ content: updatedContent })
        .eq('id', storyId)
        .select()
        .single();

      if (error) throw error;
      return data;
    } catch (err) {
      setError('Erro ao adicionar página');
      console.error(err);
      return null;
    } finally {
      setLoading(false);
    }
  };

  return {
    loading,
    error,
    getSchools,
    getTeachersBySchool,
    getClassesBySchool,
    getStudentsByClass,
    getStoriesByStudent,
    createStory,
    updateStory,
    addPageToStory,
    inviteTeacher,
  };
}