import { Injectable } from '@angular/core';
import { BehaviorSubject, Observable } from 'rxjs';
import { UpdateChangelog, SplashConfig, ChangelogItem } from '../../interfaces/update-changelog.interface';

@Injectable({
  providedIn: 'root'
})
export class UpdateChangelogService {
  private readonly VERSION_STORAGE_KEY = 'idt_app_version';
  private readonly SPLASH_SHOWN_KEY = 'idt_app_splash_shown';
  
  private showSplashSubject = new BehaviorSubject<boolean>(false);
  private currentChangelogSubject = new BehaviorSubject<UpdateChangelog | null>(null);

  public showSplash$ = this.showSplashSubject.asObservable();
  public currentChangelog$ = this.currentChangelogSubject.asObservable();

  // Configuração padrão do splash
  private splashConfig: SplashConfig = {
    showOnUpdate: true,
    showOnFirstInstall: true,
    showOnVersionChange: true,
    autoCloseDelay: 0, // Manual close
    theme: 'auto'
  };

  // Versão atual da aplicação (deve ser atualizada a cada release)
  private readonly CURRENT_VERSION = '1.2.0';

  constructor() {
    this.initializeVersionTracking();
  }

  /**
   * Inicializa o tracking de versão e verifica se deve mostrar splash
   */
  private initializeVersionTracking(): void {
    const lastVersion = this.getStoredVersion();
    const isNewInstall = !lastVersion;
    const isVersionChange = lastVersion !== null && lastVersion !== this.CURRENT_VERSION;
    const shouldShowAfterPWAUpdate = this.checkPWAUpdateFlag();

    console.log('🔄 Version tracking:', {
      current: this.CURRENT_VERSION,
      stored: lastVersion,
      isNewInstall,
      isVersionChange,
      shouldShowAfterPWAUpdate
    });

    // Verifica se deve mostrar splash
    if (this.shouldShowSplash(isNewInstall, isVersionChange) || shouldShowAfterPWAUpdate) {
      const changelog = this.getCurrentChangelog();
      if (changelog) {
        this.showChangelogSplash(changelog);
      }
    }

    // Atualiza versão armazenada
    this.storeCurrentVersion();
    
    // Limpa flag de PWA update se existir
    this.clearPWAUpdateFlag();
  }

  /**
   * Verifica se deve mostrar splash baseado na configuração
   */
  private shouldShowSplash(isNewInstall: boolean, isVersionChange: boolean): boolean {
    if (isNewInstall && this.splashConfig.showOnFirstInstall) {
      return true;
    }

    if (isVersionChange && this.splashConfig.showOnVersionChange) {
      return !this.wasSplashShownForVersion(this.CURRENT_VERSION);
    }

    return false;
  }

  /**
   * Obtém changelog da versão atual
   */
  private getCurrentChangelog(): UpdateChangelog | null {
    // Em produção, isso viria de uma API ou arquivo de configuração
    // Por agora, retorna dados mock baseados na versão atual
    return this.getChangelogForVersion(this.CURRENT_VERSION);
  }

  /**
   * Retorna changelog para uma versão específica
   */
  private getChangelogForVersion(version: string): UpdateChangelog | null {
    const changelogs: Record<string, UpdateChangelog> = {
      '1.2.0': {
        version: '1.2.0',
        releaseDate: new Date('2025-06-03'),
        title: 'PWA e Mobile Otimizado! 🚀',
        description: 'Esta atualização traz uma experiência completamente nativa com funcionalidades PWA avançadas.',
        isImportant: true,
        showSplash: true,
        highlights: [
          {
            type: 'feature',
            title: 'Instalação PWA',
            description: 'Instale o app na tela inicial como um aplicativo nativo',
            icon: 'install_mobile'
          },
          {
            type: 'feature',
            title: 'Updates Automáticos',
            description: 'Receba notificações quando novas versões estiverem disponíveis',
            icon: 'system_update'
          },
          {
            type: 'improvement',
            title: 'Zoom Prevention',
            description: 'Experiência mobile nativa sem zoom indesejado',
            icon: 'touch_app'
          },
          {
            type: 'improvement',
            title: 'Performance Mobile',
            description: 'Interface otimizada para dispositivos móveis',
            icon: 'speed'
          },
          {
            type: 'feature',
            title: 'Offline Ready',
            description: 'Funcionalidades básicas disponíveis offline',
            icon: 'offline_bolt'
          }
        ]
      },
      '2.1.0': {
        version: '2.1.0',
        releaseDate: new Date('2025-06-03'),
        title: 'Sistema de Abas Avançado',
        description: 'Novo sistema de abas para edição múltipla de registros.',
        isImportant: false,
        showSplash: true,
        highlights: [
          {
            type: 'feature',
            title: 'Tab System',
            description: 'Edite múltiplos registros simultaneamente',
            icon: 'tab'
          },
          {
            type: 'improvement',
            title: 'Data Tables',
            description: 'Tabelas responsivas com melhor UX mobile',
            icon: 'table_view'
          }
        ]
      }
    };

    return changelogs[version] || null;
  }

  /**
   * Mostra splash screen com changelog
   */
  public showChangelogSplash(changelog: UpdateChangelog): void {
    this.currentChangelogSubject.next(changelog);
    this.showSplashSubject.next(true);
    
    console.log('📱 Showing changelog splash:', changelog.version);

    // Auto-close se configurado
    if (this.splashConfig.autoCloseDelay && this.splashConfig.autoCloseDelay > 0) {
      setTimeout(() => {
        this.closeSplash();
      }, this.splashConfig.autoCloseDelay);
    }
  }

  /**
   * Fecha splash screen
   */
  public closeSplash(): void {
    const currentChangelog = this.currentChangelogSubject.value;
    if (currentChangelog) {
      this.markSplashAsShown(currentChangelog.version);
    }
    
    this.showSplashSubject.next(false);
    this.currentChangelogSubject.next(null);
    
    console.log('❌ Splash closed');
  }

  /**
   * Força exibição do splash (para debug/demo)
   */
  public showCurrentVersionSplash(): void {
    const changelog = this.getCurrentChangelog();
    if (changelog) {
      this.showChangelogSplash(changelog);
    }
  }

  /**
   * Storage helpers
   */
  private getStoredVersion(): string | null {
    return localStorage.getItem(this.VERSION_STORAGE_KEY);
  }

  private storeCurrentVersion(): void {
    localStorage.setItem(this.VERSION_STORAGE_KEY, this.CURRENT_VERSION);
  }

  private wasSplashShownForVersion(version: string): boolean {
    const shownVersions = this.getShownSplashVersions();
    return shownVersions.includes(version);
  }

  private markSplashAsShown(version: string): void {
    const shownVersions = this.getShownSplashVersions();
    if (!shownVersions.includes(version)) {
      shownVersions.push(version);
      localStorage.setItem(this.SPLASH_SHOWN_KEY, JSON.stringify(shownVersions));
    }
  }

  private getShownSplashVersions(): string[] {
    const stored = localStorage.getItem(this.SPLASH_SHOWN_KEY);
    return stored ? JSON.parse(stored) : [];
  }

  /**
   * Configuração do splash
   */
  public updateSplashConfig(config: Partial<SplashConfig>): void {
    this.splashConfig = { ...this.splashConfig, ...config };
  }

  public getSplashConfig(): SplashConfig {
    return { ...this.splashConfig };
  }

  /**
   * Utilities públicas
   */
  public getCurrentVersion(): string {
    return this.CURRENT_VERSION;
  }

  public getChangelogHistory(): UpdateChangelog[] {
    // Retorna histórico de changelogs
    return ['1.2.0', '1.1.0']
      .map(v => this.getChangelogForVersion(v))
      .filter(c => c !== null) as UpdateChangelog[];
  }

  /**
   * Debug helpers
   */
  public clearVersionHistory(): void {
    localStorage.removeItem(this.VERSION_STORAGE_KEY);
    localStorage.removeItem(this.SPLASH_SHOWN_KEY);
    console.log('🗑️ Version history cleared');
  }

  public simulateUpdate(version: string): void {
    localStorage.setItem(this.VERSION_STORAGE_KEY, '1.0.0'); // Simula versão anterior
    const changelog = this.getChangelogForVersion(version);
    if (changelog) {
      this.showChangelogSplash(changelog);
    }
  }

  /**
   * Verifica se existe flag para mostrar splash após update PWA
   */
  private checkPWAUpdateFlag(): boolean {
    return localStorage.getItem('idt_show_update_splash') === 'true';
  }

  /**
   * Limpa flag de update PWA
   */
  private clearPWAUpdateFlag(): void {
    localStorage.removeItem('idt_show_update_splash');
  }
} 