import { describe, expect, it } from 'vitest';
import { syncWithICloud, MockICloudFileSystem } from '../src/services/sync/icloudSync';
import { setupDailyReminder, setupCreditCardReminder, cancelAllReminders, MockNotificationScheduler } from '../src/services/reminder';
import { exportRules, importRules, parseRuleBundle, mergeRules, validateRule, ruleBundleChecksum, MockRuleFileSync, type RuleBundle } from '../src/services/ruleSync';
import { isTransactionIntent, processChatMessage, createConversation, appendMessage } from '../src/ai/chatAssistant';
import type { AiProvider, ChatMessage } from '../src/domain/ai';
import { calculateMonthlyStats, generatePlainTextSummary } from '../src/ai/monthlySummary';
import { groupByMonth, groupByCategory, dailyExpenseMap } from '../src/domain/chartStats';
import type { Transaction, Rule } from '../src/domain/types';
import type { CreditCard } from '../src/domain/creditCards';

const tx = (over: Partial<Transaction>): Transaction => ({
  id: 't1', date: '2026-07-10', flag: '*', postings: [], tags: [], links: [], source: 'mobile.bean', raw: '',
  ...over,
});

const sampleTx: Transaction[] = [
  tx({ id: 't1', date: '2026-07-05', postings: [{ account: 'Assets:Alipay', amount: '-100', currency: 'CNY' }, { account: 'Expenses:Food', amount: '100', currency: 'CNY' }] }),
  tx({ id: 't2', date: '2026-07-10', postings: [{ account: 'Assets:Bank', amount: '5000', currency: 'CNY' }, { account: 'Income:Salary', amount: '-5000', currency: 'CNY' }] }),
];

class MockProvider implements AiProvider {
  constructor(public readonly config: { id: string; name: string; apiKey: string; baseUrl: string; model: string }, public responses: string[] = []) {}
  async chat(_messages: ChatMessage[] | Parameters<AiProvider['chat']>[0]): Promise<string> {
    return this.responses.shift() ?? 'AI 回复';
  }
}

// ============ icloudSync ============

describe('icloudSync', () => {
  it('iCloud 不可用 → unavailable', async () => {
    const fs = new MockICloudFileSystem();
    fs.available = false;
    const result = await syncWithICloud(fs, 'local', '2026-01-01');
    expect(result.action).toBe('unavailable');
  });

  it('首次（远程无文件）→ pushed', async () => {
    const fs = new MockICloudFileSystem();
    const result = await syncWithICloud(fs, 'local-content', '2026-01-01');
    expect(result.action).toBe('pushed');
  });

  it('内容相同 → noop', async () => {
    const fs = new MockICloudFileSystem();
    fs.setRemoteFile('main.bean', 'same', '2026-01-01');
    const result = await syncWithICloud(fs, 'same', '2026-01-01');
    expect(result.action).toBe('noop');
  });

  it('远程有更新 → pulled', async () => {
    const fs = new MockICloudFileSystem();
    fs.setRemoteFile('main.bean', 'remote-new', '2026-07-14');
    const result = await syncWithICloud(fs, 'local', '2026-01-01');
    expect(result.action).toBe('pulled');
  });

  it('本地有更新 → pushed', async () => {
    const fs = new MockICloudFileSystem();
    fs.setRemoteFile('mobile.bean', 'old', '2020-01-01');
    const result = await syncWithICloud(fs, 'new-local', '2026-07-14');
    expect(result.action).toBe('pushed');
  });
});

// ============ reminder ============

describe('reminder', () => {
  it('setupDailyReminder 调度每日提醒', async () => {
    const scheduler = new MockNotificationScheduler();
    const id = await setupDailyReminder(scheduler, 20, 0);
    expect(id).toBeTruthy();
    expect(scheduler.scheduled).toHaveLength(1);
    expect(scheduler.scheduled[0].hour).toBe(20);
  });

  it('setupCreditCardReminder 调度账单日+还款日提醒', async () => {
    const scheduler = new MockNotificationScheduler();
    const card: CreditCard = { id: 'c1', name: '招行', lastFour: '1234', bankName: 'CMB', billingDay: 5, paymentDay: 25, creditLimit: '10000', currency: 'CNY', linkedAccount: 'Liabilities:CreditCard:CMB' };
    const ids = await setupCreditCardReminder(scheduler, card);
    expect(ids).toHaveLength(2);  // 账单日 + 还款日
    expect(scheduler.scheduled).toHaveLength(2);
  });

  it('cancelAllReminders 清空', async () => {
    const scheduler = new MockNotificationScheduler();
    await setupDailyReminder(scheduler);
    await cancelAllReminders(scheduler);
    expect(scheduler.scheduled).toHaveLength(0);
  });
});

// ============ ruleSync ============

describe('ruleSync', () => {
  const rules: Rule[] = [
    { id: 'r1', priority: 10, sourceAccount: 'Assets:Alipay', categoryAccount: 'Expenses:Food', hits: 0 },
    { id: 'r2', priority: 5, sourceAccount: 'Assets:Bank', categoryAccount: 'Expenses:Transport', hits: 0 },
  ];

  it('exportRules 写入 JSON', async () => {
    const fs = new MockRuleFileSync();
    await exportRules(rules, undefined, fs, '/tmp/rules.json');
    expect(fs.files.has('/tmp/rules.json')).toBe(true);
    const content = fs.files.get('/tmp/rules.json')!;
    expect(content).toContain('r1');
  });

  it('importRules 往返', async () => {
    const fs = new MockRuleFileSync();
    await exportRules(rules, undefined, fs, '/tmp/rules.json');
    const bundle = await importRules(fs, '/tmp/rules.json');
    expect(bundle.rules).toHaveLength(2);
    expect(bundle.version).toBe(1);
  });

  it('parseRuleBundle 拒绝错误版本', () => {
    expect(() => parseRuleBundle('{"version":99,"rules":[]}')).toThrow('不支持的规则包版本');
  });

  it('validateRule 校验', () => {
    expect(validateRule({ id: 'x', priority: 1, sourceAccount: 'a', categoryAccount: 'b', hits: 0 })).toBe(true);
    expect(validateRule({ id: 'x' })).toBe(false);
  });

  it('mergeRules 按 id 去重（导入覆盖）', () => {
    const existing: Rule[] = [{ id: 'r1', priority: 1, sourceAccount: 'A', categoryAccount: 'C', hits: 0 }];
    const imported: Rule[] = [{ id: 'r1', priority: 10, sourceAccount: 'A2', categoryAccount: 'C2', hits: 0 }];
    const merged = mergeRules(existing, imported);
    expect(merged).toHaveLength(1);
    expect(merged[0].priority).toBe(10);  // 被覆盖
  });

  it('ruleBundleChecksum 一致性', () => {
    const bundle: RuleBundle = { version: 1, exportedAt: 'now', rules: [] };
    expect(ruleBundleChecksum(bundle)).toBe(ruleBundleChecksum(bundle));
  });
});

// ============ chatAssistant ============

describe('chatAssistant', () => {
  it('isTransactionIntent 识别记账意图', () => {
    expect(isTransactionIntent('买了杯咖啡35元')).toBe(true);
    expect(isTransactionIntent('今天天气不错')).toBe(false);
    expect(isTransactionIntent('消费100')).toBe(true);
  });

  it('processChatMessage 记账意图返回 bill_card', async () => {
    const provider = new MockProvider({} as never, [JSON.stringify({ type: 'expense', amount: '35', currency: 'CNY', counterparty: '星巴克', narration: '咖啡', time: '2026-07-13' })]);
    const result = await processChatMessage('星巴克花了35', provider);
    expect(result.type).toBe('bill_card');
    expect(result.billCards).toHaveLength(1);
  });

  it('processChatMessage 非记账意图返回 text', async () => {
    const provider = new MockProvider({} as never, ['这是AI回复']);
    const result = await processChatMessage('你好', provider);
    expect(result.type).toBe('text');
  });

  it('createConversation + appendMessage', () => {
    const conv = createConversation();
    const conv2 = appendMessage(conv, { role: 'user', content: 'hello' });
    expect(conv2.messages).toHaveLength(1);
  });
});

// ============ monthlySummary ============

describe('monthlySummary', () => {
  it('calculateMonthlyStats', () => {
    const stats = calculateMonthlyStats(sampleTx, 2026, 7);
    expect(stats.totalExpense).toBe('100');
    expect(stats.totalIncome).toBe('5000');
    expect(stats.transactionCount).toBe(2);
  });

  it('generatePlainTextSummary 含统计数据', () => {
    const stats = calculateMonthlyStats(sampleTx, 2026, 7);
    const text = generatePlainTextSummary(stats);
    expect(text).toContain('2026年7月');
    expect(text).toContain('100');
    expect(text).toContain('5000');
  });
});

// ============ charts 纯函数 ============

describe('charts 纯函数', () => {
  it('groupByMonth', () => {
    const data = groupByMonth(sampleTx);
    expect(data).toHaveLength(1);
    expect(data[0].month).toBe('2026-07');
    expect(data[0].expense).toBe(100);
    expect(data[0].income).toBe(5000);
  });

  it('groupByCategory', () => {
    const data = groupByCategory(sampleTx);
    expect(data.length).toBeGreaterThan(0);
    expect(data[0].category).toContain('Food');
    expect(data[0].percentage).toBe(100);  // 只有一个支出分类
  });

  it('dailyExpenseMap', () => {
    const map = dailyExpenseMap(sampleTx);
    expect(map.get('2026-07-05')).toBe(100);
    expect(map.has('2026-07-10')).toBe(false);  // 工资不是 Expenses
  });
});