/**
 * @file bit_api.js
 * @brief 比特浏览器 Local API 封装
 * @details 基于官方文档 https://doc2.bitbrowser.cn/
 *          所有接口使用 POST 方法，JSON 格式
 */

const axios = require('axios');
const { getSetting } = require('./database');

// ==================== 信号量（限制并发打开浏览器请求） ====================

/**
 * 简单信号量，用于限制同时进行的 openBrowser API 请求数
 * 避免比特浏览器因请求过于集中而返回 429
 */
class Semaphore {
  constructor(max) {
    this.max = max;
    this.current = 0;
    this.queue = [];
  }
  acquire() {
    return new Promise(resolve => {
      if (this.current < this.max) {
        this.current++;
        resolve();
      } else {
        this.queue.push(resolve);
      }
    });
  }
  release() {
    this.current--;
    if (this.queue.length > 0 && this.current < this.max) {
      this.current++;
      this.queue.shift()();
    }
  }

  /**
   * 动态调整并发上限，并立即释放新增的可用名额。
   * @param {number} max - 新的并发上限
   * @returns {number} 标准化后的并发上限
   */
  setMax(max) {
    this.max = Math.max(1, Math.min(100, parseInt(max, 10) || 1));
    while (this.current < this.max && this.queue.length > 0) {
      this.current++;
      this.queue.shift()();
    }
    return this.max;
  }

  /** 返回当前信号量状态，供诊断和测试使用。 */
  getStats() {
    return { max: this.max, current: this.current, queued: this.queue.length };
  }
}

// 初始值仅用于任务配置前；每个 Worker 启动后会同步为用户设置的任务并发数。
const _openBrowserSem = new Semaphore(2);

/**
 * 让比特浏览器打开请求并发跟随任务并发。
 * 每秒启动速度仍由 browser_lifecycle 的 openThrottle 独立控制。
 * @param {number} concurrency - 当前任务并发数
 * @returns {number} 实际采用的打开请求并发数
 */
function setOpenBrowserConcurrency(concurrency) {
  return _openBrowserSem.setMax(concurrency);
}

// ==================== API 类 ====================

class BitBrowserAPI {
  /**
   * 构造函数
   * @param {string} [baseUrl='http://127.0.0.1:54345'] - 比特浏览器 API 基础 URL
   */
  constructor(baseUrl = 'http://127.0.0.1:54345') {
    this.baseUrl = baseUrl;
    this.headers = { 'Content-Type': 'application/json' };
  }

  /**
   * 发送 POST 请求到比特浏览器 API
   * @param {string} endpoint - API 路径（如 '/browser/open'）
   * @param {object} [data={}] - 请求体数据
   * @param {number} [timeout=30000] - 请求超时时间（毫秒）
   * @returns {Promise<object>} API 响应数据
   */
  async request(endpoint, data = {}, timeout = 30000) {
    const url = `${this.baseUrl}${endpoint}`;
    for (let attempt = 0; attempt < 3; attempt++) {
      try {
        const response = await axios.post(url, data, {
          headers: this.headers,
          timeout,
        });
        return response.data;
      } catch (e) {
        if (e.response && e.response.status === 429 && attempt < 2) {
          const delay = (attempt + 1) * 1000; // 1s, 2s
          await new Promise(r => setTimeout(r, delay));
          continue;
        }
        if (e.response) {
          return { success: false, msg: `HTTP ${e.response.status}: ${e.response.statusText}` };
        }
        return { success: false, msg: `请求失败: ${e.message}` };
      }
    }
  }

  /**
   * 检测比特浏览器是否在线
   * @returns {Promise<object>} 健康检查响应
   */
  async healthCheck() {
    return this.request('/health');
  }

  /**
   * 创建新的浏览器窗口
   * @param {object} [options={}] - 创建选项
   * @param {string} [options.name='new browser'] - 窗口名称
   * @param {string} [options.groupId] - 分组 ID
   * @param {object} [options.browserFingerprint] - 指纹配置
   * @param {number} [options.proxyMethod=2] - 代理方式
   * @param {string} [options.proxyType='noproxy'] - 代理类型
   * @returns {Promise<object>} 创建结果，data.id 为新窗口 ID
   */
  async createBrowser({ name = 'new browser', groupId, browserFingerprint, proxyMethod = 2, proxyType = 'noproxy', ...rest } = {}) {
    const data = {
      name,
      proxyMethod,
      proxyType,
      browserFingerPrint: browserFingerprint || {},
      ...rest,
    };
    if (groupId) data.groupId = groupId;
    return this.request('/browser/update', data);
  }

  /**
   * 打开指定浏览器窗口
   * @param {string} browserId - 浏览器窗口 ID
   * @param {object} [options={}] - 打开选项
   * @param {string[]} [options.args] - 启动参数
   * @param {boolean} [options.queue=true] - 是否排队等待
   * @param {boolean} [options.ignoreDefaultUrls] - 是否忽略默认标签页
   * @param {string} [options.newPageUrl] - 打开后跳转到的 URL
   * @returns {Promise<object>} 打开结果，data.ws 为 WebSocket 端点
   */
  async openBrowser(browserId, { args, queue = true, ignoreDefaultUrls, newPageUrl } = {}) {
    const data = { id: browserId, queue };
    if (args) data.args = args;
    if (ignoreDefaultUrls) data.ignoreDefaultUrls = ignoreDefaultUrls;
    if (newPageUrl) data.newPageUrl = newPageUrl;
    return this.request('/browser/open', data, 60000);
  }

  /**
   * 关闭指定浏览器窗口
   * @param {string} browserId - 浏览器窗口 ID
   * @returns {Promise<object>} 关闭结果
   */
  async closeBrowser(browserId) {
    return this.request('/browser/close', { id: browserId });
  }

  /**
   * 删除指定浏览器窗口（含数据）
   * @param {string} browserId - 浏览器窗口 ID
   * @returns {Promise<object>} 删除结果
   */
  async deleteBrowser(browserId) {
    return this.request('/browser/delete', { id: browserId });
  }

  /**
   * 批量删除浏览器窗口（最多 100 个）
   * @param {string[]} browserIds - 浏览器窗口 ID 数组
   * @returns {Promise<object>} 删除结果
   */
  async deleteBrowsers(browserIds) {
    return this.request('/browser/delete/ids', { ids: browserIds.slice(0, 100) });
  }

  /**
   * 获取浏览器窗口详情
   * @param {string} browserId - 浏览器窗口 ID
   * @returns {Promise<object>} 窗口详情
   */
  async getBrowserDetail(browserId) {
    return this.request('/browser/detail', { id: browserId });
  }

  /**
   * 分页列举浏览器窗口
   * @param {object} [options={}] - 查询选项
   * @param {number} [options.page=0] - 页码
   * @param {number} [options.pageSize=10] - 每页数量（最大 100）
   * @param {string} [options.groupId] - 按分组过滤
   * @param {string} [options.name] - 按名称过滤
   * @param {string} [options.sort='desc'] - 排序方向
   * @returns {Promise<object>} 窗口列表
   */
  async listBrowsers({ page = 0, pageSize = 10, groupId, name, sort = 'desc' } = {}) {
    const data = { page, pageSize: Math.min(pageSize, 100), sort };
    if (groupId) data.groupId = groupId;
    if (name) data.name = name;
    return this.request('/browser/list', data);
  }

  /**
   * 批量更新浏览器代理设置
   * @param {string[]} browserIds - 浏览器窗口 ID 数组
   * @param {object} [options={}] - 代理配置
   * @param {number} [options.proxyMethod=2] - 代理方式
   * @param {string} [options.proxyType='noproxy'] - 代理类型
   * @returns {Promise<object>} 更新结果
   */
  async updateBrowserProxy(browserIds, { proxyMethod = 2, proxyType = 'noproxy', ...rest } = {}) {
    return this.request('/browser/proxy/update', {
      ids: browserIds,
      proxyMethod,
      proxyType,
      ...rest,
    });
  }

  /**
   * 查询浏览器进程是否存活
   * @param {string[]} browserIds - 浏览器窗口 ID 数组
   * @returns {Promise<object>} 进程状态映射，data[id] 为进程 PID 或 0
   */
  async getAliveBrowserPids(browserIds) {
    return this.request('/browser/pids/alive', { ids: browserIds });
  }
}

// ==================== 全局实例（单例） ====================

let _apiInstance = null;

/**
 * 从数据库设置中读取比特浏览器端口号
 * @returns {number} 端口号，默认 54345
 */
function getBitBrowserPort() {
  try {
    const portStr = getSetting('bit_browser_port', '54345');
    return parseInt(portStr, 10) || 54345;
  } catch (e) {
    return 54345;
  }
}

/**
 * 获取 BitBrowserAPI 单例实例
 * @param {boolean} [forceNew=false] - 是否强制创建新实例（用于重读端口配置）
 * @returns {BitBrowserAPI} API 实例
 */
function getApi(forceNew = false) {
  if (!_apiInstance || forceNew) {
    const port = getBitBrowserPort();
    _apiInstance = new BitBrowserAPI(`http://127.0.0.1:${port}`);
  }
  return _apiInstance;
}

/**
 * 重置 API 单例，下次调用 getApi 时重新创建
 */
function resetApi() {
  _apiInstance = null;
}

// ==================== 代理设置 ====================

/**
 * 在打开浏览器前根据账号配置更新代理设置
 * 若浏览器已在运行则跳过代理更新
 * @param {string} browserId - 浏览器窗口 ID
 * @param {string} [email=''] - 账号邮箱，用于从数据库读取代理配置
 * @returns {Promise<{success: boolean, msg?: string}>} 操作结果
 */
async function applyProxyBeforeOpen(browserId, email = '') {
  try {
    if (!email) return { success: true };
    const { getAccount } = require('./database');
    const account = getAccount(email);
    if (!account) {
      console.log(`[Proxy] 未找到账号记录，跳过代理设置: ${email}`);
      return { success: true };
    }
    const proxyIp = (account.proxy_ip || '').trim();
    console.log(`[Proxy] 准备设置代理: email=${email}, proxy_ip='${proxyIp}'`);
    const api = getApi();

    // 检查浏览器是否已在运行
    const pidsResult = await api.getAliveBrowserPids([browserId]);
    if (pidsResult.success) {
      const pidsData = pidsResult.data || {};
      if (pidsData[browserId]) {
        console.log(`[Proxy] 浏览器已在运行中，跳过代理更新: ${browserId}`);
        return { success: true };
      }
    }

    if (proxyIp) {
      const lower = proxyIp.toLowerCase();
      if (['noproxy', 'direct', 'none'].includes(lower)) {
        const result = await api.updateBrowserProxy([browserId], { proxyMethod: 2, proxyType: 'noproxy' });
        if (!result.success) return { success: false, msg: result.msg || '代理设置失败' };
        console.log(`[Proxy] 已设置为直连: ${browserId}`);
        return { success: true };
      }

      const parts = proxyIp.split(':');
      if (parts.length < 2) {
        console.log(`[Proxy] 代理格式错误: ${proxyIp}`);
        return { success: false, msg: `代理格式错误: ${proxyIp}` };
      }

      const proxyConfig = {
        proxyMethod: 2,
        proxyType: 'socks5',
        host: parts[0].trim(),
        port: parts[1].trim(),
        proxyUserName: parts[2] ? parts[2].trim() : '',
        proxyPassword: parts[3] ? parts[3].trim() : '',
      };
      console.log(`[Proxy] 代理配置: host=${proxyConfig.host}, port=${proxyConfig.port}`);
      const result = await api.updateBrowserProxy([browserId], proxyConfig);
      if (!result.success) {
        const msg = result.msg || '';
        if (msg.includes('操作失败')) {
          console.log(`[Proxy] 代理更新被拒绝（浏览器可能已运行），跳过: ${msg}`);
          return { success: true };
        }
        return { success: false, msg: msg || '代理设置失败' };
      }
      console.log(`[Proxy] 设置代理成功: ${browserId}`);
    } else {
      console.log(`[Proxy] 未配置代理，跳过设置: ${browserId}`);
    }
    return { success: true };
  } catch (e) {
    console.log(`[Proxy] 设置代理异常: ${e.message}`);
    return { success: false, msg: e.message };
  }
}

// ==================== 便捷函数 ====================

/**
 * 打开浏览器（含代理预设置）
 * @param {string} browserId - 浏览器窗口 ID
 * @param {object} [options={}] - 打开选项
 * @param {string[]} [options.args] - 启动参数
 * @param {boolean} [options.queue=true] - 是否排队
 * @param {string} [options.email=''] - 账号邮箱，用于设置代理
 * @param {string} [options.newPageUrl] - 打开后跳转 URL
 * @returns {Promise<object>} 打开结果，data.ws 为 WebSocket 端点
 */
async function openBrowser(browserId, { args, queue = true, email = '', newPageUrl } = {}) {
  const proxyResult = await applyProxyBeforeOpen(browserId, email);
  if (!proxyResult.success) return proxyResult;
  return getApi().openBrowser(browserId, { args, queue, newPageUrl });
}

/**
 * 带重试机制的浏览器打开函数
 * @param {string} browserId - 浏览器窗口 ID
 * @param {object} [options={}] - 选项
 * @param {string} [options.email=''] - 账号邮箱
 * @param {number} [options.maxRetries=3] - 最大重试次数
 * @param {number} [options.retryDelay=2000] - 重试间隔（毫秒）
 * @param {Function} [options.logCallback] - 日志回调函数，接收一个字符串参数
 * @returns {Promise<object>} 打开结果，data.ws 为 WebSocket 端点
 */
async function openBrowserWithRetry(browserId, { email = '', maxRetries = 3, retryDelay = 2000, logCallback, ...opts } = {}) {
  const log = (msg) => { if (logCallback) logCallback(msg); };
  let lastResult = { success: false, msg: '未知错误' };
  const RATE_LIMIT_RE = /429|请求频繁|rate.?limit|too.?many/i;

  for (let attempt = 0; attempt < maxRetries; attempt++) {
    // 重试前等待：429 用更长的退避，其他错误用 retryDelay
    if (attempt > 0) {
      const isRateLimit = RATE_LIMIT_RE.test(lastResult.msg || '');
      const delay = isRateLimit ? attempt * 5000 : retryDelay;
      log(`打开失败: ${lastResult.msg || ''}，${delay / 1000}秒后重试...`);
      await new Promise(r => setTimeout(r, delay));
    }

    log(`尝试打开浏览器 (第${attempt + 1}/${maxRetries}次)`);

    // 通过信号量排队，限制同时发往比特浏览器的 open 请求数
    await _openBrowserSem.acquire();
    try {
      const result = await openBrowser(browserId, { email, ...opts });
      if (result.success) {
        const data = result.data;
        if (data && data.ws) return result;
        lastResult = { success: false, msg: `API返回成功但ws端点为空: ${JSON.stringify(data)}` };
      } else {
        lastResult = result;
      }
    } catch (e) {
      lastResult = { success: false, msg: e.message };
    } finally {
      _openBrowserSem.release();
    }
  }

  log(`浏览器打开失败（已重试${maxRetries}次）: ${lastResult.msg || ''}`);
  return lastResult;
}

/**
 * 关闭指定浏览器窗口
 * @param {string} browserId - 浏览器窗口 ID
 * @returns {Promise<object>} 关闭结果
 */
async function closeBrowser(browserId) {
  return getApi().closeBrowser(browserId);
}

/**
 * 获取所有浏览器窗口的简单列表
 * @param {object} [options={}] - 查询选项
 * @param {number} [options.page=0] - 页码
 * @param {number} [options.maxItems=10000] - 最多读取的窗口总数
 * @param {number} [options.requestPageSize=100] - 每次向比特API请求的数量（API上限100）
 * @param {number} [options.pageSize] - 旧参数，未传 maxItems 时作为总数上限兼容
 * @returns {Promise<object[]>} 浏览器窗口对象数组
 */
async function collectBrowserPages(api, options = {}) {
  const { page = 0 } = options || {};
  const startPage = Math.max(0, parseInt(page, 10) || 0);
  const legacyLimit = options && options.pageSize !== undefined ? options.pageSize : null;
  const maxItems = Math.max(1, parseInt(
    options && options.maxItems !== undefined ? options.maxItems : (legacyLimit || 10000),
    10,
  ) || 10000);
  const pageRequestSize = Math.max(1, Math.min(100, parseInt(
    options && options.requestPageSize !== undefined ? options.requestPageSize : 100,
    10,
  ) || 100));
  const browsers = [];
  const seenIds = new Set();
  let currentPage = startPage;
  let totalNum = null;
  const maxPages = Math.max(1, Math.ceil(maxItems / pageRequestSize) + 1);

  while (browsers.length < maxItems && currentPage < startPage + maxPages) {
    const requestSize = Math.min(pageRequestSize, maxItems - browsers.length);
    const response = await api.listBrowsers({ page: currentPage, pageSize: requestSize });
    if (!response || !response.success) break;

    const data = response.data;
    const list = Array.isArray(data) ? data : (data && Array.isArray(data.list) ? data.list : []);
    if (data && !Array.isArray(data) && Number.isFinite(Number(data.totalNum))) {
      totalNum = Number(data.totalNum);
    }
    if (list.length === 0) break;

    const countBeforePage = browsers.length;
    for (const browser of list) {
      const id = String((browser && (browser.id || browser.browserId || browser.browser_id)) || '');
      if (id && seenIds.has(id)) continue;
      if (id) seenIds.add(id);
      // 下游统一按 id 建立映射，兼容部分比特版本返回 browserId/browser_id。
      browsers.push(id && browser.id !== id ? { ...browser, id } : browser);
      if (browsers.length >= maxItems) break;
    }

    if (totalNum !== null && browsers.length >= totalNum) break;
    if (browsers.length === countBeforePage) break;
    if (list.length < requestSize) break;
    currentPage++;
  }

  return browsers;
}

async function getBrowserListSimple(options = {}) {
  return collectBrowserPages(getApi(), options);
}

/**
 * 将账号中保存的 host:port:user:password 代理转为比特浏览器代理配置。
 * 空值表示直连。
 */
function parseAccountProxy(proxyValue) {
  const value = String(proxyValue || '').trim();
  if (!value) return { proxyMethod: 2, proxyType: 'noproxy' };
  const parts = value.split(':');
  const host = String(parts.shift() || '').trim();
  const port = String(parts.shift() || '').trim();
  if (!host || !port) return null;
  const proxyUserName = String(parts.shift() || '').trim();
  const proxyPassword = parts.join(':').trim();
  return {
    proxyMethod: 2,
    proxyType: 'socks5',
    host,
    port,
    proxyUserName,
    proxyPassword,
  };
}

/**
 * 根据账号信息创建比特浏览器窗口
 * @param {object} account - 账号信息，包含 email、proxy_ip 等字段
 * @param {string} [browserName='默认模板'] - 窗口名称（账号无邮箱时使用）
 * @param {object[]|null} [existingBrowsers=null] - 已有浏览器列表，为 null 时自动获取
 * @param {boolean} [reuseExisting=false] - 同名窗口已存在时是否直接复用
 * @returns {Promise<{browserId: string|null, error: string|null}>} 创建结果
 */
async function createBrowserFromAccount(account, browserName = '默认模板', existingBrowsers = null, reuseExisting = false) {
  const api = getApi();

  const jsonData = { ...DEFAULT_BROWSER_TEMPLATE };
  jsonData.name = account.email || browserName;

  // 设置代理
  const proxyConfig = parseAccountProxy(account.proxy_ip);
  if (!proxyConfig) return { browserId: null, error: `代理格式错误: ${account.proxy_ip}` };
  Object.assign(jsonData, proxyConfig);

  // 检查是否已存在该账号的窗口
  const browsers = existingBrowsers !== null ? existingBrowsers : await getBrowserListSimple();
  for (const b of browsers) {
    const matchName = account.email && (b.name === account.email || b.userName === account.email);
    if (matchName) {
      // 检查是否为家庭组母号，如果是则复用
      try {
        const detail = await api.request('/browser/detail', { id: b.id });
        if (detail.success && detail.data && detail.data.remark === '家庭组母号') {
          console.log(`[BitAPI] 发现家庭组母号浏览器，复用: ${b.name} (${b.id})`);
          const { updateAccountTag } = require('./database');
          updateAccountTag(account.email, '家庭组母号');
          return { browserId: b.id, browserSeq: b.seq ?? null, error: null, isFamily: true };
        }
      } catch (_) {}
      if (reuseExisting) {
        console.log(`[BitAPI] 发现已有同名窗口，直接复用: ${b.name} (${b.id})`);
        return { browserId: b.id, browserSeq: b.seq ?? null, error: null, reused: true };
      }
      return { browserId: null, error: `该账号已有对应窗口: ${b.name} (ID: ${b.id})` };
    }
  }

  try {
    // 遇到"请求频繁"时最多重试 3 次，每次等待时间递增
    const MAX_RETRIES = 3;
    const RATE_LIMIT_PATTERN = /请求频繁|rate.?limit|too.?many.?request/i;

    for (let attempt = 1; attempt <= MAX_RETRIES; attempt++) {
      const result = await api.request('/browser/update', jsonData, 30000);
      if (result.success) {
        const browserId = result.data && result.data.id;
        if (!browserId) return { browserId: null, error: 'API返回成功但未获取到ID' };
        const browserSeq = result.data.seq ?? result.data.browserSeq ?? result.data.browser_seq ?? null;
        return { browserId, browserSeq, error: null };
      }

      const msg = result.msg || '';
      if (RATE_LIMIT_PATTERN.test(msg) && attempt < MAX_RETRIES) {
        const waitMs = attempt * 2000;  // 2s, 4s
        console.log(`[BitAPI] 创建浏览器请求频繁，${waitMs / 1000}s 后重试 (${attempt}/${MAX_RETRIES}): ${msg}`);
        await new Promise(r => setTimeout(r, waitMs));
        continue;
      }

      return { browserId: null, error: msg || '创建失败' };
    }

    return { browserId: null, error: '请求频繁，重试次数已耗尽' };
  } catch (e) {
    return { browserId: null, error: `请求异常: ${e.message}` };
  }
}

/**
 * 逐个删除浏览器窗口（带回调）
 * @param {string[]} browserIds - 要删除的浏览器 ID 数组
 * @param {Function|null} [callback=null] - 每次删除后的回调，接收 (browserId, success, msg)
 * @returns {Promise<{successCount: number, total: number}>} 删除统计
 */
async function deleteBrowsersBatch(browserIds, callback = null) {
  const api = getApi();
  const normalizedIds = Array.from(new Set((Array.isArray(browserIds) ? browserIds : []).filter(Boolean)));
  let successCount = 0;

  for (let start = 0; start < normalizedIds.length; start += 100) {
    const chunk = normalizedIds.slice(start, start + 100);
    try {
      // 中文注释：优先走比特浏览器原生批量接口，显著缩短大批量删除耗时。
      const batchResult = await api.deleteBrowsers(chunk);
      if (batchResult && batchResult.success === true) {
        successCount += chunk.length;
        if (callback) chunk.forEach(browserId => callback(browserId, true, ''));
        continue;
      }
    } catch (_) {}

    // 中文注释：批量接口不可用时再回退到单个删除，保持兼容旧环境。
    for (let i = 0; i < chunk.length; i++) {
      const browserId = chunk[i];
      const result = await api.deleteBrowser(browserId);
      const success = result.success === true;
      if (success) successCount++;
      if (callback) callback(browserId, success, success ? '' : (result.msg || ''));
      if (i < chunk.length - 1) await new Promise(r => setTimeout(r, 80));
    }
  }

  return { successCount, total: normalizedIds.length };
}

// ==================== 默认浏览器模板 ====================

const DEFAULT_BROWSER_TEMPLATE = {
  browserFingerPrint: {
    coreVersion: '148',
    ostype: 'PC',
    os: 'Win32',
    architecture: 'x86',
    osVersion: '',
    platformVersion: '10.0.0',
    version: '',
    userAgent: 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/148.0.7778.96 Safari/537.36',
    isIpCreateTimeZone: true,
    isIpCreatePosition: true,
    isIpCreateDisplayLanguage: true,
    isIpCreateLanguage: true,
    webRTC: '3',
    position: '1',
    resolutionType: '0',
    resolution: '1920 x 1080',
    openWidth: 1280,
    openHeight: 720,
    fontType: '0',
    canvas: '0',
    webGL: '0',
    webGLMeta: '0',
    audioContext: '0',
    mediaDevice: '1',
    speechVoices: '0',
    hardwareConcurrency: '6',
    deviceMemory: '8',
    deviceInfoEnabled: true,
    clientRectNoiseEnabled: true,
    doNotTrack: '0',
    flash: '1',
    portScanProtect: '0',
    colorDepth: 24,
    devicePixelRatio: 1,
    enablePlugins: false,
    windowSizeLimit: true,
    coreProduct: 'chrome',
    navigatorVendor: 'Google Inc.',
    defaultAccuracy: 10,
  },
  proxyMethod: 2,
  proxyType: 'noproxy',
  ipCheckService: 'ip-api',
  syncTabs: false,
  syncCookies: true,
  syncIndexedDb: true,
  syncLocalStorage: true,
  syncBookmarks: false,
  syncAuthorization: true,
  syncHistory: false,
  syncGoogleAccount: false,
  syncExtensions: false,
  syncUserExtensions: false,
  syncSessions: false,
  allowedSignin: false,
  clearCacheFilesBeforeLaunch: false,
  clearCookiesBeforeLaunch: false,
  clearHistoriesBeforeLaunch: false,
  randomFingerprint: false,
  muteAudio: false,
  disableGpu: false,
  enableBackgroundMode: false,
  credentialsEnableService: false,
  disableTranslatePopup: false,
  disableClipboard: false,
  disableNotifications: false,
  memorySaver: false,
  abortImage: false,
  abortMedia: false,
  stopWhileNetError: false,
  stopWhileCountryChange: false,
  stopWhileIpChange: false,
  isRandomFinger: true,
  remarkType: 1,
  duplicateCheck: 0,
  workbench: 'localserver',
};

module.exports = {
  BitBrowserAPI,
  getApi,
  resetApi,
  openBrowser,
  openBrowserWithRetry,
  setOpenBrowserConcurrency,
  closeBrowser,
  getBrowserListSimple,
  createBrowserFromAccount,
  deleteBrowsersBatch,
  DEFAULT_BROWSER_TEMPLATE,
  _private: { Semaphore, openBrowserSemaphore: _openBrowserSem, collectBrowserPages, parseAccountProxy },
};