import { useState, useCallback } from 'react';
import { Models } from 'appwrite';
import { catalogoProdutoService } from '@/services/catalogoProdutoService';

export interface CatalogoProdutoFormData {
  descricao: string;
  codigo_interno?: string;
  codigo_ean?: string;
  preco_fabrica?: number;
  pmc?: number;
  desconto_comercial?: number;
  valor_substituicao_tributaria?: number;
  preco_nf?: number;
  laboratorio?: string;
  subcategoria?: string;
  categoria?: string;
}

export interface CatalogoProdutoStats {
  total: number;
  comLaboratorio: number;
  comPreco: number;
  porCategoria: Record<string, number>;
}

export interface UseCatalogoProdutosReturn {
  catalogoProdutos: Models.Document[];
  loading: boolean;
  isChangingPage: boolean;
  isCreating: boolean;
  error: string | null;
  totalCatalogoProdutos: number;
  currentPage: number;
  listarCatalogo: (page?: number, termoBusca?: string) => Promise<void>;
  buscarCatalogo: (params: { termo: string; filtros: any }, page?: number) => Promise<void>;
  cadastrarCatalogo: (data: CatalogoProdutoFormData) => Promise<boolean>;
  atualizarCatalogo: (id: string, data: CatalogoProdutoFormData) => Promise<boolean>;
  deletarCatalogo: (id: string) => Promise<boolean>;
  obterEstatisticas: () => CatalogoProdutoStats;
  setCurrentPage: (page: number) => void;
}

export const useCatalogoProdutos = (): UseCatalogoProdutosReturn => {
  const [catalogoProdutos, setCatalogoProdutos] = useState<Models.Document[]>([]);
  const [loading, setLoading] = useState(false);
  const [error, setError] = useState<string | null>(null);
  const [totalCatalogoProdutos, setTotalCatalogoProdutos] = useState(0);
  const [currentPage, setCurrentPage] = useState(1);
  const [isChangingPage, setIsChangingPage] = useState(false);
  const [isCreating, setIsCreating] = useState(false);

  const listarCatalogo = useCallback(async (page = currentPage, termoBusca = '') => {
    setIsChangingPage(true);
    setLoading(true);
    setError(null);

    try {
      let response;
      
      if (termoBusca.trim()) {
        // Se há termo de busca, usar o método buscar
        response = await catalogoProdutoService.buscar(termoBusca);
      } else {
        // Se não há termo de busca, usar o método listar
        response = await catalogoProdutoService.listar();
      }
      
      // Implementar paginação manual no frontend
      const itemsPerPage = 10;
      const startIndex = (page - 1) * itemsPerPage;
      const endIndex = startIndex + itemsPerPage;
      const paginatedDocuments = response.documents.slice(startIndex, endIndex);
      
      setCatalogoProdutos(paginatedDocuments);
      setTotalCatalogoProdutos(response.total);
      setCurrentPage(page);
    } catch (err: any) {
      setError(err.message || 'Erro ao listar catálogo de produtos');
      console.error('Erro ao listar catálogo:', err);
    } finally {
      setLoading(false);
      setIsChangingPage(false);
    }
  }, [currentPage]);

  const buscarCatalogo = useCallback(
    async (params: { termo: string; filtros: any }, page = 1) => {
      setIsChangingPage(true);
      setLoading(true);
      setError(null);

      try {
        console.log('Busca catalogo de produtos:', { termo: params.termo, page });
        const response = await catalogoProdutoService.buscar(params.termo);
        
        // Implementar paginação manual no frontend
        const itemsPerPage = 10;
        const startIndex = (page - 1) * itemsPerPage;
        const endIndex = startIndex + itemsPerPage;
        const paginatedDocuments = response.documents.slice(startIndex, endIndex);

        setCatalogoProdutos(paginatedDocuments);
        setTotalCatalogoProdutos(response.total);
        setCurrentPage(page);
      } catch (err: any) {
        setError(err.message || 'Erro ao buscar catálogo de produtos');
        console.error('Erro ao buscar catálogo:', err);
      } finally {
        setLoading(false);
        setIsChangingPage(false);
      }
    },
    []
  );

  const cadastrarCatalogo = useCallback(async (data: CatalogoProdutoFormData): Promise<boolean> => {
    setIsCreating(true);
    setError(null);

    try {
      await catalogoProdutoService.criar(data as any);
      await listarCatalogo(currentPage);
      return true;
    } catch (err: any) {
      setError(err.message || 'Erro ao cadastrar produto');
      console.error('Erro ao cadastrar:', err);
      return false;
    } finally {
      setIsCreating(false);
    }
  }, [currentPage, listarCatalogo]);

  const atualizarCatalogo = useCallback(async (id: string, data: CatalogoProdutoFormData): Promise<boolean> => {
    setLoading(true);
    setError(null);

    try {
      await catalogoProdutoService.atualizar(id, data as any);
      await listarCatalogo(currentPage);
      return true;
    } catch (err: any) {
      setError(err.message || 'Erro ao atualizar produto');
      console.error('Erro ao atualizar:', err);
      return false;
    } finally {
      setLoading(false);
    }
  }, [currentPage, listarCatalogo]);

  const deletarCatalogo = useCallback(async (id: string): Promise<boolean> => {
    setLoading(true);
    setError(null);

    try {
      await catalogoProdutoService.deletar(id);
      await listarCatalogo(currentPage);
      return true;
    } catch (err: any) {
      setError(err.message || 'Erro ao deletar produto');
      console.error('Erro ao deletar:', err);
      return false;
    } finally {
      setLoading(false);
    }
  }, [currentPage, listarCatalogo]);

  const obterEstatisticas = useCallback((): CatalogoProdutoStats => {
    const stats: CatalogoProdutoStats = {
      total: catalogoProdutos.length,
      comLaboratorio: 0,
      comPreco: 0,
      porCategoria: {},
    };

    catalogoProdutos.forEach((doc) => {
      if (doc.laboratorio) stats.comLaboratorio += 1;
      if (doc.preco_nf && doc.preco_nf > 0) stats.comPreco += 1;
      const cat = (doc as any).categoria;
      if (cat) {
        stats.porCategoria[cat] = (stats.porCategoria[cat] || 0) + 1;
      }
    });

    return stats;
  }, [catalogoProdutos]);

  return {
    catalogoProdutos,
    loading,
    isChangingPage,
    isCreating,
    error,
    totalCatalogoProdutos,
    currentPage,
    listarCatalogo,
    buscarCatalogo,
    cadastrarCatalogo,
    atualizarCatalogo,
    deletarCatalogo,
    obterEstatisticas,
    setCurrentPage
  };
};
