// SimplifiedComponent.js - 简化版组件系统API
import { Component, PhysicsComponent, ColliderComponent, AnimationComponent, InputComponent, LifecycleComponent } from './Component.js';

/**
 * 简化版组件基类
 * 参考PixiJS、Egret和Vue 3的设计理念
 */
class SimplifiedComponent extends Component {
  constructor(options = {}) {
    super(options);
    
    // 创建简化API的快捷方法
    this._createSimplifiedAPI();
  }
  
  /**
   * 创建简化API的快捷方法
   */
  _createSimplifiedAPI() {
    // 简化的组件启用/禁用API
    this.enable = this._enable.bind(this);
    this.disable = this._disable.bind(this);
    
    // 简化的组件销毁API
    this.destroy = this._destroy.bind(this);
  }
  
  /**
   * 简化的组件启用API
   * @returns {Component} 组件实例
   */
  _enable() {
    this.enabled = true;
    return this;
  }
  
  /**
   * 简化的组件禁用API
   * @returns {Component} 组件实例
   */
  _disable() {
    this.enabled = false;
    return this;
  }
  
  /**
   * 简化的组件销毁API
   * @returns {Component} 组件实例
   */
  _destroy() {
    this.onDestroy(this.gameObject);
    return this;
  }
  
  /**
   * 简化的组件配置API
   * @param {object} config - 配置对象
   * @returns {Component} 组件实例
   */
  config(config = {}) {
    // 应用配置
    Object.assign(this, config);
    return this;
  }
}

/**
 * 简化版物理组件类
 */
class SimplifiedPhysicsComponent extends PhysicsComponent {
  constructor(options = {}) {
    super(options);
    
    // 创建简化API的快捷方法
    this._createSimplifiedAPI();
  }
  
  /**
   * 创建简化API的快捷方法
   */
  _createSimplifiedAPI() {
    // 简化的物理属性设置API
    this.velocity = this._setVelocity.bind(this);
    this.acceleration = this._setAcceleration.bind(this);
    this.friction = this._setFriction.bind(this);
  }
  
  /**
   * 简化的速度设置API
   * @param {number} x - X轴速度
   * @param {number} y - Y轴速度
   * @returns {PhysicsComponent} 物理组件实例
   */
  _setVelocity(x, y) {
    this.velocityX = x;
    this.velocityY = y;
    return this;
  }
  
  /**
   * 简化的加速度设置API
   * @param {number} x - X轴加速度
   * @param {number} y - Y轴加速度
   * @returns {PhysicsComponent} 物理组件实例
   */
  _setAcceleration(x, y) {
    this.accelerationX = x;
    this.accelerationY = y;
    return this;
  }
  
  /**
   * 简化的摩擦力设置API
   * @param {number} friction - 摩擦力系数
   * @returns {PhysicsComponent} 物理组件实例
   */
  _setFriction(friction) {
    this.friction = friction;
    return this;
  }
  
  /**
   * 简化的物理配置API
   * @param {object} config - 配置对象
   * @returns {PhysicsComponent} 物理组件实例
   */
  config(config = {}) {
    // 应用配置
    if (config.velocityX !== undefined) this.velocityX = config.velocityX;
    if (config.velocityY !== undefined) this.velocityY = config.velocityY;
    if (config.accelerationX !== undefined) this.accelerationX = config.accelerationX;
    if (config.accelerationY !== undefined) this.accelerationY = config.accelerationY;
    if (config.friction !== undefined) this.friction = config.friction;
    if (config.gravity !== undefined) this.gravity = config.gravity;
    
    return this;
  }
}

/**
 * 简化版碰撞组件类
 */
class SimplifiedColliderComponent extends ColliderComponent {
  constructor(options = {}) {
    super(options);
    
    // 创建简化API的快捷方法
    this._createSimplifiedAPI();
  }
  
  /**
   * 创建简化API的快捷方法
   */
  _createSimplifiedAPI() {
    // 简化的碰撞体设置API
    this.size = this._setSize.bind(this);
    this.offset = this._setOffset.bind(this);
  }
  
  /**
   * 简化的碰撞体大小设置API
   * @param {number} width - 碰撞体宽度
   * @param {number} height - 碰撞体高度
   * @returns {ColliderComponent} 碰撞组件实例
   */
  _setSize(width, height) {
    this.width = width;
    this.height = height;
    return this;
  }
  
  /**
   * 简化的碰撞体偏移设置API
   * @param {number} x - X轴偏移
   * @param {number} y - Y轴偏移
   * @returns {ColliderComponent} 碰撞组件实例
   */
  _setOffset(x, y) {
    this.offsetX = x;
    this.offsetY = y;
    return this;
  }
  
  /**
   * 简化的碰撞配置API
   * @param {object} config - 配置对象
   * @returns {ColliderComponent} 碰撞组件实例
   */
  config(config = {}) {
    // 应用配置
    if (config.width !== undefined) this.width = config.width;
    if (config.height !== undefined) this.height = config.height;
    if (config.offsetX !== undefined) this.offsetX = config.offsetX;
    if (config.offsetY !== undefined) this.offsetY = config.offsetY;
    if (config.isTrigger !== undefined) this.isTrigger = config.isTrigger;
    
    return this;
  }
}

/**
 * 简化版动画组件类
 */
class SimplifiedAnimationComponent extends AnimationComponent {
  constructor(options = {}) {
    super(options);
    
    // 创建简化API的快捷方法
    this._createSimplifiedAPI();
  }
  
  /**
   * 创建简化API的快捷方法
   */
  _createSimplifiedAPI() {
    // 简化的动画控制API
    this.play = this._playAnimation.bind(this);
    this.stop = this._stopAnimation.bind(this);
    this.pause = this._pauseAnimation.bind(this);
    this.resume = this._resumeAnimation.bind(this);
  }
  
  /**
   * 简化的动画播放API
   * @param {string} name - 动画名称
   * @param {boolean} loop - 是否循环
   * @returns {AnimationComponent} 动画组件实例
   */
  _playAnimation(name, loop = false) {
    // 这里需要访问游戏对象的动画控制器
    if (this.gameObject && this.gameObject.engine) {
      this.gameObject.engine.playFrameAnimation(this.gameObject, name, loop);
    }
    return this;
  }
  
  /**
   * 简化的动画停止API
   * @returns {AnimationComponent} 动画组件实例
   */
  _stopAnimation() {
    // 这里需要访问游戏对象的动画控制器
    if (this.gameObject && this.gameObject.engine) {
      this.gameObject.engine.stopFrameAnimation();
    }
    return this;
  }
  
  /**
   * 简化的动画暂停API
   * @returns {AnimationComponent} 动画组件实例
   */
  _pauseAnimation() {
    // 动画暂停逻辑
    return this;
  }
  
  /**
   * 简化的动画恢复API
   * @returns {AnimationComponent} 动画组件实例
   */
  _resumeAnimation() {
    // 动画恢复逻辑
    return this;
  }
  
  /**
   * 简化的动画配置API
   * @param {object} config - 配置对象
   * @returns {AnimationComponent} 动画组件实例
   */
  config(config = {}) {
    // 应用配置
    if (config.currentAnimation !== undefined) this.currentAnimation = config.currentAnimation;
    if (config.isPlaying !== undefined) this.isPlaying = config.isPlaying;
    
    return this;
  }
}

/**
 * 简化版输入组件类
 */
class SimplifiedInputComponent extends InputComponent {
  constructor(options = {}) {
    super(options);
    
    // 创建简化API的快捷方法
    this._createSimplifiedAPI();
  }
  
  /**
   * 创建简化API的快捷方法
   */
  _createSimplifiedAPI() {
    // 简化的输入处理API
    this.onKeyDown = this._onKeyDown.bind(this);
    this.onKeyUp = this._onKeyUp.bind(this);
    this.onMouseDown = this._onMouseDown.bind(this);
    this.onMouseUp = this._onMouseUp.bind(this);
  }
  
  /**
   * 简化的键盘按下处理API
   * @param {string} key - 按键名称
   * @param {function} callback - 回调函数
   * @returns {InputComponent} 输入组件实例
   */
  _onKeyDown(key, callback) {
    if (!this.keyDownHandlers) this.keyDownHandlers = {};
    this.keyDownHandlers[key] = callback;
    return this;
  }
  
  /**
   * 简化的键盘抬起处理API
   * @param {string} key - 按键名称
   * @param {function} callback - 回调函数
   * @returns {InputComponent} 输入组件实例
   */
  _onKeyUp(key, callback) {
    if (!this.keyUpHandlers) this.keyUpHandlers = {};
    this.keyUpHandlers[key] = callback;
    return this;
  }
  
  /**
   * 简化的鼠标按下处理API
   * @param {function} callback - 回调函数
   * @returns {InputComponent} 输入组件实例
   */
  _onMouseDown(callback) {
    this.mouseDownHandler = callback;
    return this;
  }
  
  /**
   * 简化的鼠标抬起处理API
   * @param {function} callback - 回调函数
   * @returns {InputComponent} 输入组件实例
   */
  _onMouseUp(callback) {
    this.mouseUpHandler = callback;
    return this;
  }
  
  /**
   * 简化的输入配置API
   * @param {object} config - 配置对象
   * @returns {InputComponent} 输入组件实例
   */
  config(config = {}) {
    // 应用配置
    if (config.keyDownHandlers !== undefined) this.keyDownHandlers = config.keyDownHandlers;
    if (config.keyUpHandlers !== undefined) this.keyUpHandlers = config.keyUpHandlers;
    if (config.mouseDownHandler !== undefined) this.mouseDownHandler = config.mouseDownHandler;
    if (config.mouseUpHandler !== undefined) this.mouseUpHandler = config.mouseUpHandler;
    
    return this;
  }
}

/**
 * 简化版生命周期组件类
 */
class SimplifiedLifecycleComponent extends LifecycleComponent {
  constructor(options = {}) {
    super(options);
    
    // 创建简化API的快捷方法
    this._createSimplifiedAPI();
  }
  
  /**
   * 创建简化API的快捷方法
   */
  _createSimplifiedAPI() {
    // 简化的生命周期处理API
    this.onCreate = this._onCreate.bind(this);
    this.onUpdate = this._onUpdate.bind(this);
    this.onDestroy = this._onDestroy.bind(this);
  }
  
  /**
   * 简化的创建处理API
   * @param {function} callback - 回调函数
   * @returns {LifecycleComponent} 生命周期组件实例
   */
  _onCreate(callback) {
    this.createHandler = callback;
    return this;
  }
  
  /**
   * 简化的更新处理API
   * @param {function} callback - 回调函数
   * @returns {LifecycleComponent} 生命周期组件实例
   */
  _onUpdate(callback) {
    this.updateHandler = callback;
    return this;
  }
  
  /**
   * 简化的销毁处理API
   * @param {function} callback - 回调函数
   * @returns {LifecycleComponent} 生命周期组件实例
   */
  _onDestroy(callback) {
    this.destroyHandler = callback;
    return this;
  }
  
  /**
   * 简化的生命周期配置API
   * @param {object} config - 配置对象
   * @returns {LifecycleComponent} 生命周期组件实例
   */
  config(config = {}) {
    // 应用配置
    if (config.createHandler !== undefined) this.createHandler = config.createHandler;
    if (config.updateHandler !== undefined) this.updateHandler = config.updateHandler;
    if (config.destroyHandler !== undefined) this.destroyHandler = config.destroyHandler;
    
    return this;
  }
}

/**
 * 简化版组件工厂类
 */
class SimplifiedComponentFactory {
  /**
   * 创建组件
   * @param {string} type - 组件类型
   * @param {object} options - 组件选项
   * @returns {Component} 组件实例
   */
  static create(type, options = {}) {
    switch (type.toLowerCase()) {
      case 'physics':
        return new SimplifiedPhysicsComponent(options);
      case 'collider':
        return new SimplifiedColliderComponent(options);
      case 'animation':
        return new SimplifiedAnimationComponent(options);
      case 'input':
        return new SimplifiedInputComponent(options);
      case 'lifecycle':
        return new SimplifiedLifecycleComponent(options);
      default:
        return new SimplifiedComponent(options);
    }
  }
  
  /**
   * 创建物理组件
   * @param {object} options - 组件选项
   * @returns {SimplifiedPhysicsComponent} 物理组件
   */
  static physics(options = {}) {
    return new SimplifiedPhysicsComponent(options);
  }
  
  /**
   * 创建碰撞组件
   * @param {object} options - 组件选项
   * @returns {SimplifiedColliderComponent} 碰撞组件
   */
  static collider(options = {}) {
    return new SimplifiedColliderComponent(options);
  }
  
  /**
   * 创建动画组件
   * @param {object} options - 组件选项
   * @returns {SimplifiedAnimationComponent} 动画组件
   */
  static animation(options = {}) {
    return new SimplifiedAnimationComponent(options);
  }
  
  /**
   * 创建输入组件
   * @param {object} options - 组件选项
   * @returns {SimplifiedInputComponent} 输入组件
   */
  static input(options = {}) {
    return new SimplifiedInputComponent(options);
  }
  
  /**
   * 创建生命周期组件
   * @param {object} options - 组件选项
   * @returns {SimplifiedLifecycleComponent} 生命周期组件
   */
  static lifecycle(options = {}) {
    return new SimplifiedLifecycleComponent(options);
  }
  
  /**
   * 创建自定义组件
   * @param {object} options - 组件选项
   * @returns {SimplifiedComponent} 自定义组件
   */
  static custom(options = {}) {
    return new SimplifiedComponent(options);
  }
}

// 导出简化版组件类和工厂类
export { 
  SimplifiedComponent, 
  SimplifiedPhysicsComponent, 
  SimplifiedColliderComponent, 
  SimplifiedAnimationComponent, 
  SimplifiedInputComponent, 
  SimplifiedLifecycleComponent, 
  SimplifiedComponentFactory 
};