// Core system imports
import { PageManager } from './core/PageManager.js';
import { eventBus } from './core/EventBus.js';

// Component imports
import MicroModal from 'micromodal';
import { TabsComponent } from './components/tabs.js';
import { AccordionComponent } from './components/accordion.js';
import { ToastComponent } from './components/toast.js';

// Utils imports
import { ready } from './utils/dom.js';
import { performanceMonitor } from './utils/performance.js';

/**
 * Главный класс приложения с минимальной логикой
 */
class ViteKitApp {
  constructor() {
    this.pageManager = null;
    this.components = new Map();
    this.isInitialized = false;
    
    console.log('🚀 ViteKit Universal - Starting initialization...');
    performanceMonitor.mark('app-start');
  }

  /**
   * Инициализация приложения
   */
  async init() {
    if (this.isInitialized) return;

    try {
      performanceMonitor.mark('init-start');
      
      // Инициализация глобальных компонентов
      await this.initGlobalComponents();
      
      // Инициализация системы страниц
      await this.initPageSystem();
      
      // Инициализация UI компонентов
      await this.initUIComponents();
      
      // Финализация
      this.finalize();
      
      performanceMonitor.mark('init-end');
      performanceMonitor.measure('app-init', 'app-start', 'init-end');
      console.log('✅ ViteKit Universal - Ready!');
      
    } catch (error) {
      console.error('❌ ViteKit Universal - Initialization failed:', error);
    }
  }

  /**
   * Инициализация глобальных компонентов
   */
  async initGlobalComponents() {
    performanceMonitor.mark('global-components-start');
    
    // Инициализация MicroModal
    try {
      MicroModal.init({
        onShow: this.onModalShow.bind(this),
        onClose: this.onModalClose.bind(this),
        awaitOpenAnimation: true,
        awaitCloseAnimation: true,
        debugMode: false
      });
      console.log('✅ MicroModal initialized');
    } catch (error) {
      console.error('❌ MicroModal initialization failed:', error);
    }
    
    performanceMonitor.measure('global-components', 'global-components-start');
  }

  /**
   * Инициализация системы страниц
   */
  async initPageSystem() {
    performanceMonitor.mark('page-system-start');
    
    try {
      this.pageManager = new PageManager();
      console.log('✅ Page system initialized');
    } catch (error) {
      console.error('❌ Page system initialization failed:', error);
    }
    
    performanceMonitor.measure('page-system', 'page-system-start');
  }

  /**
   * Инициализация UI компонентов
   */
  async initUIComponents() {
    performanceMonitor.mark('ui-components-start');
    
    // Автоматическая инициализация табов
    const tabsElements = document.querySelectorAll('[data-tabs]');
    tabsElements.forEach(element => {
      try {
        const tabs = new TabsComponent(element);
        this.components.set(element, tabs);
        eventBus.emit('component:init', { component: tabs });
      } catch (error) {
        console.error('❌ Tabs component initialization failed:', error);
      }
    });

    // Автоматическая инициализация аккордеонов
    const accordionElements = document.querySelectorAll('[data-accordion]');
    accordionElements.forEach(element => {
      try {
        const accordion = new AccordionComponent(element);
        this.components.set(element, accordion);
        eventBus.emit('component:init', { component: accordion });
      } catch (error) {
        console.error('❌ Accordion component initialization failed:', error);
      }
    });

    // Инициализация toast triggers
    this.initToastTriggers();

    console.log(`✅ UI Components initialized: ${this.components.size} instances`);
    performanceMonitor.measure('ui-components', 'ui-components-start');
  }

  /**
   * Инициализация toast triggers
   */
  initToastTriggers() {
    const toastTriggers = document.querySelectorAll('[data-toast-trigger]');
    toastTriggers.forEach(trigger => {
      trigger.addEventListener('click', (e) => {
        const type = trigger.dataset.toastTrigger;
        const title = trigger.dataset.toastTitle || 'Уведомление';
        const message = trigger.dataset.toastMessage || 'Сообщение';
        
        ToastComponent.show(message, type, { title });
        eventBus.emit('toast:show', { type, title, message });
      });
    });
  }

  /**
   * Обработчики событий модальных окон
   */
  onModalShow(modal) {
    console.log(`Modal ${modal.id} opened`);
    eventBus.emit('modal:open', { id: modal.id, modal });
  }

  onModalClose(modal) {
    console.log(`Modal ${modal.id} closed`);
    eventBus.emit('modal:close', { id: modal.id, modal });
  }

  /**
   * Финализация инициализации
   */
  finalize() {
    this.isInitialized = true;
    
    // Уведомляем систему о готовности
    eventBus.emit('app:ready', { 
      pageManager: this.pageManager,
      componentsCount: this.components.size 
    });
    
    // Добавляем класс готовности к body
    document.body.classList.add('app-ready');
    
    // Показываем метрики производительности в dev режиме
    if (process.env.NODE_ENV === 'development') {
      setTimeout(() => {
        performanceMonitor.report();
      }, 100);
    }
  }

  /**
   * Публичные методы API
   */
  
  getComponent(element) {
    return this.components.get(element);
  }

  getPageController() {
    return this.pageManager?.getCurrentController();
  }

  async loadComponent(name, element, options = {}) {
    try {
      const module = await import(`./components/${name}.js`);
      const ComponentClass = module.default || module[`${name}Component`];
      
      if (ComponentClass) {
        const instance = new ComponentClass(element, options);
        this.components.set(element, instance);
        eventBus.emit('component:init', { component: instance });
        return instance;
      }
    } catch (error) {
      console.error(`Failed to load component: ${name}`, error);
      return null;
    }
  }

  getInfo() {
    return {
      isInitialized: this.isInitialized,
      componentsCount: this.components.size,
      currentPage: this.pageManager?.currentPage,
      hasPageController: !!this.pageManager?.currentController,
      performance: performanceMonitor.getAllMeasures()
    };
  }

  destroy() {
    // Очищаем компоненты
    this.components.forEach(component => {
      if (typeof component.destroy === 'function') {
        component.destroy();
      }
    });
    this.components.clear();

    // Очищаем page manager
    if (this.pageManager) {
      this.pageManager.cleanup();
    }

    // Очищаем event bus
    eventBus.clear();

    console.log('🧹 ViteKit Universal - Cleaned up');
  }
}

/**
 * Инициализация приложения при загрузке DOM
 */
let app;

ready(async () => {
  app = new ViteKitApp();
  await app.init();
});

// Экспортируем для глобального доступа
if (typeof window !== 'undefined') {
  window.ViteKit = {
    get app() { return app; },
    get pageManager() { return app?.pageManager; },
    get eventBus() { return eventBus; },
    ToastComponent,
    performanceMonitor
  };
}

// Экспорт для модульного использования
export default app;
export { eventBus, ToastComponent, performanceMonitor };