/**
 * 浏览器工厂类
 * 负责创建不同类型的浏览器提供商实例
 */

const AdsPowerProvider = require('../providers/adspower-provider');
// 未来添加更多提供商
// const PlaywrightStealthProvider = require('../providers/playwright-stealth-provider');
// const PuppeteerStealthProvider = require('../providers/puppeteer-stealth-provider');

class BrowserFactory {
  /**
   * 提供商注册表
   * @private
   */
  static _providers = {
    'adspower': AdsPowerProvider,
    // 未来添加：
    // 'playwright-stealth': PlaywrightStealthProvider,
    // 'puppeteer-stealth': PuppeteerStealthProvider,
    // 'selenium-undetected': SeleniumUndetectedProvider,
    // 'nodriver': NoDriverProvider
  };

  /**
   * 创建浏览器提供商实例
   * @param {string} providerName - 提供商名称
   * @param {Object} config - 配置对象
   * @returns {BaseBrowserProvider}
   */
  static create(providerName, config = {}) {
    // 标准化提供商名称
    const normalizedName = providerName.toLowerCase().trim();
    
    // 查找提供商类
    const ProviderClass = this._providers[normalizedName];
    
    if (!ProviderClass) {
      const available = this.getAvailableProviders().join(', ');
      throw new Error(
        `未知的浏览器提供商: "${providerName}"\n` +
        `可用的提供商: ${available}`
      );
    }
    
    // 创建实例
    return new ProviderClass(config);
  }

  /**
   * 获取所有可用的提供商列表
   * @returns {string[]}
   */
  static getAvailableProviders() {
    return Object.keys(this._providers);
  }

  /**
   * 获取所有提供商的元数据
   * @returns {Object[]}
   */
  static getAllProvidersMetadata() {
    return Object.entries(this._providers).map(([name, ProviderClass]) => {
      const instance = new ProviderClass({});
      return {
        id: name,
        ...instance.getMetadata()
      };
    });
  }

  /**
   * 获取免费提供商列表
   * @returns {string[]}
   */
  static getFreeProviders() {
    return this.getAllProvidersMetadata()
      .filter(meta => meta.free)
      .map(meta => meta.id);
  }

  /**
   * 获取付费提供商列表
   * @returns {string[]}
   */
  static getPaidProviders() {
    return this.getAllProvidersMetadata()
      .filter(meta => !meta.free)
      .map(meta => meta.id);
  }

  /**
   * 根据能力查找提供商
   * @param {string|string[]} capabilities - 所需能力
   * @returns {string[]}
   */
  static findProvidersByCapability(capabilities) {
    const requiredCapabilities = Array.isArray(capabilities) 
      ? capabilities 
      : [capabilities];
    
    return this.getAllProvidersMetadata()
      .filter(meta => {
        const caps = meta.capabilities;
        return requiredCapabilities.every(cap => caps[cap] === true);
      })
      .map(meta => meta.id);
  }

  /**
   * 注册自定义提供商
   * @param {string} name - 提供商名称
   * @param {Class} ProviderClass - 提供商类
   */
  static registerProvider(name, ProviderClass) {
    const normalizedName = name.toLowerCase().trim();
    
    if (this._providers[normalizedName]) {
      throw new Error(`提供商 "${name}" 已存在`);
    }
    
    this._providers[normalizedName] = ProviderClass;
  }

  /**
   * 注销提供商
   * @param {string} name - 提供商名称
   */
  static unregisterProvider(name) {
    const normalizedName = name.toLowerCase().trim();
    delete this._providers[normalizedName];
  }

  /**
   * 获取推荐的提供商
   * @param {Object} requirements - 需求 { free: boolean, capabilities: string[] }
   * @returns {string|null}
   */
  static getRecommendedProvider(requirements = {}) {
    let providers = this.getAllProvidersMetadata();
    
    // 筛选免费/付费
    if (requirements.free !== undefined) {
      providers = providers.filter(p => p.free === requirements.free);
    }
    
    // 筛选能力
    if (requirements.capabilities) {
      const caps = requirements.capabilities;
      providers = providers.filter(p => {
        return caps.every(cap => p.capabilities[cap] === true);
      });
    }
    
    // 返回第一个匹配的
    return providers.length > 0 ? providers[0].id : null;
  }
}

module.exports = BrowserFactory;
