import { Injectable } from '@angular/core';
import { Observable, map } from 'rxjs';
import { Papa } from 'ngx-papaparse';
import { ApiClientService } from '../../../shared/services/api/api-client.service';
import { Integration, PaginatedResponse, IntegrationFilter, ReconnectData } from '../interfaces/integration.interface';
import { DomainService } from '../../../shared/components/base-domain/base-domain.component';

@Injectable({
    providedIn: 'root' 
})
export class IntegrationService implements DomainService<Integration> { 
    constructor(
        private apiClient: ApiClientService,
        private papa: Papa
    ) {}

    /**
     * Busca integrações com paginação e filtros
     */
    getIntegrations( 
        page = 1, 
        limit = 10, 
        filters?: {[key: string]: string}
    ): Observable<PaginatedResponse<Integration>> {
        
        let url = `integration?page=${page}&limit=${limit}`;
        
        if (filters) {
            const params = new URLSearchParams();
            
            for (const [key, value] of Object.entries(filters)) {
                if (value) {
                    params.append(key, value);
                }
            }
            
            url += `&${params.toString()}`;
        }
        
        return this.apiClient.get<PaginatedResponse<Integration>>(url);
    }

    /**
     * Busca uma integração específica por ID
     */
    getById(id: string | number): Observable<Integration> {
        return this.apiClient.get<Integration>(`integration/${id}`);
    }
    
    /**
     * ✅ Método genérico para criar - chamado automaticamente pelo BaseDomainComponent
     */
    create(data: any): Observable<Integration> {
        return this.apiClient.post<Integration>('integration', data);
    }

    /**
     * ✅ Método genérico para atualizar - chamado automaticamente pelo BaseDomainComponent
     */
    update(id: any, data: any): Observable<Integration> {
        return this.apiClient.patch<Integration>(`integration/${id}`, data);
    }

    /**
     * Remove uma integração
     */
    delete(id: string | number): Observable<void> {
        return this.apiClient.delete<void>(`integration/${id}`);
    }

    /**
     * Reconecta uma integração existente
     */
    reconnectIntegration(integrationId: number, data: ReconnectData): Observable<Integration> {
        return this.apiClient.put<Integration>(`integration/${integrationId}/reconnect`, data);
    }

    /**
     * Conecta uma nova integração
     */
    connectIntegration(integrationId: number, data: ReconnectData): Observable<Integration> {
        return this.apiClient.post<Integration>(`integration/${integrationId}/connect`, data);
    }

    /**
     * Desconecta uma integração
     */
    disconnectIntegration(integrationId: number): Observable<void> {
        return this.apiClient.delete<void>(`integration/${integrationId}/disconnect`);
    }

    /**
     * Testa conexão de uma integração
     */
    testConnection(integrationId: number): Observable<{ success: boolean; message: string }> {
        return this.apiClient.post<{ success: boolean; message: string }>(`integration/${integrationId}/test`, {});
    }

    /**
     * Busca integrações por tipo (Meli, SasCar, BrasilCredit, etc.)
     */
    getIntegrationsByType(type: string): Observable<Integration[]> {
        return this.apiClient.get<Integration[]>(`integration?type=${type}&isEnabled=true&page=1&limit=30`); 
    }

    /**
     * Busca integrações habilitadas
     */
    getEnabledIntegrations(): Observable<Integration[]> {
        return this.apiClient.get<Integration[]>('integration?isEnabled=true');
    }

    // ========================================
    // 🎯 MÉTODOS ESPERADOS PELO BaseDomainComponent
    // ========================================
    
    /**
     * ✅ Método genérico para listar - chamado automaticamente pelo BaseDomainComponent
     */
    getEntities(page: number, pageSize: number, filters: any): Observable<{
        data: Integration[];
        totalCount: number;
        pageCount: number;
        currentPage: number;
    }> {
        return this.getIntegrations(page, pageSize, filters).pipe(
            map(response => ({
                data: response.data,
                totalCount: response.totalCount,
                pageCount: response.pageCount,
                currentPage: response.currentPage
            }))
        );
    }
} 