const { app, BrowserWindow, ipcMain, clipboard, dialog, shell, session, safeStorage } = require('electron');
const path = require('path');
const fs = require('fs');
const { Readable, Transform } = require('stream');
const { pipeline } = require('stream/promises');

const DL_UA = 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0 Safari/537.36';
const RELEASES_API = 'https://api.github.com/repos/lofyer/peoplelib/releases/latest';
const RELEASES_PAGE = 'https://github.com/lofyer/peoplelib/releases';

function parseVersion(v) {
  return String(v || '').replace(/^v/i, '').trim().split('.').map((n) => parseInt(n, 10) || 0);
}

function compareVersion(a, b) {
  const pa = parseVersion(a);
  const pb = parseVersion(b);
  const len = Math.max(pa.length, pb.length);
  for (let i = 0; i < len; i++) {
    const x = pa[i] || 0;
    const y = pb[i] || 0;
    if (x !== y) return x > y ? 1 : -1;
  }
  return 0;
}

async function checkUpdate() {
  const current = app.getVersion();
  const ac = new AbortController();
  const timer = setTimeout(() => ac.abort(), 15000);
  let res;
  try {
    res = await fetchWithProxy(RELEASES_API, {
      headers: { 'User-Agent': DL_UA, 'Accept': 'application/vnd.github+json' },
      signal: ac.signal
    });
  } catch (e) {
    if (e && e.name === 'AbortError') throw new Error('检查更新超时，请检查网络或代理设置');
    throw e;
  } finally {
    clearTimeout(timer);
  }
  if (!res.ok) throw new Error(`检查更新失败: ${res.status}`);
  const json = await res.json();
  const latest = json.tag_name || json.name || '';
  return {
    current,
    latest: String(latest).replace(/^v/i, ''),
    hasUpdate: compareVersion(latest, current) > 0,
    url: json.html_url || RELEASES_PAGE,
    notes: json.body || ''
  };
}

function filenameFromResponse(res, fallback) {
  const cd = res.headers.get('content-disposition') || '';
  let m = cd.match(/filename\*=(?:UTF-8'')?([^;]+)/i) || cd.match(/filename="?([^";]+)"?/i);
  if (m) { try { return decodeURIComponent(m[1].trim()); } catch (e) { return m[1].trim(); } }
  try {
    const u = new URL(res.url);
    const base = path.basename(u.pathname);
    if (base && /\.[a-z0-9]{2,5}$/i.test(base)) return decodeURIComponent(base);
  } catch (e) { /* ignore */ }
  return fallback || 'download.bin';
}

app.setName('PeopleLib');

const userDataDir = app.isPackaged
  ? path.join(path.dirname(app.getPath('exe')), 'data')
  : path.join(app.getPath('appData'), 'PeopleLib');
app.setPath('userData', userDataDir);

const sources = require('./src/sources');
const library = require('./src/library/store');
const zlibAuth = require('./src/sources/zlib-auth');
const semanticKey = require('./src/sources/semantic-key');
const settings = require('./src/settings');
const { setProxy, getProxy, fetchWithProxy } = require('./src/sources/http');
zlibAuth.init(userDataDir);
semanticKey.init(userDataDir, safeStorage);
settings.init(userDataDir);
// 启动时从持久化设置恢复代理
try {
  setProxy(settings.get('proxy', ''));
} catch (e) {
  console.warn('代理配置无效，已改为直连:', e.message);
  setProxy('');
}

// 书库目录：默认 <userData>/library，用户可在设置中更改
const DEFAULT_LIBRARY_DIR = path.join(userDataDir, 'library');
try {
  library.init(settings.get('libraryDir', '') || DEFAULT_LIBRARY_DIR);
} catch (e) {
  console.warn('自定义书库目录不可用，已回退到默认目录:', e.message);
  library.init(DEFAULT_LIBRARY_DIR);
}
// 首次运行时把旧版本散落在 userData 根目录的书库数据导入一次
if (!settings.get('legacyImported', false)) {
  try {
    library.importLegacy(userDataDir);
    settings.set('legacyImported', true);
  } catch (e) {
    console.warn('旧书库导入失败:', e.message);
  }
}

let mainWindow;
let activeDownloads = 0;

function createWindow() {
  mainWindow = new BrowserWindow({
    width: 1240,
    height: 840,
    minWidth: 940,
    minHeight: 620,
    frame: false,
    backgroundColor: '#141414',
    title: 'PeopleLib 文献库',
    webPreferences: {
      preload: path.join(__dirname, 'preload.js'),
      contextIsolation: true,
      nodeIntegration: false
    }
  });
  mainWindow.loadFile(path.join(__dirname, 'src', 'ui', 'index.html'));
}

function notifyLibraryChanged() {
  if (mainWindow && !mainWindow.isDestroyed()) {
    mainWindow.webContents.send('library:changed');
  }
}

library.setChangeListener(notifyLibraryChanged);

app.whenReady().then(() => {
  // 应用代理到 Chromium defaultSession（影响 net.fetch、窗口加载、所有请求）
  const p = getProxy();
  if (p) {
    session.defaultSession.setProxy({ proxyRules: p }).catch(() => {});
  }
  createWindow();
  // 启动时扫描书库目录，用户手动放进 files/ 的书会自动入库
  try { library.scan(); } catch (e) { /* ignore */ }
  app.on('activate', () => {
    if (BrowserWindow.getAllWindows().length === 0) createWindow();
  });
});

app.on('window-all-closed', () => {
  if (process.platform !== 'darwin') app.quit();
});

function wrap(promise) {
  return promise
    .then((data) => ({ ok: true, data }))
    .catch((err) => ({ ok: false, error: err.message || String(err) }));
}

// 数据源
ipcMain.handle('sources:list', () => ({ ok: true, data: sources.listSources() }));
ipcMain.handle('source:list', (_e, sourceId, page) => wrap(sources.getSource(sourceId).list(page)));
ipcMain.handle('source:search', (_e, sourceId, keyword, page) => wrap(sources.getSource(sourceId).search(keyword, page)));
ipcMain.handle('source:detail', (_e, sourceId, postId) => wrap(sources.getSource(sourceId).detail(postId)));
ipcMain.handle('source:download', (_e, sourceId, postId) => wrap(sources.getSource(sourceId).download(postId)));

// 代理配置：全局生效，影响所有数据源的 HTTP 请求与文件下载
ipcMain.handle('proxy:get', () => ({ ok: true, data: getProxy() }));
ipcMain.handle('proxy:set', (_e, url) => {
  const previous = getProxy();
  try {
    const u = String(url || '').trim();
    setProxy(u);
    settings.set('proxy', u);
    session.defaultSession.setProxy({ proxyRules: u || 'direct://' }).catch(() => {});
    return { ok: true };
  } catch (e) {
    try { setProxy(previous); } catch (rollbackError) { /* ignore */ }
    return { ok: false, error: e.message || String(e) };
  }
});

// Z-Library 凭据
ipcMain.handle('zlib:hasCreds', () => ({ ok: true, data: zlibAuth.hasCreds() }));
ipcMain.handle('zlib:login', (_e, email, password) => wrap(sources.getSource('zlib').login(email, password)));
ipcMain.handle('zlib:logout', () => wrap(sources.getSource('zlib').logout()));

// Semantic Scholar API Key
ipcMain.handle('semanticScholar:keyStatus', () => ({ ok: true, data: semanticKey.status() }));
ipcMain.handle('semanticScholar:setKey', (_e, key) => wrap(Promise.resolve().then(() => semanticKey.write(key))));
ipcMain.handle('semanticScholar:clearKey', () => wrap(Promise.resolve().then(() => semanticKey.clear())));

// 书库目录管理
ipcMain.handle('library:getDir', () => ({ ok: true, data: { dir: library.getRoot(), isDefault: library.getRoot() === DEFAULT_LIBRARY_DIR } }));
ipcMain.handle('library:pickDir', async () => {
  const r = await dialog.showOpenDialog(mainWindow, {
    title: '选择书库目录',
    defaultPath: library.getRoot(),
    properties: ['openDirectory', 'createDirectory']
  });
  if (r.canceled || !r.filePaths.length) return { ok: true, data: null };
  return { ok: true, data: r.filePaths[0] };
});
// migrate=true 时把现有数据搬到新目录，否则只切换（旧目录原样保留）
ipcMain.handle('library:setDir', (_e, dir, migrate) => wrap(Promise.resolve().then(() => {
  const dest = String(dir || '').trim();
  if (!dest) throw new Error('目录不能为空');
  if (activeDownloads) throw new Error('请等待当前下载完成后再切换书库目录');
  const previousSetting = settings.get('libraryDir', '');
  const previousRoot = library.getRoot();
  try {
    if (migrate) {
      library.migrateTo(dest);
    } else {
      library.init(dest);
    }
    const r = library.scan();
    settings.set('libraryDir', dest);
    if (migrate) library.finalizeMigration();
    notifyLibraryChanged();
    return { dir: library.getRoot(), ...r };
  } catch (e) {
    if (migrate) {
      try { library.rollbackMigration(); } catch (rollbackError) { /* ignore */ }
    } else {
      try { library.init(previousRoot); } catch (rollbackError) { /* ignore */ }
    }
    try { settings.set('libraryDir', previousSetting); } catch (rollbackError) { /* ignore */ }
    throw e;
  }
})));
ipcMain.handle('library:scan', () => wrap(Promise.resolve().then(() => {
  const r = library.scan();
  notifyLibraryChanged();
  return r;
})));

// 本地书库
ipcMain.handle('library:list', () => wrap(Promise.resolve(library.list())));
ipcMain.handle('library:get', (_e, id) => wrap(Promise.resolve(library.get(id))));
ipcMain.handle('library:findBySource', (_e, sourceId, postId) => wrap(Promise.resolve(library.findBySource(sourceId, postId))));
ipcMain.handle('library:add', (_e, item) => wrap(Promise.resolve(library.add(item))));
ipcMain.handle('library:update', (_e, id, patch) => wrap(Promise.resolve(library.update(id, patch))));
ipcMain.handle('library:remove', (_e, id, deleteFiles) => wrap(Promise.resolve(library.remove(id, deleteFiles))));

// 下载文件：默认直接存入书库目录并挂到条目上；
// 开启"下载前询问保存位置"后改为弹保存框（此时文件在书库外，记绝对路径）。
// meta 用于文件不属于任何已有条目时自动建条目，避免"下载了但书库不知道"。
ipcMain.handle('download:file', async (_e, url, suggestName, entryId, extraHeaders, meta) => {
  activeDownloads++;
  let partial = '';
  let res = null;
  let bodyHandled = false;
  try {
    const parsedUrl = new URL(String(url || ''));
    if (!/^https?:$/.test(parsedUrl.protocol)) throw new Error('仅支持 HTTP 或 HTTPS 下载链接');
    const askSavePath = settings.get('askSavePath', false);
    const suggested = library.sanitize(suggestName || 'download.bin');
    let target;
    if (askSavePath) {
      const save = await dialog.showSaveDialog(mainWindow, {
        title: '保存文件',
        defaultPath: path.join(library.filesDir(), suggested)
      });
      if (save.canceled || !save.filePath) return { ok: true, data: { canceled: true } };
      target = save.filePath;
    }

    const headers = { 'User-Agent': DL_UA, ...(extraHeaders || {}) };
    headers['Referer'] = parsedUrl.origin + '/';
    const ac = new AbortController();
    const timer = setTimeout(() => ac.abort(), 30000);
    try {
      res = await fetchWithProxy(parsedUrl.toString(), {
        redirect: 'follow',
        headers,
        signal: ac.signal
      });
    } finally {
      clearTimeout(timer);
    }
    if (!res.ok) throw new Error(`下载失败: ${res.status}`);

    const respName = filenameFromResponse(res, suggestName);
    const hasExt = suggestName && /\.[a-z0-9]{2,5}$/i.test(suggestName);
    const defaultName = library.sanitize(hasExt ? suggestName : respName);
    const contentType = res.headers.get('content-type') || '';
    const expectedExt = path.extname(target || defaultName).toLowerCase();
    if (/text\/html|application\/json/i.test(contentType)
      && !['.html', '.htm', '.json', '.txt'].includes(expectedExt)) {
      throw new Error('下载地址返回了网页而不是文献文件');
    }

    if (!target) target = library.allocFilePath(defaultName);

    fs.mkdirSync(path.dirname(target), { recursive: true });
    partial = path.join(
      path.dirname(target),
      `.${path.basename(target)}.${process.pid}-${Date.now()}-${Math.random().toString(36).slice(2)}.part`
    );
    if (!res.body) throw new Error('下载响应没有文件内容');
    let transferTimer;
    const refreshTransferTimer = () => {
      clearTimeout(transferTimer);
      transferTimer = setTimeout(() => ac.abort(), 30000);
    };
    const activity = new Transform({
      transform(chunk, encoding, callback) {
        refreshTransferTimer();
        callback(null, chunk);
      }
    });
    refreshTransferTimer();
    bodyHandled = true;
    try {
      await pipeline(Readable.fromWeb(res.body), activity, fs.createWriteStream(partial, { flags: 'wx' }));
    } finally {
      clearTimeout(transferTimer);
    }
    if (askSavePath) {
      const backup = `${target}.${process.pid}-${Date.now()}.bak`;
      let backedUp = false;
      try {
        if (fs.existsSync(target)) {
          fs.renameSync(target, backup);
          backedUp = true;
        }
        fs.renameSync(partial, target);
        partial = '';
        if (backedUp) {
          try { fs.unlinkSync(backup); } catch (e) { /* 保留备份不影响下载 */ }
        }
      } catch (e) {
        try {
          if (backedUp && !fs.existsSync(target) && fs.existsSync(backup)) fs.renameSync(backup, target);
        } catch (rollbackError) { /* ignore */ }
        throw e;
      }
    } else {
      for (;;) {
        try {
          fs.linkSync(partial, target);
          break;
        } catch (e) {
          if (e.code !== 'EEXIST') throw e;
          target = library.allocFilePath(defaultName);
        }
      }
      try { fs.unlinkSync(partial); } catch (e) { /* 保留硬链接副本不影响文件 */ }
      partial = '';
    }

    // 落库：优先挂到已有条目，否则用 meta 新建
    let id = entryId;
    if (!id && meta) {
      const existing = meta.sourceId && meta.sourcePostId
        ? library.findBySource(meta.sourceId, meta.sourcePostId) : null;
      id = existing ? existing.id : library.add(meta).id;
    }
    const entry = id ? library.attachFile(id, target) : null;

    return { ok: true, data: { path: target, name: path.basename(target), entryId: id || null, entry } };
  } catch (e) {
    if (res && res.body && !bodyHandled) {
      try { await res.body.cancel(); } catch (cancelError) { /* ignore */ }
    }
    if (partial) {
      try { fs.unlinkSync(partial); } catch (cleanupError) { /* ignore */ }
    }
    if (e && (e.name === 'AbortError' || /aborted/i.test(e.message || ''))) {
      return { ok: false, error: '下载超时，请检查网络或代理设置' };
    }
    return { ok: false, error: e.message || String(e) };
  } finally {
    activeDownloads--;
  }
});

// 打开文件。没有关联程序时（例如未装 epub 阅读器）退而求其次，
// 在资源管理器里定位该文件，而不是静默失败。
ipcMain.handle('shell:openPath', async (_e, p) => {
  const target = String(p || '');
  if (!target) return { ok: false, error: '路径为空' };
  if (!fs.existsSync(target)) return { ok: false, error: '文件不存在，可能已被移动或删除' };
  const err = await shell.openPath(target);
  if (!err) return { ok: true };
  shell.showItemInFolder(target);
  return { ok: true, data: { revealed: true, reason: err } };
});
ipcMain.handle('shell:showItem', (_e, p) => { shell.showItemInFolder(p || ''); return { ok: true }; });
ipcMain.handle('shell:openExternal', async (_e, url) => {
  try {
    const target = new URL(String(url || ''));
    if (!/^https?:$/.test(target.protocol)) throw new Error('仅允许打开 HTTP 或 HTTPS 链接');
    await shell.openExternal(target.toString());
    return { ok: true };
  }
  catch (e) { return { ok: false, error: e.message || String(e) }; }
});

ipcMain.handle('dialog:pickFile', async () => {
  const r = await dialog.showOpenDialog(mainWindow, {
    title: '选择本地文献文件',
    properties: ['openFile'],
    filters: [{ name: '文献', extensions: ['pdf', 'epub', 'mobi', 'txt', 'azw3'] }, { name: '所有文件', extensions: ['*'] }]
  });
  if (r.canceled || !r.filePaths.length) return { ok: true, data: null };
  const p = r.filePaths[0];
  return { ok: true, data: { path: p, name: path.basename(p, path.extname(p)) } };
});

// 通用设置读写（目前用于"下载前询问保存位置"开关）
ipcMain.handle('settings:get', (_e, key, def) => ({ ok: true, data: settings.get(key, def) }));
ipcMain.handle('settings:set', (_e, key, value) => { settings.set(key, value); return { ok: true }; });

ipcMain.handle('app:version', () => ({ ok: true, data: app.getVersion() }));
ipcMain.handle('app:checkUpdate', () => wrap(checkUpdate()));
ipcMain.handle('copy', (_e, text) => { clipboard.writeText(String(text || '')); return { ok: true }; });

ipcMain.on('win:minimize', () => mainWindow && mainWindow.minimize());
ipcMain.on('win:maximize', () => {
  if (!mainWindow) return;
  if (mainWindow.isMaximized()) mainWindow.unmaximize(); else mainWindow.maximize();
});
ipcMain.on('win:close', () => mainWindow && mainWindow.close());