import { setDriver, getActiveDriver, listSessions } from 'cursor-history';

// 在任何操作之前强制使用特定驱动
setDriver('better-sqlite3');

// 检查当前活动的驱动
const driver = getActiveDriver();
console.log(`使用驱动：${driver}`);

// 或通过 LibraryConfig 配置
const result = await listSessions({
  sqliteDriver: 'node:sqlite'  // 为此调用强制使用 node:sqlite
});

import {
  listSessions,
  getSession,
  searchSessions,
  exportSessionToMarkdown
} from 'cursor-history';

// 列出所有会话并分页
const result = listSessions({ limit: 10 });
console.log(`找到 ${result.pagination.total} 个会话`);

for (const session of result.data) {
  console.log(`${session.id}: ${session.messageCount} 条消息`);
}

// 获取特定会话（从零开始的索引）
const session = getSession(0);
console.log(session.messages);

// 在所有会话中搜索
const results = searchSessions('authentication', { context: 2 });
for (const match of results) {
  console.log(match.match);
}

// 导出为 Markdown
const markdown = exportSessionToMarkdown(0);

import { migrateSession, migrateWorkspace } from 'cursor-history';

// 将会话移动到另一个工作区
const results = migrateSession({
  sessions: 3,  // 索引或 ID
  destination: '/path/to/new/project'
});

// 复制多个会话（保留原始）
const results = migrateSession({
  sessions: [1, 3, 5],
  destination: '/path/to/project',
  mode: 'copy'
});

// 在工作区之间迁移所有会话
const result = migrateWorkspace({
  source: '/old/project',
  destination: '/new/project'
});
console.log(`已迁移 ${result.successCount} 个会话`);

import {
  createBackup,
  restoreBackup,
  validateBackup,
  listBackups,
  getDefaultBackupDir
} from 'cursor-history';

// 创建备份
const result = await createBackup({
  outputPath: '~/my-backup.zip',
  force: true,
  onProgress: (progress) => {
    console.log(`${progress.phase}: ${progress.filesCompleted}/${progress.totalFiles}`);
  }
});
console.log(`备份已创建：${result.backupPath}`);
console.log(`会话数：${result.manifest.stats.sessionCount}`);

// 验证备份
const validation = validateBackup('~/backup.zip');
if (validation.status === 'valid') {
  console.log('备份有效');
} else if (validation.status === 'warnings') {
  console.log('备份有警告：', validation.corruptedFiles);
}

// 从备份恢复
const restoreResult = restoreBackup({
  backupPath: '~/backup.zip',
  force: true
});
console.log(`已恢复 ${restoreResult.filesRestored} 个文件`);

// 列出可用的备份
const backups = listBackups();  // 扫描 ~/cursor-history-backups/
for (const backup of backups) {
  console.log(`${backup.filename}: ${backup.manifest?.stats.sessionCount} 个会话`);
}

// 从备份读取会话而不恢复
const sessions = listSessions({ backupPath: '~/backup.zip' });

interface LibraryConfig {
  dataPath?: string;       // 自定义 Cursor 数据路径
  workspace?: string;      // 按工作区路径过滤
  limit?: number;          // 分页限制
  offset?: number;         // 分页偏移
  context?: number;        // 搜索上下文行数
  backupPath?: string;     // 从备份文件读取而不是实时数据
  sqliteDriver?: 'better-sqlite3' | 'node:sqlite';  // 强制使用特定 SQLite 驱动
  messageFilter?: MessageType[];  // 按类型过滤消息（user、assistant、tool、thinking、error）
}

import {
  listSessions,
  getSession,
  createBackup,
  isDatabaseLockedError,
  isDatabaseNotFoundError,
  isSessionNotFoundError,
  isWorkspaceNotFoundError,
  isInvalidFilterError,
  isBackupError,
  isRestoreError,
  isInvalidBackupError
} from 'cursor-history';

try {
  const result = listSessions();
} catch (err) {
  if (isDatabaseLockedError(err)) {
    console.error('数据库已锁定 - 关闭 Cursor 并重试');
  } else if (isDatabaseNotFoundError(err)) {
    console.error('未找到 Cursor 数据');
  } else if (isSessionNotFoundError(err)) {
    console.error('未找到会话');
  } else if (isWorkspaceNotFoundError(err)) {
    console.error('未找到工作区 - 请先在 Cursor 中打开项目');
  }
}

// 过滤器错误处理
try {
  const session = getSession(0, { messageFilter: ['invalid'] });
} catch (err) {
  if (isInvalidFilterError(err)) {
    console.error('无效的过滤器类型：', err.invalidTypes);
    console.error('有效类型：', err.validTypes);
  }
}

// 备份特定错误
try {
  const result = await createBackup();
} catch (err) {
  if (isBackupError(err)) {
    console.error('备份失败：', err.message);
  } else if (isInvalidBackupError(err)) {
    console.error('无效的备份文件');
  } else if (isRestoreError(err)) {
    console.error('恢复失败：', err.message);
  }
}