// import { Models } from "appwrite"; // Removido - não usamos mais Appwrite

export interface CatalogoProdutoData {
  $id: string;
  descricao: string;
  nome?: string;
  "codigo-interno"?: string;
  "codigo-ean"?: string;
  "principio-ativo"?: string;
  concentracao?: string;
  "forma-farmaceutica"?: string;
  "registro-anvisa"?: string;
  prescricao?: string;
  observacoes?: string;
  laboratorios?: any;
  categorias?: any;
}

export interface ApiResponse<T = any> {
  success: boolean;
  data?: T;
  error?: string;
  details?: any;
}

export interface PaginatedResponse<T> extends ApiResponse<T> {
  documents: T[];
  total: number;
}

class CatalogoProdutoService {
  /**
   * Obtém o token de autenticação do localStorage
   */
  private getAuthToken(): string | null {
    if (typeof window === 'undefined') return null;
    return localStorage.getItem('access_token');
  }

  /**
   * Cria headers para requisições
   */
  private getHeaders(): HeadersInit {
    const headers: HeadersInit = {
      'Accept': 'application/json',
      'Content-Type': 'application/json',
    };

    // Para BFF em produção, incluir autenticação
    if (typeof window !== 'undefined' && window.location.hostname !== 'localhost') {
      const token = this.getAuthToken();
      if (token) {
        headers['Authorization'] = `Bearer ${token}`;
      }
    }

    return headers;
  }

  private getBaseUrl(): string {
    // Verificar se estamos no browser e qual é o ambiente
    if (typeof window !== 'undefined') {
      // Em desenvolvimento (localhost), usar API local
      if (window.location.hostname === 'localhost') {
        console.log('🌐 [Service] Desenvolvimento - usando API local');
        return '/api/catalogo-produtos';
      }
      
  // Em produção, usar BFF com endpoint correto para produtos-catalogo
  const bffUrl = `${process.env.NEXT_PUBLIC_BFF_API_URL}/produtos-catalogo`;
  console.log('🌐 [Service] Produção - usando BFF:', bffUrl);
  return bffUrl;
    }
    
    // No servidor (SSR), usar URL relativa para desenvolvimento
    console.log('🌐 [Service] SSR - usando URL relativa');
    return '/api/catalogo-produtos';
  }

  async listar(): Promise<PaginatedResponse<any>> {
    try {
      console.log('🔍 [Service] Listando produtos do catálogo...');
      
      const response = await fetch(this.getBaseUrl(), {
        method: "GET",
        headers: this.getHeaders(),
        cache: 'no-store',
      });

      if (!response.ok) {
        const errorData = await response.json();
        console.error('❌ [Service] Erro ao listar catálogo:', errorData);
        throw new Error(
          `Erro ao listar catálogo de produtos: ${response.status} - ${errorData.error || 'Erro desconhecido'}`
        );
      }

      const data = await response.json();
      console.log('✅ [Service] Produtos listados com sucesso!');
      
      return {
        success: true,
        documents: data.documents || [],
        total: data.total || 0,
      };
    } catch (error) {
      console.error("❌ [Service] Erro ao listar catálogo:", error);
      return {
        success: false,
        error: error instanceof Error ? error.message : String(error),
        documents: [],
        total: 0,
      };
    }
  }

  async buscar(termo: string): Promise<PaginatedResponse<any>> {
    try {
      console.log('🔍 [Service] Buscando produtos por termo:', termo);
      
      const response = await fetch(`${this.getBaseUrl()}?q=${encodeURIComponent(termo)}`, {
        method: "GET",
        headers: this.getHeaders(),
        cache: 'no-store',
      });

      if (!response.ok) {
        const errorData = await response.json();
        console.error('❌ [Service] Erro ao buscar produtos:', errorData);
        throw new Error(
          `Erro ao buscar produtos: ${response.status} - ${errorData.error || 'Erro desconhecido'}`
        );
      }

      const data = await response.json();
      console.log('✅ [Service] Busca realizada com sucesso!');
      
      return {
        success: true,
        documents: data.documents || [],
        total: data.total || 0,
      };
    } catch (error) {
      console.error("❌ [Service] Erro na busca:", error);
      return {
        success: false,
        error: error instanceof Error ? error.message : String(error),
        documents: [],
        total: 0,
      };
    }
  }

  async obterPorId(id: string): Promise<ApiResponse<any>> {
    try {
      const baseUrl = this.getBaseUrl();
      const fullUrl = `${baseUrl}/${id}`;
      
      console.log('🔍 [Service] Obtendo produto por ID:', id);
      console.log('🌐 [Service] URL completa:', fullUrl);
      
      const response = await fetch(fullUrl, {
        method: "GET",
        headers: this.getHeaders(),
        cache: 'no-store',
      });

      if (!response.ok) {
        console.error('❌ [Service] Erro HTTP:', {
          status: response.status,
          statusText: response.statusText,
          url: fullUrl
        });
        
        let errorData;
        try {
          errorData = await response.json();
        } catch {
          errorData = { error: 'Erro de rede ou resposta inválida' };
        }
        
        console.error('❌ [Service] Dados do erro:', errorData);
        
        // Se estamos em produção e o BFF falhou, tentar API local como fallback
        if (fullUrl.includes('bff-dev.saveinmed.com.br')) {
          console.log('🔄 [Service] BFF falhou, tentando API local...');
          return await this.obterPorIdLocal(id);
        }
        
        throw new Error(
          `Erro ao obter produto: ${response.status} - ${errorData.error || errorData.detail || 'Erro desconhecido'}`
        );
      }

      const data = await response.json();
      console.log('✅ [Service] Produto obtido com sucesso!');
      
      // O BFF pode retornar a estrutura diretamente ou encapsulada
      return {
        success: true,
        data: data.data || data,
      };
    } catch (error) {
      console.error("❌ [Service] Erro ao obter produto:", error);
      
      // Se ainda não tentamos a API local, tentar como fallback
      const baseUrl = this.getBaseUrl();
      if (baseUrl.includes('bff-dev.saveinmed.com.br')) {
        console.log('🔄 [Service] Erro geral, tentando API local como fallback...');
        return await this.obterPorIdLocal(id);
      }
      
      return {
        success: false,
        error: error instanceof Error ? error.message : String(error),
      };
    }
  }

  /**
   * Fallback para API local quando BFF falhar
   */
  private async obterPorIdLocal(id: string): Promise<ApiResponse<any>> {
    try {
      console.log('🏠 [Service] Usando API local como fallback para ID:', id);
      
      const localUrl = `/api/catalogo-produtos/${id}`;
      console.log('🌐 [Service] URL local:', localUrl);
      
      const response = await fetch(localUrl, {
        method: "GET",
        cache: 'no-store',
      });

      if (!response.ok) {
        const errorData = await response.json();
        console.error('❌ [Service] Erro na API local:', errorData);
        throw new Error(`Erro na API local: ${response.status} - ${errorData.error || 'Erro desconhecido'}`);
      }

      const data = await response.json();
      console.log('✅ [Service] Produto obtido via API local!');
      
      return {
        success: true,
        data: data.data || data,
      };
    } catch (error) {
      console.error("❌ [Service] Erro na API local:", error);
      return {
        success: false,
        error: error instanceof Error ? error.message : String(error),
      };
    }
  }

  async criar(produtoData: Partial<CatalogoProdutoData>): Promise<ApiResponse<any>> {
    try {
      console.log('➕ [Service] Criando produto no catálogo:', produtoData);
      
      const response = await fetch(this.getBaseUrl(), {
        method: "POST",
        headers: this.getHeaders(),
        body: JSON.stringify(produtoData),
      });

      const data = await response.json();

      if (!response.ok) {
        console.error('❌ [Service] Erro ao criar produto:', data);
        throw new Error(
          `Erro ao criar produto: ${response.status} - ${data.error || 'Erro desconhecido'}`
        );
      }

      console.log('✅ [Service] Produto criado com sucesso!');
      
      return {
        success: true,
        data: data.data,
      };
    } catch (error) {
      console.error("❌ [Service] Erro ao criar produto:", error);
      return {
        success: false,
        error: error instanceof Error ? error.message : String(error),
      };
    }
  }

  async atualizar(id: string, produtoData: Partial<CatalogoProdutoData>): Promise<ApiResponse<any>> {
    try {
      console.log('📝 [Service] Atualizando produto:', id, produtoData);
      
      const response = await fetch(`${this.getBaseUrl()}/${id}`, {
        method: "PATCH",
        headers: this.getHeaders(),
        body: JSON.stringify(produtoData),
      });

      const data = await response.json();

      if (!response.ok) {
        console.error('❌ [Service] Erro ao atualizar produto:', data);
        throw new Error(
          `Erro ao atualizar produto: ${response.status} - ${data.error || 'Erro desconhecido'}`
        );
      }

      console.log('✅ [Service] Produto atualizado com sucesso!');
      
      return {
        success: true,
        data: data.data,
      };
    } catch (error) {
      console.error("❌ [Service] Erro ao atualizar produto:", error);
      return {
        success: false,
        error: error instanceof Error ? error.message : String(error),
      };
    }
  }

  async excluir(id: string): Promise<ApiResponse<void>> {
    try {
      console.log('🗑️ [Service] Excluindo produto:', id);
      
      const response = await fetch(`${this.getBaseUrl()}/${id}`, {
        method: "DELETE",
        headers: this.getHeaders(),
      });

      if (!response.ok) {
        const errorData = await response.json();
        console.error('❌ [Service] Erro ao excluir produto:', errorData);
        throw new Error(
          `Erro ao excluir produto: ${response.status} - ${errorData.error || 'Erro desconhecido'}`
        );
      }

      console.log('✅ [Service] Produto excluído com sucesso!');
      
      return {
        success: true,
      };
    } catch (error) {
      console.error("❌ [Service] Erro ao excluir produto:", error);
      return {
        success: false,
        error: error instanceof Error ? error.message : String(error),
      };
    }
  }
}

export const catalogoProdutoService = new CatalogoProdutoService();
export default catalogoProdutoService;