/**
 * 省胜优铺 · 授权客户端模块（性能+安全优化版）
 * ============================================
 * 优化点：
 *  1. 本地授权状态缓存（内存 LRU），避免每个 HTML 渲染都查 DB + 算机器码
 *  2. 机器码计算缓存（进程内一次）
 *  3. 激活时客户端独立验签授权码（OWN_SECRET），并用授权码内嵌的 plan 决定版权，
 *     不盲信授权服务器响应体（防中间人/劫持篡改 branded 字段）
 * ============================================
 */
const crypto = require('crypto');
const os = require('os');

// 授权服务器地址（生产必须 HTTPS）
const LICENSE_SERVER = process.env.SSYP_LICENSE_SERVER || 'https://lic.ssypco.com';

// 验证授权码签名的密钥（必须与授权服务器 LICENSE_SECRET 一致）
const OWN_SECRET = process.env.SSYP_LICENSE_SECRET;
if (!OWN_SECRET || OWN_SECRET.length < 32) {
  console.error('❌ ssyp-license: 必须设置 SSYP_LICENSE_SECRET，禁止在未配置密钥时运行（否则授权可被伪造）');
}

const BRAND = {
  name: '省胜优铺',
  website: 'https://ssypco.com',
  copyright: 'Powered by 省胜优铺 · 电商解决方案',
};

// ---------- 内存缓存 ----------
let _licenseCache = null;   // 授权状态缓存（读取后 30s 有效）
let _cacheTime = 0;
const CACHE_TTL = 30000;
let _machineIdCache = null;

function b64urlDecode(str) {
  try {
    let s = String(str).replace(/-/g, '+').replace(/_/g, '/');
    while (s.length % 4) s += '=';
    return Buffer.from(s, 'base64').toString('utf8');
  } catch { return null; }
}

/** 本地验签授权码（不依赖网络，防伪造/防中间人篡改） */
function parseAndVerify(code) {
  if (!code || typeof code !== 'string') return { ok: false };
  // 未配置验证密钥时，无法信任任何授权码（不允许激活，但保留只读状态查询）
  if (!OWN_SECRET || OWN_SECRET.length < 32) {
    return { ok: false, error: '服务器未配置 SSYP_LICENSE_SECRET，无法验证授权码' };
  }
  const parts = code.split('.');
  if (parts.length !== 3) return { ok: false };
  const [header, payload, signature] = parts;
  const expected = crypto.createHmac('sha256', OWN_SECRET).update(`${header}.${payload}`).digest('hex');
  const a = Buffer.from(signature); const b = Buffer.from(expected);
  const len = Math.max(a.length, b.length);
  const ab = Buffer.alloc(len); a.copy(ab);
  const bb = Buffer.alloc(len); b.copy(bb);
  if (len === 0 || !crypto.timingSafeEqual(ab, bb)) return { ok: false };
  try {
    const pl = JSON.parse(b64urlDecode(payload));
    if (!pl.lid || !pl.domain || !pl.plan) return { ok: false };
    return { ok: true, payload: pl };
  } catch { return { ok: false }; }
}

/** 机器码（进程内缓存，仅计算一次） */
function getMachineId() {
  if (_machineIdCache) return _machineIdCache;
  try {
    const ifaces = os.networkInterfaces();
    let mac = '';
    for (const name of Object.keys(ifaces)) {
      for (const iface of ifaces[name]) {
        if (!iface.internal && iface.mac && iface.mac !== '00:00:00:00:00:00') {
          mac = iface.mac; break;
        }
      }
      if (mac) break;
    }
    const raw = mac + '|' + os.hostname() + '|' + os.platform();
    _machineIdCache = crypto.createHash('sha256').update(raw).digest('hex').substring(0, 24).toUpperCase();
  } catch {
    _machineIdCache = 'UNKNOWN_MACHINE';
  }
  return _machineIdCache;
}

/** 读取本地授权状态（带缓存，避免高频渲染查库） */
function getLocalLicense(force = false) {
  if (!force && _licenseCache && (Date.now() - _cacheTime) < CACHE_TTL) {
    return _licenseCache;
  }
  let license = { type: 'free', domain: '', activated: false };
  try {
    const { get } = require('../utils/db');
    const record = get("SELECT value FROM system_config WHERE key='ssyp_license'") || {};
    if (record.value) {
      const parsed = JSON.parse(record.value);
      if (parsed && parsed.type && parsed.activated) {
        license = { ...license, ...parsed };
      }
    }
  } catch (e) {
    console.error('[ssyp-license] 读取本地授权失败:', e.message);
  }
  license.machineId = getMachineId();
  _licenseCache = license;
  _cacheTime = Date.now();
  return license;
}

/** 激活（本地验签 + 调授权服务器记录绑定） */
async function activateLicense(licenseCode, domain) {
  // 1. 本地先验签，确保授权码真实有效、并拿到准确的 plan（决定版权）
  const verified = parseAndVerify(licenseCode);
  if (!verified.ok) {
    return { ok: false, message: '授权码签名无效，请检查后重试或重新购买' };
  }
  const d = String(domain || '').trim().toLowerCase();
  if (verified.payload.domain !== d) {
    return { ok: false, message: '域名与授权码绑定域名不一致：应为 ' + verified.payload.domain };
  }

  // 2. 调授权服务器完成机器码登记绑定（真正的"锁机"在这）
  try {
    const controller = new AbortController();
    const timer = setTimeout(() => controller.abort(), 15000);
    const resp = await fetch(`${LICENSE_SERVER}/api/activate`, {
      method: 'POST',
      headers: { 'Content-Type': 'application/json' },
      body: JSON.stringify({ license_code: licenseCode, domain: d, system_id: getMachineId() }),
      signal: controller.signal,
    });
    clearTimeout(timer);
    const data = await resp.json();
    if (!data.ok) return { ok: false, message: data.message || '激活失败' };

    // 3. 用「本地验签的 plan」而不是响应体的 branded 决定版权（防篡改）
    const type = verified.payload.plan === 'P599' ? 'unbranded_599' : 'branded_199';
    const license = { type, domain: d, activated: true, licenseCode, activatedAt: Date.now() };
    saveLocalLicense(license);
    // 同步 v1.1.0 功能解锁：付费即把 license_type 设为 lifetime（全功能解锁）
    setLicenseType('lifetime');
    invalidateCache();
    return { ok: true, message: data.message, license };
  } catch (e) {
    return { ok: false, message: '无法连接授权服务器，请检查网络或稍后重试' };
  }
}

/**
 * 同步 v1.1.0 的原生授权体系字段（system_config.license_type）
 * - 激活 199/599 → 'lifetime'（全部功能解锁）
 * - 免费 → 'free'
 * 这样 v1.1.0 混淆层的 isFeatureEnabled/getLicenseType 会自动识别，
 * 无需改动任何混淆代码即可实现“付费解锁全部功能”。
 */
function setLicenseType(type) {
  try {
    const { run } = require('../utils/db');
    run(
      "INSERT INTO system_config(key, value) VALUES('license_type', ?) " +
      "ON CONFLICT(key) DO UPDATE SET value=excluded.value",
      [type]
    );
  } catch (e) {
    console.error('[ssyp-license] 同步 license_type 失败:', e.message);
  }
}

/** 根据本地授权状态同步 license_type（供启动时调用，确保重启后状态一致） */
function syncFeatureUnlock() {
  const lic = getLocalLicense();
  setLicenseType(lic.activated ? 'lifetime' : 'free');
  return lic.activated;
}

function saveLocalLicense(license) {
  try {
    const { run } = require('../utils/db');
    run(
      "INSERT INTO system_config(key, value) VALUES('ssyp_license', ?) " +
      "ON CONFLICT(key) DO UPDATE SET value=excluded.value",
      [JSON.stringify(license)]
    );
  } catch (e) {
    console.error('[ssyp-license] 保存本地授权失败:', e.message);
  }
}

function invalidateCache() { _licenseCache = null; _cacheTime = 0; }

/** 当前应显示的版权：599→null(不注入)；否则省胜优铺版权 */
function getBranding() {
  const lic = getLocalLicense();
  if (lic.type === 'unbranded_599') return null;
  return BUILD_BRAND_HTML();
}

function BUILD_BRAND_HTML() {
  // name / website 来自常量，无注入面
  const safeName = String(BRAND.name).replace(/</g, '&lt;').replace(/>/g, '&gt;');
  const safeUrl = String(BRAND.website).replace(/</g, '&lt;').replace(/>/g, '&gt;');
  return `<div id="litemall-copyright" style="text-align:center;padding:16px 0;color:#999;font-size:13px;line-height:1.8;border-top:1px solid #eee;">
  <a href="${safeUrl}" target="_blank" rel="noopener" style="color:#999;text-decoration:none;">${safeName}</a> 提供技术支持 · <a href="${safeUrl}" target="_blank" style="color:#4A7CF7;text-decoration:none;">${safeUrl}</a>
</div>`;
}

module.exports = {
  getMachineId, getLocalLicense, activateLicense, getBranding, BRAND,
  parseAndVerify, invalidateCache, setLicenseType, syncFeatureUnlock,
};
