import { OnInit, ViewChild, OnDestroy, ChangeDetectorRef, Directive } from "@angular/core";
import { Subscription, Observable } from "rxjs";

import { TitleService } from "../../services/theme/title.service";
import { HeaderActionsService } from "../../services/header-actions.service";
import { TabSystemComponent } from "../tab-system/tab-system.component";
import { TabItem, TabSystemConfig } from "../tab-system/interfaces/tab-system.interface";
import { Logger } from '../../services/logger/logger.service';
import { SideCardConfig } from '../../interfaces/sidecard.config.interface';
import { BulkAction } from "../../interfaces/bulk-action.interface";

/**
 * 🎯 BaseDomainComponent - Componente Base Abstrato para Domínios ERP
 * 
 * Este componente abstrato encapsula todos os padrões comuns dos domínios:
 * - ✅ Sistema de abas integrado
 * - ✅ CRUD operations padronizadas
 * - ✅ Gerenciamento de estado unificado
 * - ✅ Header actions configuráveis
 * - ✅ Paginação server-side
 * - ✅ Prevenção de duplicatas
 * - ✅ Event handling padronizado
 * 
 * ## 🚀 Como usar em novos domínios:
 * 
 * ```typescript
 * @Component({
 *   selector: 'app-clients',
 *   template: `<base-domain [config]="domainConfig"></base-domain>`
 * })
 * export class ClientsComponent extends BaseDomainComponent<Client> {
 *   constructor(
 *     clientsService: ClientsService,
 *     titleService: TitleService,
 *     headerActionsService: HeaderActionsService,
 *     cdr: ChangeDetectorRef
 *   ) {
 *     super(titleService, headerActionsService, cdr, clientsService);
 *   }
 * 
 *   protected getDomainConfig(): DomainConfig {
 *     return {
 *       domain: 'client',
 *       title: 'Clientes',
 *       entityName: 'cliente',
 *       subTabs: ['dados', 'contatos', 'financeiro'],
 *       columns: [...]
 *     };
 *   }
 * }
 * ```
 */

export interface DomainConfig {
  domain: string;                    // ID do domínio (ex: 'driver', 'vehicle', 'client')
  title: string;                     // Título para header (ex: 'Motoristas')
  entityName: string;                // Nome da entidade (ex: 'motorista', 'veículo')
  subTabs: string[];                 // Sub-abas para edição ['dados', 'endereco', 'documentos']
  columns: any[];                    // Configuração das colunas da tabela
  pageSize?: number;                 // Tamanho padrão da página (default: 10)
  maxTabs?: number;                  // Máximo de abas abertas (default: 5)
  allowDuplicates?: boolean;         // Permitir abas duplicadas (default: false)
  customActions?: any[];             // Ações customizadas além do padrão edit/new
  sideCard?: SideCardConfig;         // ✨ Configuração do card lateral
  filterConfig?: FilterConfig;       // ✨ Configuração de filtros avançados
  bulkActions?: BulkAction[];        // ✨ Ações em lote para o data-table
  showDashboardTab?: boolean;        // ✨ NOVO: Mostrar aba Dashboard antes da lista (default: false)
  dashboardConfig?: DashboardTabConfig; // ✨ NOVO: Configuração específica do dashboard
  serverSidePagination?: boolean;    // ✨ NOVO: Controla se pesquisa vai ao backend (default: false - pesquisa local)
}

export interface DashboardTabConfig {
  title?: string;                    // Título customizado (default: 'Dashboard de [Title]')
  showKPIs?: boolean;               // Mostrar KPIs principais (default: true)
  showCharts?: boolean;             // Mostrar gráficos (default: true)
  showRecentItems?: boolean;        // Mostrar itens recentes (default: true)
  customKPIs?: DashboardKPI[];      // KPIs customizados
  customCharts?: DashboardChart[];  // Gráficos customizados
  customComponent?: any;            // ✨ NOVO: Componente personalizado
  customData?: any;                 // ✨ NOVO: Dados para componente personalizado
}

export interface DashboardKPI {
  id: string;
  label: string;
  value: string | number;
  icon: string;
  color: 'primary' | 'success' | 'warning' | 'danger' | 'info';
  trend?: 'up' | 'down' | 'stable';
  change?: string;
}

export interface DashboardChart {
  id: string;
  title: string;
  type: 'bar' | 'line' | 'pie' | 'donut';
  data: any[];
  config?: any;
}

export interface FilterConfig {
  specialFilters?: SpecialFilter[];
  defaultFilters?: DefaultFilter[];
  companyFilter?: boolean; // default: true
  dateRangeFilter?: boolean; // default: false
  dateFieldNames?: {
    fieldsSearchDefault?: string[];
    startField?: string; // default: 'date_start'
    endField?: string;   // default: 'date_end'
  };
  
  // ✨ NOVOS: Filtros de data de vencimento
  dueDateOneFilter?: boolean; // default: false - Filtro de data de vencimento 1
  dueDateOneFieldNames?: {
    label?: string;      // ✨ NOVO: Label customizado (default: 'Data de Vencimento 1')
    startField: string;
    endField: string;
  };
  
  dueDateTwoFilter?: boolean; // default: false - Filtro de data de vencimento 2
  dueDateTwoFieldNames?: {
    label?: string;      // ✨ NOVO: Label customizado (default: 'Data de Vencimento 2')
    startField: string;
    endField: string;
  };
  
  // ✨ NOVO: Campos padrão para busca automática no backend
  fieldsSearchDefault?: string[]; // Campos que serão usados para busca automática quando não há resultados locais
  
  // ✨ NOVO: Configurações de pesquisa
  searchConfig?: {
    minSearchLength?: number; // Mínimo de caracteres para iniciar pesquisa (default: 1)
    debounceTime?: number;    // Tempo de espera em ms antes de pesquisar (default: 300)
    preserveSearchOnDataChange?: boolean; // Manter valor da pesquisa quando dados mudam (default: true)
  };
}

export interface SpecialFilter {
  id: string;
  label: string;
  type: 'date-range' | 'number-range' | 'custom-select' | 'multi-search';
  required?: boolean ;
  defaultValue?: any ;
  config?: any;
}

export interface DefaultFilter {
  field: string;
  operator: 'in' | 'eq' | 'like' | 'between' | 'gte' | 'lte';
  value: any;
}

export interface DomainService<T> {
  getEntities(page: number, pageSize: number, filters: any): Observable<{
    data: T[];
    totalCount: number;
    pageCount: number;
    currentPage: number;
  }>;
}

@Directive()
export abstract class BaseDomainComponent<T> implements OnInit, OnDestroy {
  @ViewChild('tabSystem') tabSystem!: TabSystemComponent;

  protected logger: Logger;
  protected subscriptions = new Subscription();
  
  // Domain data (generic)
  entities: T[] = [];
  currentPage = 1;
  itemsPerPage = 100;
  totalItems = 0;
  totalPages = 0;
  isLoading = false;
  currentFilters: { [key: string]: string } = {};
  
  // ✨ NOVO: Lista de itens selecionados
  selectedRows: T[] = [];
  
  // Configuration
  protected domainConfig!: DomainConfig;
  
  // Controle de inicialização para prevenir loops
  private _isInitialized = false;
  private _isLoadingEntities = false;
  private _setupDomainCalled = false;
  private _lastLoadTime = 0;
  
  // Tab system configuration
  tabConfig: TabSystemConfig = {
    maxTabs: 5,
    allowDuplicates: false,
    confirmClose: true
  };

  tabEvents = {
    onMaxTabsReached: () => {
      console.warn('Limite máximo de abas atingido!');
    },
    onUnsavedChanges: (tabs: TabItem[]) => {
      console.warn('Existem mudanças não salvas:', tabs);
    }
  };

  // Table configuration (will be set by domain config)
  tableConfig: any = {};

  constructor(
    protected titleService: TitleService,
    protected headerActionsService: HeaderActionsService,
    protected cdr: ChangeDetectorRef,
    protected entityService: DomainService<T>
  ) {
    this.logger = new Logger(this.constructor.name);
  }

  ngOnInit() {
    if (this._isInitialized) {
      console.warn('[BaseDomainComponent] Tentativa de re-inicialização bloqueada');
      return;
    }
    
    this.domainConfig = this.getDomainConfig();
    
    // 🐛 DEBUG: Verificar se fieldsSearchDefault está sendo configurado corretamente
    console.log('🔍 DEBUG BaseDomainComponent ngOnInit:', {
      domain: this.domainConfig.domain,
      filterConfig: this.domainConfig.filterConfig,
      fieldsSearchDefault: this.domainConfig.filterConfig?.fieldsSearchDefault,
      hasFieldsSearchDefault: Boolean(this.domainConfig.filterConfig?.fieldsSearchDefault),
      defaultFilters: this.domainConfig.filterConfig?.defaultFilters
    });
    
    // ✅ NOVO: Aplicar defaultFilters diretamente no BaseDomainComponent
    this.applyDefaultFiltersDirectly();
    
    this.setupDomain();
    this._isInitialized = true;
  }



  ngOnDestroy() {
    this.subscriptions.unsubscribe();
    try {
      this.headerActionsService.clearConfig();
    } catch (error) {
      console.error('Erro ao limpar header:', error);
    }
  }

  // ========================================
  // 🎯 MÉTODOS ABSTRATOS (implementar nos domínios)
  // ========================================

  /**
   * Deve retornar a configuração específica do domínio
   */
  protected abstract getDomainConfig(): DomainConfig;

  /**
   * Pode ser sobrescrito para customizar criação de nova entidade
   */
  protected getNewEntityData(): Partial<T> {
    return {};
  }

  // ========================================
  // 🏗️ SETUP E CONFIGURAÇÃO
  // ========================================

  private setupDomain(): void {
    if (this._setupDomainCalled) {
      console.warn('[BaseDomainComponent] setupDomain já foi executado, evitando duplicação');
      return;
    }
    
    this._setupDomainCalled = true;
    
    // Setup título
    this.titleService.setTitle(this.domainConfig.title);
    
    // Setup configurações
    this.itemsPerPage = this.domainConfig.pageSize || 50;
    this.tabConfig.maxTabs = this.domainConfig.maxTabs || 5;
    this.tabConfig.allowDuplicates = this.domainConfig.allowDuplicates || false;
    
    // Setup tabela
    this.setupTableConfig();
    
    // Setup header actions
    this.configureHeaderActions();
    
    // Carregar dados
    this.loadEntities();
  }

  private setupTableConfig(): void {
    this.tableConfig = {
      columns: this.domainConfig.columns,
      pageSize: this.itemsPerPage,
      pageSizeOptions: [10, 25, 50],
      showFirstLastButtons: true,
      actions: [
        {
          icon: "fas fa-edit",
          label: "Editar",
          action: "edit"
        },
        ...(this.domainConfig.customActions || [])
      ]
    };
  }

  // ========================================
  // 🔄 CRUD OPERATIONS (GENÉRICAS)
  // ========================================

  loadEntities(currentPage = this.currentPage, itemsPerPage = this.itemsPerPage) {
    const now = Date.now();
    
    // 🛡️ PROTEÇÃO CONTRA LOOP: Não carregar se já está carregando ou se a última chamada foi muito recente
    if (this.isLoading || this._isLoadingEntities) {
      console.warn('[BaseDomainComponent] Tentativa de carregamento rejeitada - já está carregando');
      return;
    }
    
    // Proteção contra chamadas muito frequentes (75ms - tempo moderado entre responsividade e proteção)
    if (now - this._lastLoadTime < 75) {
      console.warn('[BaseDomainComponent] Tentativa de carregamento rejeitada - chamada muito frequente (tempo desde última:', now - this._lastLoadTime, 'ms)');
      return;
    }
    
    this._lastLoadTime = now;
    this.isLoading = true;
    this._isLoadingEntities = true;
    
    // ✅ Atualizar interface imediatamente para mostrar loading
    this.updateListTabData();
    this.cdr.detectChanges();
    
    this.entityService
      .getEntities(currentPage, itemsPerPage, this.currentFilters)
      .subscribe({
        next: (response) => {
          this.entities = response.data;
          this.totalItems = response.totalCount;
          this.totalPages = response.pageCount;
          this.currentPage = response.currentPage;
          this.isLoading = false;
          this._isLoadingEntities = false;

          this.headerActionsService.updateRecordCount(this.totalItems);
          
          // 🔧 OTIMIZAÇÃO: Criar abas apenas UMA VEZ, não em loop
          if (this.tabSystem && this.tabSystem.getTabs().length === 0) {
            this.createInitialTabs();
          } else if (this.tabSystem) {
            this.updateTabsData();
          }
          
          // Forçar detecção de mudanças de forma controlada
          this.cdr.detectChanges();
        },
        error: (error) => {
          console.error("Erro ao carregar entidades:", error);
          this.isLoading = false;
          this._isLoadingEntities = false;
        },
      });
  }

  async createNew(): Promise<void> {
    await this.tabSystem.tabSystemService.openCreateTab(
      this.domainConfig.domain, 
      this.getNewEntityData()
    );
  }

  async editEntity(entityData: any): Promise<void> {
    const success = await this.tabSystem.tabSystemService.openTabWithSubTabs(
      this.domainConfig.domain, 
      entityData, 
      this.domainConfig.subTabs,
      undefined, // customTitle
      this.domainConfig.sideCard // ✨ Passar configuração do side card
    );
    
    if (!success) {
      console.error('Falha ao abrir aba de edição');
    }
  }

  // ========================================
  // 📊 TABLE EVENTS (GENÉRICOS)
  // ========================================

  onSort(event: { field: string; direction: "asc" | "desc" }) {
    const { field, direction } = event;
    this.entities = [...this.entities].sort((a: any, b: any) => {
      const isAsc = direction === "asc";
      return this.compare(a[field], b[field], isAsc);
    });
  }

  onPage(event: { page: number; pageSize: number }) {
    const maxPage = Math.ceil(this.totalItems / event.pageSize);
    const validPage = Math.min(event.page, maxPage);
    
    // Condições mais claras para debugging
    const pageChanged = this.currentPage !== validPage;
    const pageSizeChanged = this.itemsPerPage !== event.pageSize;
    const shouldLoad = pageChanged || pageSizeChanged;

    if (shouldLoad) {
      // Atualizar o estado antes de carregar para evitar condições de corrida
      this.currentPage = validPage;
      this.itemsPerPage = event.pageSize;
      
      this.loadEntities(validPage, event.pageSize);
    }
  }

  onFilter(filters: { [key: string]: string }) {
    // Verificar se realmente houve mudança nos filtros
    const filtersChanged = JSON.stringify(this.currentFilters) !== JSON.stringify(filters);
    
    this.currentFilters = filters;
    
    // ✅ Só resetar para página 1 se realmente houve mudança de filtros
    if (filtersChanged) {
      this.currentPage = 1;
    }
    
    this.loadEntities();
  }

  onColumnsChange(columns: any[]) {
    this.tableConfig = { ...this.tableConfig, columns };
  }

  onActionClick(event: { action: string; data: any }) {
    switch (event.action) {
      case "new":
        this.createNew();
        break;
      case "edit":
        this.editEntity(event.data);
        break;
      default:
        this.handleCustomAction(event.action, event.data);
        break;
    }
  }

  /**
   * ✅ NOVO: Aplica defaultFilters diretamente no BaseDomainComponent
   */
  private applyDefaultFiltersDirectly(): void {
    const defaultFilters = this.domainConfig.filterConfig?.defaultFilters || [];
    
    if (defaultFilters.length === 0) {
      console.log('🔍 [DEBUG] Nenhum defaultFilter configurado');
      return;
    }
    
    console.log('🔍 [DEBUG] Aplicando defaultFilters diretamente no BaseDomainComponent:', defaultFilters);
    
    // Usar o método helper para converter defaultFilters
    const convertedFilters = this.getDefaultFiltersAsCurrentFilters();
    
    // Aplicar os filtros convertidos
    this.currentFilters = { ...convertedFilters };
    
    console.log('🔍 [DEBUG] currentFilters após aplicar defaultFilters:', { ...this.currentFilters });
    console.log(`✅ [DEBUG] ${Object.keys(convertedFilters).length} defaultFilters aplicados`);
  }

  /**
   * ✅ NOVO: Converte defaultFilters para o formato currentFilters
   */
  private getDefaultFiltersAsCurrentFilters(): { [key: string]: string } {
    const defaultFilters = this.domainConfig.filterConfig?.defaultFilters || [];
    const convertedFilters: { [key: string]: string } = {};
    
    defaultFilters.forEach((filter: DefaultFilter) => {
      let value = filter.value;
      
      // Converter array para string separada por vírgula (para operador 'in')
      if (Array.isArray(value)) {
        value = value.join(',');
      }
      
      convertedFilters[filter.field] = value;
    });
    
    return convertedFilters;
  }

  /**
   * ✨ NOVO: Manipula mudanças nos filtros avançados
   */
  onAdvancedFiltersChanged(filters: any): void {
    console.log('🔍 [DEBUG] BaseDomainComponent.onAdvancedFiltersChanged called with:', {
      filters,
      filtersType: typeof filters,
      filtersKeys: filters ? Object.keys(filters) : 'no filters',
      currentFilters: { ...this.currentFilters }
    });
    
    // ✅ NOVO: Mesclar filtros manuais com defaultFilters para manter ambos ativos
    const defaultFilters = this.getDefaultFiltersAsCurrentFilters();
    const mergedFilters = { ...defaultFilters, ...filters };
    
    this.currentFilters = mergedFilters;
    
    console.log('🔍 [DEBUG] Updated currentFilters (com defaultFilters):', { ...this.currentFilters });
    
    // Recarregar dados com novos filtros
    this.currentPage = 1; // Voltar para primeira página
    console.log('🔍 [DEBUG] Calling loadEntities with:', {
      currentPage: this.currentPage,
      itemsPerPage: this.itemsPerPage,
      currentFilters: { ...this.currentFilters }
    });
    
    this.loadEntities(this.currentPage, this.itemsPerPage);
  }

  /**
   * ✨ NOVO: Manipula mudanças na seleção de linhas
   */
  onRowSelectionChanged(selectedRows: T[]): void {
    this.selectedRows = selectedRows;
    console.log(`🎯 ${selectedRows.length} ${this.domainConfig.entityName}(s) selecionado(s):`, selectedRows);
  }

  onTableEvent(eventData: { event: string, data: any }): void {
    const { event, data } = eventData;
    
    switch (event) {
      case 'sort':
        this.onSort(data);
        break;
      case 'page':
        this.onPage(data);
        break;
      case 'filter':
        this.onFilter(data);
        break;
      case 'columnsChange':
        this.onColumnsChange(data);
        break;
      case 'actionClick':
        this.onActionClick(data);
        break;
      case 'formSubmit':
        this.onFormSubmit(data);
        break;
      case 'advancedFiltersChanged': // ✨ NOVO: Filtros avançados
        this.onAdvancedFiltersChanged(data);
        break;
      case 'rowSelectionChanged': // ✨ NOVO: Seleção de linhas
        this.onRowSelectionChanged(data);
        break;
    }
  }

  // ========================================
  // 🎯 TAB SYSTEM EVENTS (GENÉRICOS)
  // ========================================

  onTabSelected(tab: TabItem): void {
    console.log('Aba selecionada:', tab?.title);
  }

  onTabClosed(tab: TabItem): void {
    console.log('Aba fechada:', tab?.title);
  }

  onTabAdded(tab: TabItem): void {
    console.log('Aba adicionada:', tab?.title);
  }

  // ========================================
  // 🏗️ HELPER METHODS (GENÉRICOS)
  // ========================================

  // ========================================
  // 📊 DASHBOARD TAB (NOVO)
  // ========================================

  private async createDashboardTab(): Promise<void> {
    const dashboardType = `${this.domainConfig.domain}s-dashboard`;
    const dashboardTitle = this.domainConfig.dashboardConfig?.title || `Dashboard de ${this.domainConfig.title}`;
    
    // Verificar se há componente personalizado
    const hasCustomComponent = !!this.domainConfig.dashboardConfig?.customComponent;
    
    let tabData: any;
    
    if (hasCustomComponent) {
      // ✨ NOVO: Usar componente personalizado
      const customData = this.domainConfig.dashboardConfig?.customData || {};
      
      // Resolver dados dinâmicos (funções)
      const resolvedData: any = {};
      for (const [key, value] of Object.entries(customData)) {
        resolvedData[key] = typeof value === 'function' ? value() : value;
      }
      
      tabData = {
        domainConfig: this.domainConfig,
        dashboardConfig: this.domainConfig.dashboardConfig,
        customComponent: this.domainConfig.dashboardConfig?.customComponent,
        customData: resolvedData,
        // Dados padrão para componente personalizado
        entities: this.entities,
        totalItems: this.totalItems,
        isLoading: this.isLoading
      };
    } else {
      // Usar dashboard padrão
      const autoKPIs = this.generateAutomaticKPIs();
      const allKPIs = [
        ...autoKPIs,
        ...(this.domainConfig.dashboardConfig?.customKPIs || [])
      ];

      tabData = {
        domainConfig: this.domainConfig,
        dashboardConfig: this.domainConfig.dashboardConfig,
        kpis: allKPIs,
        charts: this.domainConfig.dashboardConfig?.customCharts || [],
        recentItems: this.entities.slice(0, 5),
        totalItems: this.totalItems,
        isLoading: this.isLoading
      };
    }

    const dashboardTab: TabItem = {
      id: dashboardType,
      title: dashboardTitle,
      type: dashboardType,
      data: tabData,
      isLoading: false,
      isModified: false
    };
    
    await this.tabSystem.addTab(dashboardTab);
  }

  private generateAutomaticKPIs(): DashboardKPI[] {
    const kpis: DashboardKPI[] = [];

    // KPI 1: Total de registros
    kpis.push({
      id: 'total-items',
      label: `Total de ${this.domainConfig.title}`,
      value: this.totalItems,
      icon: 'fas fa-list',
      color: 'primary'
    });

    // KPI 2: Registros ativos (se houver campo status)
    const activeItems = this.entities.filter((item: any) => 
      item.status === 'Ativo' || item.status === 'active' || item.status === 'Active'
    ).length;
    
    if (activeItems > 0) {
      kpis.push({
        id: 'active-items',
        label: `${this.domainConfig.title} Ativos`,
        value: activeItems,
        icon: 'fas fa-check-circle',
        color: 'success',
        trend: 'stable'
      });
    }

    // KPI 3: Registros recentes (últimos 7 dias)
    const recentItems = this.entities.filter((item: any) => {
      if (!item.created_at) return false;
      const createdDate = new Date(item.created_at);
      const sevenDaysAgo = new Date();
      sevenDaysAgo.setDate(sevenDaysAgo.getDate() - 7);
      return createdDate >= sevenDaysAgo;
    }).length;

    if (recentItems > 0) {
      kpis.push({
        id: 'recent-items',
        label: 'Novos (7 dias)',
        value: recentItems,
        icon: 'fas fa-plus-circle',
        color: 'info',
        trend: 'up'
      });
    }

    return kpis;
  }

  private async createListTab(): Promise<void> {
    const listType = `${this.domainConfig.domain}s-list`;
    const listTitle = `Lista de ${this.domainConfig.title}`;
    
    const tabData = {
      items: this.entities,
      [this.domainConfig.domain + 's']: this.entities, // Backward compatibility
      totalItems: this.totalItems,
      currentPage: this.currentPage,
      totalPages: this.totalPages,
      tableConfig: this.tableConfig,
      domainConfig: this.domainConfig,
      bulkActions: this.domainConfig.bulkActions || [],
      isLoading: this.isLoading
    };

    const listTab: TabItem = {
      id: listType,
      title: listTitle,
      type: listType,
      data: tabData,
      isLoading: false,
      isModified: false
    };
    
    await this.tabSystem.addTab(listTab);
  }

  // ========================================
  // 🎯 MÉTODOS DE GERENCIAMENTO DE ABAS (NOVO)
  // ========================================

  private async createInitialTabs(): Promise<void> {
    // 1. Criar aba Dashboard (se habilitada)
    if (this.domainConfig.showDashboardTab) {
      await this.createDashboardTab();
    }
    
    // 2. Criar aba Lista (sempre)
    await this.createListTab();
  }

  private updateTabsData(): void {
    // Atualizar aba Dashboard (se existir)
    if (this.domainConfig.showDashboardTab) {
      this.updateDashboardTabData();
    }
    
    // Atualizar aba Lista (sempre)
    this.updateListTabData();
  }

  private updateDashboardTabData(): void {
    if (!this.tabSystem) return;

    const dashboardType = `${this.domainConfig.domain}s-dashboard`;
    const dashboardTabIndex = this.tabSystem.getTabs().findIndex(tab => tab.type === dashboardType);
    
    if (dashboardTabIndex >= 0) {
      // Regenerar KPIs com dados atualizados
      const autoKPIs = this.generateAutomaticKPIs();
      const allKPIs = [
        ...autoKPIs,
        ...(this.domainConfig.dashboardConfig?.customKPIs || [])
      ];

      const updatedData = {
        domainConfig: this.domainConfig,
        dashboardConfig: this.domainConfig.dashboardConfig,
        kpis: allKPIs,
        charts: this.domainConfig.dashboardConfig?.customCharts || [],
        recentItems: this.entities.slice(0, 5),
        totalItems: this.totalItems,
        isLoading: this.isLoading
      };
      
      this.tabSystem.tabSystemService.updateTab(dashboardTabIndex, updatedData);
      this.cdr.detectChanges();
    }
  }

  protected updateListTabData(): void {
    if (!this.tabSystem) return;

    const listType = `${this.domainConfig.domain}s-list`;
    const listTabIndex = this.tabSystem.getTabs().findIndex(tab => tab.type === listType);
    
    if (listTabIndex >= 0) {
      // ✅ CORREÇÃO: Verificar se estamos atualizando a aba atualmente ativa
      const currentSelectedIndex = this.tabSystem.getCurrentSelectedIndex();
      const isUpdatingActiveTab = listTabIndex === currentSelectedIndex;
      
      // ✅ CORREÇÃO CRÍTICA: Só atualizar se estivermos na aba da lista
      // Isso evita que sub-abas recebam atualizações desnecessárias que causam ngOnChanges
      if (!isUpdatingActiveTab) {
        console.log('🚫 Paginação ignorada - não estamos na aba da lista:', {
          listTabIndex,
          currentSelectedIndex,
          currentPage: this.currentPage
        });
        return;
      }
      
      const updatedData = {
        items: this.entities,
        [this.domainConfig.domain + 's']: this.entities,
        totalItems: this.totalItems,
        currentPage: this.currentPage,
        totalPages: this.totalPages,
        tableConfig: this.tableConfig,
        domainConfig: this.domainConfig,
        bulkActions: this.domainConfig.bulkActions || [],
        isLoading: this.isLoading
      };
      
      // 🐛 DEBUG: Verificar se domainConfig está sendo passado corretamente para o data-table
      console.log('🔍 DEBUG updateListTabData - domainConfig sendo passado:', {
        domain: this.domainConfig.domain,
        filterConfig: this.domainConfig.filterConfig,
        fieldsSearchDefault: this.domainConfig.filterConfig?.fieldsSearchDefault,
        updatedDataDomainConfig: updatedData.domainConfig?.filterConfig?.fieldsSearchDefault
      });
      
      // ✅ Atualizar dados da aba da lista
      this.tabSystem.tabSystemService.updateTab(listTabIndex, updatedData);
      this.cdr.detectChanges();
      
      console.log('🔄 Lista atualizada na aba ativa:', {
        listTabIndex,
        currentSelectedIndex,
        currentPage: this.currentPage
      });
    }
  }

  protected configureHeaderActions(): void {
    this.headerActionsService.setDomainConfig({
      domain: this.domainConfig.domain,
      title: this.domainConfig.title,
      recordCount: this.totalItems,
      actions: [
        {
          id: `new-${this.domainConfig.domain}`,
          label: `Novo ${this.domainConfig.entityName}`,
          icon: 'add',
          type: 'primary',
          action: () => this.createNew(),
          visible: true,
          tooltip: `Criar novo ${this.domainConfig.entityName}`
        }
      ]
    });
  }

  /**
   * 🚀 GENÉRICO: Lidar com salvamento de formulários
   */
  protected onFormSubmit(data: any): void {
    const { tab, formData, isNewItem, onSuccess, onError } = data;
    
    console.log(`${isNewItem ? 'Criando' : 'Atualizando'} ${this.domainConfig.entityName}...`);
    
    // Determinar qual método do service usar
    const saveOperation = isNewItem 
      ? this.createEntity(formData)
      : this.updateEntity(tab.data.id, formData);
    
    if (saveOperation) {
      saveOperation.subscribe({
        next: (response: any) => {
          console.log(`✅ ${this.domainConfig.entityName} salvo com sucesso:`, response);
          
          // 🎯 NOVO: Atualizar lista automaticamente após salvar
          this.updateListAfterSave(response, isNewItem);
          
          onSuccess(response);
        },
        error: (error: any) => {
          console.error(`❌ Erro ao salvar ${this.domainConfig.entityName}:`, error);
          console.log('🔍 [DEBUG] BaseDomainComponent - Chamando onError callback');
          onError(error);
        }
      });
    } else {
      // Fallback se não há service específico
      this.simulateSave(formData, isNewItem, tab, onSuccess, onError);
    }
  }

  /**
   * 🎯 NOVO: Atualiza a lista automaticamente após salvar
   * - Para CRIAÇÃO: Adiciona o novo item à lista
   * - Para EDIÇÃO: Atualiza o item existente na lista
   * - Atualiza contadores e interface
   */
  private updateListAfterSave(savedEntity: any, isNewItem: boolean): void {
    console.log('🎯 updateListAfterSave chamado:', { savedEntity, isNewItem });
    
    if (isNewItem) {
      // ✅ CRIAÇÃO: Adicionar novo item à lista (no início para melhor UX)
      this.entities = [savedEntity, ...this.entities];
      this.totalItems += 1;
      
      // Recalcular páginas se necessário
      this.totalPages = Math.ceil(this.totalItems / this.itemsPerPage);
      
      console.log(`✅ Novo ${this.domainConfig.entityName} adicionado à lista:`, savedEntity);
      
    } else {
      // ✅ EDIÇÃO: Atualizar item existente na lista
      // Extrair ID da resposta (pode estar em savedEntity.id ou savedEntity.data.id)
      const savedEntityId = savedEntity?.id || savedEntity?.data?.id;
      
      console.log('🔍 Procurando item na lista com ID:', savedEntityId);
      
      const index = this.entities.findIndex((entity: any) => entity.id === savedEntityId);
      
      if (index >= 0) {
        // Manter dados existentes e sobrescrever com os novos
        // Se savedEntity tem uma estrutura aninhada (.data), usar essa estrutura
        const updatedData = savedEntity?.data || savedEntity;
        this.entities[index] = { ...this.entities[index], ...updatedData }; 
        
        console.log(`✅ ${this.domainConfig.entityName} atualizado na lista:`, {
          index,
          oldData: this.entities[index],
          newData: updatedData
        });
      } else {
        console.warn(`⚠️ Item com ID ${savedEntityId} não encontrado na lista para atualização`);
        console.log('📋 IDs disponíveis na lista:', this.entities.map((e: any) => e.id));
        
        // Fallback: adicionar à lista mesmo sendo edição (pode ter sido criado em outra sessão)
        const entityToAdd = savedEntity?.data || savedEntity;
        this.entities = [entityToAdd, ...this.entities];
        this.totalItems += 1;
        this.totalPages = Math.ceil(this.totalItems / this.itemsPerPage);
      }
    }
    
    // 🔄 Atualizar interface automaticamente
    this.updateListTabData();
    this.headerActionsService.updateRecordCount(this.totalItems);
    this.cdr.detectChanges();
    
    console.log('✅ Lista atualizada com sucesso');
  }

  /**
   * Método para criar entidade - deve ser sobrescrito nos domínios se necessário
   */
  protected createEntity(data: any): Observable<any> | null {
    // Por padrão, tentar chamar um método genérico se existir
    const service = this.entityService as any;
    if (service.create) {
      return service.create(data);
    }
    return null;
  }

  /**
   * Método para atualizar entidade - deve ser sobrescrito nos domínios se necessário
   */
  protected updateEntity(id: any, data: any): Observable<any> | null {
    // Por padrão, tentar chamar um método genérico se existir
    const service = this.entityService as any;
    if (service.update) {
      return service.update(id, data);
    }
    return null;
  }

  /**
   * Simular salvamento quando não há service específico
   */
  private simulateSave(formData: any, isNewItem: boolean, tab: any, onSuccess: Function, onError: Function): void {
    console.warn(`${this.domainConfig.entityName}Service não disponível, simulando salvamento...`);
    
    setTimeout(() => {
      try {
        // 🎯 MELHORADO: Criar resposta mais completa para atualização do formulário
        const response = {
          success: true,
          ...formData, // Incluir todos os dados do formulário
          id: isNewItem ? Math.random().toString(36).substr(2, 9) : tab.data.id,
          updated_at: new Date().toISOString(),
          // Adicionar campos que podem ter sido processados pelo backend
          created_at: isNewItem ? new Date().toISOString() : tab.data.created_at
        };

        console.log(`✅ ${this.domainConfig.entityName} salvo com sucesso (simulado):`, response);
        
        // 🎯 USAR A MESMA LÓGICA: Atualizar lista automaticamente
        this.updateListAfterSave(response, isNewItem);
        
        onSuccess(response);
        
      } catch (error) {
        console.error(`❌ Erro ao salvar ${this.domainConfig.entityName}:`, error);
        onError(error);
      }
    }, 1500);
  }

  /**
   * Método para ações customizadas - pode ser sobrescrito nos domínios
   */
  protected handleCustomAction(action: string, data: any): void {
    console.warn(`Ação customizada não implementada: ${action}`, data);
  }

  private compare(a: number | string, b: number | string, isAsc: boolean) {
    return (a < b ? -1 : 1) * (isAsc ? 1 : -1);
  }
} 