// SimplifiedGameObject.js - 简化版游戏对象系统API
import { GameObject } from './GameObject.js';
import { Component, PhysicsComponent, ColliderComponent, AnimationComponent, InputComponent, LifecycleComponent } from './Component.js';

/**
 * 简化版游戏对象类
 * 参考PixiJS、Egret和Vue 3的设计理念
 */
class SimplifiedGameObject extends GameObject {
  constructor(options = {}) {
    super(
      options.x || 0,
      options.y || 0,
      options.width || 0,
      options.height || 0
    );
    
    // 应用属性
    if (options.name) {
      this.name = options.name;
    }
    
    // 添加组件
    if (options.components) {
      this._addComponents(options.components);
    }
    
    // 应用事件
    if (options.events) {
      this._applyEvents(options.events);
    }
  }
  
  /**
   * 添加组件
   * @param {object} components - 组件对象
   */
  _addComponents(components) {
    Object.keys(components).forEach(name => {
      this.addComponent(name, components[name]);
    });
  }
  
  /**
   * 应用事件
   * @param {object} events - 事件对象
   */
  _applyEvents(events) {
    Object.keys(events).forEach(event => {
      this.on(event, events[event]);
    });
  }
  
  /**
   * 简化的链式调用方法
   */
  position(x, y) {
    this.setPosition(x, y);
    return this;
  }
  
  size(width, height) {
    this.setSize(width, height);
    return this;
  }
  
  rotation(angle) {
    this.setRotation(angle);
    return this;
  }
  
  scale(x, y = x) {
    this.setScale(x, y);
    return this;
  }
  
  visible(visible) {
    this.setVisible(visible);
    return this;
  }
  
  add(child) {
    this.addChild(child);
    return this;
  }
  
  remove(child) {
    this.removeChild(child);
    return this;
  }
  
  component(name, component) {
    if (component) {
      this.addComponent(name, component);
    }
    return this.getComponent(name);
  }
  
  on(event, callback) {
    super.on(event, callback);
    return this;
  }
}

/**
 * 简化版组件工厂类
 */
class SimplifiedComponentFactory {
  /**
   * 创建物理组件
   * @param {object} options - 物理组件选项
   * @returns {PhysicsComponent} 物理组件
   */
  static physics(options = {}) {
    return new PhysicsComponent(options);
  }
  
  /**
   * 创建碰撞组件
   * @param {object} options - 碰撞组件选项
   * @returns {ColliderComponent} 碰撞组件
   */
  static collider(options = {}) {
    return new ColliderComponent(options);
  }
  
  /**
   * 创建动画组件
   * @param {object} options - 动画组件选项
   * @returns {AnimationComponent} 动画组件
   */
  static animation(options = {}) {
    return new AnimationComponent(options);
  }
  
  /**
   * 创建输入组件
   * @param {object} options - 输入组件选项
   * @returns {InputComponent} 输入组件
   */
  static input(options = {}) {
    return new InputComponent(options);
  }
  
  /**
   * 创建生命周期组件
   * @param {object} options - 生命周期组件选项
   * @returns {LifecycleComponent} 生命周期组件
   */
  static lifecycle(options = {}) {
    return new LifecycleComponent(options);
  }
  
  /**
   * 创建自定义组件
   * @param {object} options - 自定义组件选项
   * @returns {Component} 自定义组件
   */
  static custom(options = {}) {
    return new Component(options);
  }
}

/**
 * 简化版游戏对象工厂类
 */
class SimplifiedGameObjectFactory {
  /**
   * 创建游戏对象
   * @param {object} options - 游戏对象选项
   * @returns {SimplifiedGameObject} 游戏对象
   */
  static create(options = {}) {
    return new SimplifiedGameObject(options);
  }
  
  /**
   * 创建精灵对象
   * @param {object} options - 精灵对象选项
   * @returns {SimplifiedGameObject} 精灵对象
   */
  static sprite(options = {}) {
    const spriteOptions = {
      ...options,
      components: {
        ...options.components,
        renderer: new Component({
          render: function() {
            // 精灵渲染逻辑
            if (this.gameObject && this.gameObject.element) {
              // 更新精灵位置和样式
              this.gameObject.element.setPosition(this.gameObject.x, this.gameObject.y);
            }
          }
        })
      }
    };
    
    return new SimplifiedGameObject(spriteOptions);
  }
  
  /**
   * 创建容器对象
   * @param {object} options - 容器对象选项
   * @returns {SimplifiedGameObject} 容器对象
   */
  static container(options = {}) {
    return new SimplifiedGameObject(options);
  }
  
  /**
   * 创建文本对象
   * @param {object} options - 文本对象选项
   * @returns {SimplifiedGameObject} 文本对象
   */
  static text(options = {}) {
    const textOptions = {
      ...options,
      components: {
        ...options.components,
        renderer: new Component({
          render: function() {
            // 文本渲染逻辑
            if (this.gameObject && this.gameObject.element) {
              // 更新文本位置和样式
              this.gameObject.element.setPosition(this.gameObject.x, this.gameObject.y);
            }
          }
        })
      }
    };
    
    return new SimplifiedGameObject(textOptions);
  }
}

// 导出简化版游戏对象类和工厂类
export { SimplifiedGameObject, SimplifiedComponentFactory, SimplifiedGameObjectFactory };