import axios from "axios";

const WP_BASE_URL = process.env.WP_BASE_URL || 'https://ccis-agadir.ma';
const WP_USERNAME = process.env.WP_USERNAME || 'ccismsm';
const WP_APP_PASSWORD = process.env.WP_APP_PASSWORD || 'Pkil wzVo stXl Fd2Q ejRY Nvae';

export interface GravityFormEntry {
  id: string;
  form_id: string;
  date_created: string;
  date_updated: string;
  is_starred: string;
  is_read: string;
  ip: string;
  source_url: string;
  user_agent: string;
  currency: string;
  status: string;
  [key: string]: any;
}

export interface FilteredFormEntry {
  id: string;
  form_id: string;
  form_title: string;
  date_created: string;
  nom?: string;
  email?: string;
  telephone?: string;
  projet?: string;
  ville?: string;
  ip: string;
  is_legit: boolean;
  spam_reason?: string;
}

export interface FormsResponse {
  metadata: {
    total_forms: number;
    total_entries: number;
    legitimate_entries: number;
    spam_entries: number;
    generated_at: string;
  };
  forms: any;
  entries: FilteredFormEntry[];
}

class GravityFormsService {
  private baseUrl: string;
  private authHeader: string;

  constructor() {
    this.baseUrl = WP_BASE_URL;
    const credentials = Buffer.from(`${WP_USERNAME}:${WP_APP_PASSWORD}`).toString('base64');
    this.authHeader = `Basic ${credentials}`;
  }

  private async makeRequest(endpoint: string): Promise<any> {
    try {
      console.log(`🔗 API Request: ${endpoint}`);
      
      const response = await axios.get(`${this.baseUrl}${endpoint}`, {
        headers: {
          'Authorization': this.authHeader,
          'Content-Type': 'application/json',
          'User-Agent': 'CCIS-Connect-API/1.0'
        },
        timeout: 30000
      });
      
      return response.data;
    } catch (error: any) {
      console.error(`❌ API Request failed for ${endpoint}:`, error.response?.data || error.message);
      throw new Error(`API Error: ${error.response?.status} - ${error.response?.statusText}`);
    }
  }

  private isSpamEntry(entry: GravityFormEntry): { isSpam: boolean; reason?: string } {
    const nom = (entry['1'] || '').toString();
    const email = (entry['6'] || '').toString();
    const userAgent = entry.user_agent || '';

    // Détection des patterns de spam BTC
    const spamPatterns = [
      /BTC|Bitcoin|btc/i,
      /graph\.org|http.*graph/i,
      /\ud83d[\udcd7-\udced]|\u2709\ufe0f/i,
      /deal|bonus|transfer|wallet|notification|verification|withdrawal/i,
      /\d+\.\d+ BTC/i
    ];

    for (const pattern of spamPatterns) {
      if (pattern.test(nom) || pattern.test(userAgent)) {
        return { isSpam: true, reason: 'Pattern BTC/Spam détecté' };
      }
    }

    // Détection des emails suspects
    const spamEmails = [
      /boranora\.com|chahcyrans\.com|jagomail\.com|code-gmail\.com|dmxs8\.com|mailgetget\.asia|theking\.id|email-temp\.com|thinhmin\.com/i
    ];

    for (const pattern of spamEmails) {
      if (pattern.test(email)) {
        return { isSpam: true, reason: 'Email spam détecté' };
      }
    }

    return { isSpam: false };
  }

  private mapFormFields(entry: GravityFormEntry, formTitle: string): Partial<FilteredFormEntry> {
    const fields: Partial<FilteredFormEntry> = {};
    const formId = entry.form_id.toString();

    // Mapping spécifique pour chaque formulaire
    switch (formId) {
      case '6': // Accompagnement
        fields.nom = entry['1'];
        fields.email = entry['2'];
        fields.telephone = entry['3'];
        fields.projet = entry['4'];
        break;
      
      case '7': // Business Plan
        fields.nom = entry['1'];
        fields.email = entry['6'];
        fields.telephone = entry['5'];
        fields.projet = entry['7'];
        fields.ville = entry['8'];
        break;
      
      case '8': // Étude de Marché
        fields.nom = entry['1'];
        fields.email = entry['2'];
        fields.telephone = entry['3'];
        fields.projet = entry['4'];
        break;
      
      case '9': // Le Networking
        fields.nom = entry['1'];
        fields.email = entry['2'];
        fields.telephone = entry['3'];
        fields.projet = entry['4'];
        break;
      
      case '10': // Le sourcing
        fields.nom = entry['1'];
        fields.email = entry['2'];
        fields.telephone = entry['3'];
        fields.projet = entry['4'];
        break;
      
      case '11': // La Prospection
        fields.nom = entry['1'];
        fields.email = entry['2'];
        fields.telephone = entry['3'];
        fields.projet = entry['4'];
        break;
      
      default:
        // Mapping générique
        fields.nom = entry['1'] || entry['2'] || entry['3'];
        fields.email = entry['6'] || entry['4'] || entry['5'];
        fields.telephone = entry['5'] || entry['3'] || entry['7'];
        fields.projet = entry['7'] || entry['4'] || entry['8'];
        fields.ville = entry['8'] || entry['9'];
    }
    
    return fields;
  }

  async getFormEntries(formId: string): Promise<FilteredFormEntry[]> {
    try {
      console.log(`🔄 Récupération des entrées du formulaire ${formId}...`);
      
      const forms = await this.makeRequest('/wp-json/gf/v2/forms');
      const form = forms[formId];
      
      if (!form) {
        throw new Error(`Formulaire ${formId} non trouvé`);
      }

      const entriesData = await this.makeRequest(`/wp-json/gf/v2/forms/${formId}/entries`);
      const entries: GravityFormEntry[] = entriesData.entries || [];
      
      console.log(`✅ Formulaire ${formId}: ${entries.length} entrées trouvées`);

      const filteredEntries: FilteredFormEntry[] = [];
      
      for (const entry of entries) {
        const spamCheck = this.isSpamEntry(entry);
        const mappedFields = this.mapFormFields(entry, form.title);
        
        const filteredEntry: FilteredFormEntry = {
          id: entry.id,
          form_id: entry.form_id,
          form_title: form.title,
          date_created: entry.date_created,
          ip: entry.ip,
          is_legit: !spamCheck.isSpam,
          ...mappedFields
        };
        
        if (spamCheck.isSpam) {
          filteredEntry.spam_reason = spamCheck.reason;
        }
        
        filteredEntries.push(filteredEntry);
      }

      return filteredEntries;
    } catch (error: any) {
      console.error(`❌ Erreur avec le formulaire ${formId}:`, error.message);
      throw error;
    }
  }

  async getAllForms(): Promise<any> {
    try {
      console.log('🔄 Récupération de tous les formulaires...');
      const forms = await this.makeRequest('/wp-json/gf/v2/forms');
      console.log(`✅ ${Object.keys(forms).length} formulaires trouvés`);
      return forms;
    } catch (error: any) {
      console.error('❌ Erreur lors de la récupération des formulaires:', error.message);
      throw error;
    }
  }

  async getAllFormsData(): Promise<FormsResponse> {
    try {
      console.log('🔄 Récupération de toutes les données...');
      
      const forms = await this.getAllForms();
      const formIds = Object.keys(forms);
      
      const allFilteredEntries: FilteredFormEntry[] = [];
      let totalEntries = 0;
      let totalLegit = 0;
      let totalSpam = 0;

      for (const formId of formIds) {
        try {
          const entries = await this.getFormEntries(formId);
          const legitEntries = entries.filter(entry => entry.is_legit);
          
          allFilteredEntries.push(...legitEntries);
          totalEntries += entries.length;
          totalLegit += legitEntries.length;
          totalSpam += (entries.length - legitEntries.length);
          
          await new Promise(resolve => setTimeout(resolve, 500));
          
        } catch (error) {
          console.error(`⚠️ Ignored form ${formId}:`, error.message);
        }
      }

      const result: FormsResponse = {
        metadata: {
          total_forms: formIds.length,
          total_entries: totalEntries,
          legitimate_entries: totalLegit,
          spam_entries: totalSpam,
          generated_at: new Date().toISOString()
        },
        forms: forms,
        entries: allFilteredEntries
      };

      return result;
      
    } catch (error: any) {
      console.error('❌ Erreur lors de la récupération de toutes les données:', error.message);
      throw error;
    }
  }
}

export const gravityFormsService = new GravityFormsService();