// Scene.js
// 场景类，用于管理场景的生命周期和元素

class Scene {
  constructor(engine, path, config) {
    this.engine = engine;
    this.path = path;
    this.config = config;
    this.data = {};
    this.methods = {};
    this.elements = new Map();
    this.container = null;
    this.module = null;
  }

  /**
   * 初始化场景
   */
  async init() {
    // 创建场景容器
    this.container = document.createElement('div');
    this.container.style.position = 'absolute';
    this.container.style.top = '0';
    this.container.style.left = '0';
    this.container.style.width = '100%';
    this.container.style.height = '100%';
    this.container.style.display = 'none';
    
    // 添加到引擎舞台
    this.engine.stage.appendChild(this.container);
    
    // 加载场景模块
    await this.loadModule();
  }

  /**
   * 加载场景模块
   */
  async loadModule() {
    try {
      // 加载样式文件
      const cssPath = `../example/sence${this.path}/index.less`;
      const link = document.createElement('link');
      link.rel = 'stylesheet';
      link.href = cssPath;
      document.head.appendChild(link);
      
      // 加载场景逻辑文件
      this.module = await import(/* @vite-ignore */ `../example/sence${this.path}/index.js`);
      
      // 初始化数据
      if (this.module.default && typeof this.module.default.data === 'function') {
        this.data = this.module.default.data();
      }
      
      // 初始化方法
      if (this.module.default && this.module.default.methods) {
        this.methods = this.module.default.methods;
      }
      
      // 解析模板
      if (this.module.default && this.module.default.template) {
        this.parseTemplate(this.module.default.template);
      }
    } catch (error) {
      console.error(`Failed to load scene module for path: ${this.path}`, error);
    }
  }

  /**
   * 解析场景模板
   * @param {string} template - 模板字符串
   */
  parseTemplate(template) {
    // 创建临时容器来解析模板
    const tempContainer = document.createElement('div');
    tempContainer.innerHTML = template.trim();
    
    // 遍历所有元素
    const elements = tempContainer.children;
    for (let i = 0; i < elements.length; i++) {
      const element = elements[i];
      const tagName = element.tagName.toLowerCase();
      const className = element.className;
      const x = parseInt(element.getAttribute('x')) || 0;
      const y = parseInt(element.getAttribute('y')) || 0;
      const width = parseInt(element.getAttribute('width')) || 0;
      const height = parseInt(element.getAttribute('height')) || 0;
      const text = element.textContent || '';
      
      let peElement;
      
      // 根据标签名创建对应的PE元素
      switch (tagName) {
        case 'box':
          peElement = this.engine.create('box', { x, y, width, height });
          break;
        case 'text':
          peElement = this.engine.create('text', { text, x, y });
          break;
        default:
          // 默认创建box元素
          peElement = this.engine.create('box', { x, y, width, height });
      }
      
      // 添加CSS类
      if (className) {
        peElement.element.classList.add(className);
      }
      
      // 添加到场景
      this.addElement(className || `element_${i}`, peElement);
    }
  }

  /**
   * 添加元素到场景
   * @param {string} name - 元素名称
   * @param {BaseElement} element - 元素实例
   */
  addElement(name, element) {
    this.elements.set(name, element);
    if (this.container) {
      this.container.appendChild(element.element || element);
    }
  }

  /**
   * 从场景移除元素
   * @param {string} name - 元素名称
   */
  removeElement(name) {
    const element = this.elements.get(name);
    if (element && this.container) {
      this.container.removeChild(element.element || element);
      this.elements.delete(name);
    }
  }

  /**
   * 获取元素
   * @param {string} name - 元素名称
   * @returns {BaseElement} 元素实例
   */
  getElement(name) {
    return this.elements.get(name);
  }

  /**
   * 显示场景
   */
  show() {
    if (this.container) {
      this.container.style.display = 'block';
    }
  }

  /**
   * 隐藏场景
   */
  hide() {
    if (this.container) {
      this.container.style.display = 'none';
    }
  }

  /**
   * 场景加载完成时调用
   */
  async mounted() {
    // 调用模块的mounted方法
    if (this.module && this.module.default && typeof this.module.default.mounted === 'function') {
      await this.module.default.mounted.call(this);
    }
  }

  /**
   * 场景显示时调用
   */
  async onShow() {
    // 调用模块的onShow方法（如果存在）
    if (this.module && this.module.default && typeof this.module.default.onShow === 'function') {
      await this.module.default.onShow.call(this);
    }
  }

  /**
   * 场景隐藏时调用
   */
  async onHide() {
    // 调用模块的onHide方法（如果存在）
    if (this.module && this.module.default && typeof this.module.default.onHide === 'function') {
      await this.module.default.onHide.call(this);
    }
  }

  /**
   * 销毁场景
   */
  destroy() {
    if (this.container && this.container.parentNode) {
      this.container.parentNode.removeChild(this.container);
    }
    this.elements.clear();
  }
}

export default Scene;