// SimplifiedEngine.js - 简化版引擎API
import Engine from './Engine.js';
import { SimplifiedSceneManager } from '../managers/SimplifiedSceneManager.js';

class SimplifiedEngine extends Engine {
  constructor(element = document.body, options = {}) {
    // 调用父类构造函数
    super(element, options);
    
    // 创建简化API的快捷方法
    this._createSimplifiedAPI();
  }
  
  /**
   * 创建简化API的快捷方法
   * 参考PixiJS、Egret和Vue 3的设计理念
   */
  _createSimplifiedAPI() {
    // 简化的元素创建API
    this.create = this._createElement.bind(this);
    
    // 简化的动画API
    this.animate = this._animate.bind(this);
    
    // 简化的场景管理API
    this.scene = new SimplifiedSceneManager(this);
    
    // 简化的资源管理API
    this.assets = {
      load: this._loadAsset.bind(this),
      get: this._getAsset.bind(this)
    };
    
    // 简化的事件系统API
    this.on = this._on.bind(this);
    this.off = this._off.bind(this);
    this.emit = this._emit.bind(this);
    
    // 简化的UI系统API
    this.ui = {
      create: this._createUI.bind(this)
    };
    
    // 简化的游戏对象API
    this.gameobject = {
      create: this._createGameObject.bind(this)
    };
    
    // 简化的摄像机API
    // 保留原始的camera对象，添加简化的方法
    this.camera.follow = this._follow.bind(this);
    this.camera.moveTo = this._moveCameraTo.bind(this);
    this.camera.zoom = this._zoomCamera.bind(this);
    this.camera.shake = this._shakeCamera.bind(this);
    
    // 简化的音频API
    this.sound = {
      play: this._playSound.bind(this),
      stop: this._stopSound.bind(this),
      load: this._loadSound.bind(this)
    };
    
    // 简化的粒子系统API
    this.particle = {
      create: this._createParticle.bind(this)
    };
  }
  
  /**
   * 简化的元素创建API
   * @param {string} type - 元素类型 ('sprite', 'box', 'text', 'html', 'svg')
   * @param {object} options - 元素选项
   * @returns {BaseElement} 创建的元素
   */
  _createElement(type, options = {}) {
    return this.create(type, options);
  }
  
  /**
   * 简化的动画API
   * @param {BaseElement} target - 动画目标
   * @param {object} props - 动画属性
   * @param {number} duration - 动画持续时间(毫秒)
   * @param {object} options - 动画选项
   * @returns {Tween} 动画对象
   */
  _animate(target, props, duration = 1000, options = {}) {
    const tween = this.tween(target, duration, options.easing || 'linear')
      .to(props);
      
    if (options.onUpdate) {
      tween.onUpdate(options.onUpdate);
    }
    
    if (options.onComplete) {
      tween.onComplete(options.onComplete);
    }
    
    if (options.delay) {
      tween.delay(options.delay);
    }
    
    if (options.repeat) {
      tween.repeat(options.repeat);
    }
    
    if (options.yoyo) {
      tween.yoyo(options.yoyo);
    }
    
    if (options.start !== false) {
      tween.start();
    }
    
    return tween;
  }
  
  /**
   * 简化的资源加载API
   * @param {string} src - 资源路径
   * @returns {Promise} 资源加载Promise
   */
  _loadAsset(src) {
    return this.load(src);
  }
  
  /**
   * 简化的资源获取API
   * @param {string} src - 资源路径
   * @returns {any} 资源对象
   */
  _getAsset(src) {
    return this.resourceManager.get(src);
  }
  
  /**
   * 简化的事件绑定API
   * @param {string} event - 事件名称
   * @param {function} callback - 回调函数
   */
  _on(event, callback) {
    this.eventBus.on(event, callback);
  }
  
  /**
   * 简化的事件解绑API
   * @param {string} event - 事件名称
   * @param {function} callback - 回调函数
   */
  _off(event, callback) {
    this.eventBus.off(event, callback);
  }
  
  /**
   * 简化的事件触发API
   * @param {string} event - 事件名称
   * @param {any} data - 事件数据
   */
  _emit(event, data) {
    this.eventBus.emit(event, data);
  }
  
  /**
   * 简化的UI创建API
   * @param {string} type - UI类型 ('button', 'label', 'image', 'slider')
   * @param {object} options - UI选项
   * @returns {UIElement} UI元素
   */
  _createUI(type, options = {}) {
    // 导入UI组件
    const { UIButton, UILabel, UIImage, UISlider } = require('../ui/UI.js');
    
    switch (type.toLowerCase()) {
      case 'button':
        const button = new UIButton(
          options.x || 0, 
          options.y || 0, 
          options.width || 100, 
          options.height || 50, 
          options.text || ''
        );
        
        if (options.style) {
          if (options.style.backgroundColor) button.setBackgroundColor(options.style.backgroundColor);
          if (options.style.hoverColor) button.setHoverColor(options.style.hoverColor);
          if (options.style.pressedColor) button.setPressedColor(options.style.pressedColor);
          if (options.style.textColor) button.setTextColor(options.style.textColor);
        }
        
        return button;
        
      case 'label':
        const label = new UILabel(
          options.x || 0, 
          options.y || 0, 
          options.text || ''
        );
        
        if (options.style) {
          if (options.style.font) label.setFont(options.style.font);
          if (options.style.color) label.setColor(options.style.color);
          if (options.style.align) label.setAlign(options.style.align);
        }
        
        return label;
        
      case 'image':
        const image = new UIImage(
          options.x || 0, 
          options.y || 0, 
          options.width || 0, 
          options.height || 0
        );
        
        if (options.src) {
          image.setSrc(options.src);
        }
        
        return image;
        
      case 'slider':
        const slider = new UISlider(
          options.x || 0, 
          options.y || 0, 
          options.width || 200, 
          options.height || 20,
          options.min || 0,
          options.max || 100,
          options.value || 0
        );
        
        return slider;
        
      default:
        throw new Error(`Unsupported UI type: ${type}`);
    }
  }
  
  /**
   * 简化的游戏对象创建API
   * @param {object} options - 游戏对象选项
   * @returns {GameObject} 游戏对象
   */
  _createGameObject(options = {}) {
    // 导入GameObject
    const { GameObject } = require('../elements/GameObject.js');
    
    const gameObject = new GameObject(
      options.x || 0, 
      options.y || 0, 
      options.width || 0, 
      options.height || 0
    );
    
    // 添加组件
    if (options.components) {
      Object.keys(options.components).forEach(name => {
        gameObject.addComponent(name, options.components[name]);
      });
    }
    
    // 添加到引擎
    this.addGameObject(gameObject);
    
    return gameObject;
  }
  
  /**
   * 简化的摄像机跟随API
   * @param {GameObject} target - 跟随目标
   * @param {object} offset - 偏移量
   */
  _follow(target, offset = { x: 0, y: 0 }) {
    this.follow(target, offset);
  }
  
  /**
   * 简化的摄像机移动API
   * @param {number} x - X坐标
   * @param {number} y - Y坐标
   * @param {number} duration - 移动持续时间
   * @returns {Promise} 移动完成的Promise
   */
  _moveCameraTo(x, y, duration = 0) {
    if (duration > 0) {
      // 使用动画移动摄像机
      const currentX = this.camera.x;
      const currentY = this.camera.y;
      
      return new Promise(resolve => {
        this.animate(
          { x: currentX, y: currentY },
          { x, y },
          duration,
          {
            onUpdate: (progress) => {
              const newX = currentX + (x - currentX) * progress;
              const newY = currentY + (y - currentY) * progress;
              this.setCameraPosition(newX, newY);
            },
            onComplete: resolve
          }
        );
      });
    } else {
      // 立即移动摄像机
      this.setCameraPosition(x, y);
      return Promise.resolve();
    }
  }
  
  /**
   * 简化的摄像机缩放API
   * @param {number} zoom - 缩放级别
   * @param {number} duration - 缩放持续时间
   * @returns {Promise} 缩放完成的Promise
   */
  _zoomCamera(zoom, duration = 0) {
    if (duration > 0) {
      // 使用动画缩放摄像机
      const currentZoom = this.camera.zoom;
      
      return new Promise(resolve => {
        this.animate(
          { zoom: currentZoom },
          { zoom },
          duration,
          {
            onUpdate: (progress) => {
              const newZoom = currentZoom + (zoom - currentZoom) * progress;
              this.setCameraZoom(newZoom);
            },
            onComplete: resolve
          }
        );
      });
    } else {
      // 立即缩放摄像机
      this.setCameraZoom(zoom);
      return Promise.resolve();
    }
  }
  
  /**
   * 简化的摄像机震动API
   * @param {number} intensity - 震动强度
   * @param {number} duration - 震动持续时间
   */
  _shakeCamera(intensity, duration) {
    this.shakeCamera(intensity, duration);
  }
  
  /**
   * 简化的音频加载API
   * @param {string} name - 音频名称
   * @param {string} src - 音频路径
   * @param {object} options - 音频选项
   * @returns {Promise} 音频加载Promise
   */
  _loadSound(name, src, options = {}) {
    if (options.type === 'music') {
      return this.loadMusic(name, src, options);
    } else {
      return this.loadSound(name, src, options);
    }
  }
  
  /**
   * 简化的音频播放API
   * @param {string} name - 音频名称
   * @param {object} options - 播放选项
   */
  _playSound(name, options = {}) {
    if (options.type === 'music') {
      this.playMusic(name, options);
    } else {
      this.playSound(name, options);
    }
  }
  
  /**
   * 简化的音频停止API
   * @param {string} name - 音频名称
   * @param {string} type - 音频类型 ('sound' 或 'music')
   */
  _stopSound(name, type = 'sound') {
    if (type === 'music') {
      this.stopMusic(name);
    }
  }
  
  /**
   * 简化的粒子系统API
   * @param {object} options - 粒子选项
   * @returns {ParticleSystem} 粒子系统
   */
  _createParticle(options = {}) {
    // 导入粒子系统
    const { ParticleSystem } = require('../effects/ParticleSystem.js');
    
    const particleSystem = new ParticleSystem(
      options.x || 0,
      options.y || 0,
      options.options || {}
    );
    
    // 添加到引擎
    this.addGameObject(particleSystem);
    
    return particleSystem;
  }
}

// 创建全局PE对象，提供简化的API
const PE = {
  // 简化的引擎创建方法
  createEngine: (element, options) => new SimplifiedEngine(element, options),
  
  // 简化的工具方法
  version: '1.0.0',
  
  // 简化的常量
  PI: Math.PI,
  PI_2: Math.PI * 2
};

// 导出简化版引擎
export default SimplifiedEngine;
export { PE };