import { Injectable } from '@angular/core';
import { HttpClient } from '@angular/common/http';
import { Observable, firstValueFrom } from 'rxjs';

/**
 * 🎯 ANGULAR API ANALYZER - V2.0
 * 
 * Versão do API Analyzer que funciona dentro da aplicação Angular
 * com autenticação e interceptors configurados automaticamente.
 * 
 * ✨ Features:
 * - Usa HttpClient com auth interceptor
 * - Headers de autenticação automáticos
 * - Contexto de tenant configurado
 * - Tratamento de erros integrado
 */
@Injectable({
  providedIn: 'root'
})
export class AngularApiAnalyzerService {
  
  private baseUrl = 'https://prafrota-be-bff-tenant-api.grupopra.tech';

  constructor(private http: HttpClient) {}

  /**
   * 🔍 ANALISAR API usando contexto autenticado da aplicação
   */
  async analyzeAPIWithAuth(domainName: string): Promise<any> {
    console.log(`🔍 Analisando API com autenticação para domínio: ${domainName}`);
    
    // Testar endpoints com diferentes variações
    const endpoints = [
      `${domainName}?page=1&limit=1`,
      `${domainName}s?page=1&limit=1`, 
      `api/v1/${domainName}?page=1&limit=1`,
      `api/v1/${domainName}s?page=1&limit=1`,
      `${domainName}`,
      `${domainName}s`
    ];

    for (const endpoint of endpoints) {
      try {
        console.log(`🔍 Testando endpoint: ${endpoint}`);
        
        const response = await firstValueFrom(
          this.http.get<any>(endpoint)
        );

        if (response && response.data && Array.isArray(response.data) && response.data.length > 0) {
          const sampleObject = response.data[0];
          console.log(`✅ Dados reais encontrados! ${Object.keys(sampleObject).length} campos`);
          
          // Gerar interface TypeScript baseada nos dados reais
          const interfaceCode = this.generateInterfaceFromSample(domainName, sampleObject);
          
          return {
            success: true,
            strategy: 'authenticated_api_response',
            interface: interfaceCode,
            fields: this.extractFieldsFromSample(sampleObject),
            metadata: {
              source: 'authenticated_api',
              endpoint: endpoint,
              sampleSize: response.data.length,
              totalCount: response.totalCount || 'unknown',
              timestamp: new Date().toISOString()
            }
          };
        } else {
          console.log(`⚠️ Endpoint ${endpoint} sem dados válidos`);
          if (response) {
            console.log(`📋 Estrutura: ${Object.keys(response)}`);
          }
        }
        
      } catch (error: any) {
        console.log(`⚠️ Endpoint ${endpoint} falhou:`, error.message);
        continue;
      }
    }

    return {
      success: false,
      error: 'Nenhum endpoint retornou dados válidos'
    };
  }

  /**
   * 📝 GERAR INTERFACE TypeScript baseada em dados reais
   */
  private generateInterfaceFromSample(domainName: string, sampleObject: any): string {
    const className = this.capitalize(domainName);
    let interfaceCode = `/**
 * 🎯 ${className} Interface - Generated from REAL API Data
 * 
 * ✨ Auto-generated using Angular API Analyzer with Authentication
 * 📊 Source: Real authenticated API response
 * 🔒 Context: Authenticated application context
 * 🕒 Generated: ${new Date().toLocaleString()}
 */
export interface ${className} {\n`;

    Object.entries(sampleObject).forEach(([key, value]) => {
      const type = this.detectTypeScript(value);
      const isOptional = value === null || value === undefined;
      const optional = isOptional ? '?' : '';
      const description = this.inferDescription(key, type);
      
      interfaceCode += `  ${key}${optional}: ${type}; // ${description}\n`;
    });

    interfaceCode += '}';
    return interfaceCode;
  }

  /**
   * 📊 EXTRAIR CAMPOS dos dados reais
   */
  private extractFieldsFromSample(sampleObject: any): any[] {
    return Object.entries(sampleObject).map(([name, value]) => ({
      name,
      type: this.detectTypeScript(value),
      required: value !== null && value !== undefined,
      description: this.inferDescription(name, this.detectTypeScript(value)),
      realValue: typeof value === 'string' ? value.substring(0, 50) + '...' : value
    }));
  }

  /**
   * 🔍 DETECTAR TIPO TypeScript
   */
  private detectTypeScript(value: any): string {
    if (value === null || value === undefined) return 'any';
    
    const type = typeof value;
    
    if (type === 'string') {
      // Detectar datas ISO
      if (/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}/.test(value)) return 'string';
      // Detectar emails
      if (/^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(value)) return 'string';
      return 'string';
    }
    
    if (type === 'number') return 'number';
    if (type === 'boolean') return 'boolean';
    
    if (Array.isArray(value)) {
      if (value.length === 0) return 'any[]';
      return `${this.detectTypeScript(value[0])}[]`;
    }
    
    if (type === 'object') return 'any';
    
    return 'any';
  }

  /**
   * 📝 INFERIR DESCRIÇÃO do campo
   */
  private inferDescription(fieldName: string, type: string): string {
    const descriptions: { [key: string]: string } = {
      id: 'Identificador único',
      name: 'Nome do registro',
      email: 'Endereço de email',
      phone: 'Número de telefone',
      address: 'Endereço',
      status: 'Status do registro',
      active: 'Se está ativo',
      created_at: 'Data de criação',
      updated_at: 'Data de atualização',
      deleted_at: 'Data de exclusão',
      description: 'Descrição',
      title: 'Título',
      price: 'Preço',
      amount: 'Valor/Quantia',
      quantity: 'Quantidade',
      user_id: 'ID do usuário',
      company_id: 'ID da empresa',
      tenant_id: 'ID do tenant'
    };
    
    return descriptions[fieldName] || `Campo ${fieldName} (${type})`;
  }

  /**
   * 🔤 CAPITALIZAR string
   */
  private capitalize(str: string): string {
    return str.charAt(0).toUpperCase() + str.slice(1);
  }

  /**
   * 🧪 TESTE RÁPIDO - para uso no console da aplicação
   */
  async quickTest(domainName: string): Promise<void> {
    console.log(`🧪 TESTE RÁPIDO: ${domainName}`);
    const result = await this.analyzeAPIWithAuth(domainName);
    
    if (result.success) {
      console.log('✅ SUCESSO! Dados reais da API detectados');
      console.log('📊 Campos encontrados:', result.fields.length);
      console.log('📝 Interface gerada:');
      console.log(result.interface);
    } else {
      console.log('❌ Falha:', result.error);
    }
  }
} 