/**
 * 笔刷注册表
 * 用于注册、获取和管理所有笔刷
 */
export class BrushRegistry {
  constructor() {
    // 存储所有注册的笔刷类
    this.brushes = new Map();

    // 按类别组织的笔刷
    this.brushesByCategory = new Map();

    // 事件监听器
    this.listeners = {
      register: [],
      unregister: [],
    };
  }

  /**
   * 注册一个笔刷
   * @param {String} id 笔刷唯一标识
   * @param {Class} brushClass 笔刷类（需要继承BaseBrush）
   * @param {Object} metadata 笔刷元数据（可选）
   * @returns {Boolean} 是否注册成功
   */
  register(id, brushClass, metadata = {}) {
    if (this.brushes.has(id)) {
    //   console.warn(`笔刷 ${id} 已存在，请使用其他ID`);
      return false;
    }

    // 存储笔刷信息
    const brushInfo = {
      id,
      class: brushClass,
      metadata: {
        ...metadata,
        id,
      },
    };

    this.brushes.set(id, brushInfo);

    // 添加到分类
    const category = metadata.category || "默认";
    if (!this.brushesByCategory.has(category)) {
      this.brushesByCategory.set(category, []);
    }
    this.brushesByCategory.get(category).push(brushInfo);

    // 触发事件
    this._triggerEvent("register", brushInfo);

    return true;
  }

  /**
   * 取消注册笔刷
   * @param {String} id 笔刷ID
   * @returns {Boolean} 是否成功
   */
  unregister(id) {
    if (!this.brushes.has(id)) {
      return false;
    }

    const brushInfo = this.brushes.get(id);
    this.brushes.delete(id);

    // 从分类中移除
    const category = brushInfo.metadata.category || "默认";
    if (this.brushesByCategory.has(category)) {
      const brushes = this.brushesByCategory.get(category);
      const index = brushes.findIndex((b) => b.id === id);
      if (index !== -1) {
        brushes.splice(index, 1);
      }

      // 如果分类为空，删除该分类
      if (brushes.length === 0) {
        this.brushesByCategory.delete(category);
      }
    }

    // 触发事件
    this._triggerEvent("unregister", brushInfo);

    return true;
  }

  /**
   * 获取笔刷信息
   * @param {String} id 笔刷ID
   * @returns {Object|null} 笔刷信息或null
   */
  getBrush(id) {
    return this.brushes.get(id) || null;
  }

  /**
   * 获取所有笔刷
   * @returns {Array} 笔刷信息数组
   */
  getAllBrushes() {
    return Array.from(this.brushes.values());
  }

  /**
   * 获取指定分类的笔刷
   * @param {String} category 分类名称
   * @returns {Array} 笔刷信息数组
   */
  getBrushesByCategory(category) {
    return this.brushesByCategory.get(category) || [];
  }

  /**
   * 获取所有分类
   * @returns {Array} 分类名称数组
   */
  getCategories() {
    return Array.from(this.brushesByCategory.keys());
  }

  /**
   * 创建一个笔刷实例
   * @param {String} id 笔刷ID
   * @param {Object} canvas 画布实例
   * @param {Object} options 配置选项
   * @returns {Object|null} 笔刷实例或null
   */
  createBrushInstance(id, canvas, options = {}) {
    const brushInfo = this.getBrush(id);
    if (!brushInfo) {
      console.error(`笔刷 ${id} 不存在`);
      return null;
    }

    try {
      // 创建笔刷实例
      return new brushInfo.class(canvas, {
        ...options,
        id: brushInfo.id,
        ...brushInfo.metadata,
      });
    } catch (error) {
      console.error(`创建笔刷 ${id} 失败:`, error);
      return null;
    }
  }

  /**
   * 添加事件监听器
   * @param {String} event 事件名称 ('register'|'unregister')
   * @param {Function} callback 回调函数
   */
  addEventListener(event, callback) {
    if (this.listeners[event]) {
      this.listeners[event].push(callback);
    }
  }

  /**
   * 移除事件监听器
   * @param {String} event 事件名称
   * @param {Function} callback 回调函数
   */
  removeEventListener(event, callback) {
    if (this.listeners[event]) {
      const index = this.listeners[event].indexOf(callback);
      if (index !== -1) {
        this.listeners[event].splice(index, 1);
      }
    }
  }

  /**
   * 触发事件
   * @param {String} event 事件名称
   * @param {*} data 事件数据
   * @private
   */
  _triggerEvent(event, data) {
    if (this.listeners[event]) {
      this.listeners[event].forEach((callback) => {
        try {
          callback(data);
        } catch (error) {
          console.error(`执行 ${event} 事件监听器出错:`, error);
        }
      });
    }
  }
}

// 导出单例实例
export const brushRegistry = new BrushRegistry();

// 默认导出单例
export default brushRegistry;
