import { Buffer } from 'node:buffer';

import type { Page, Route } from '@playwright/test';
import { expect, test } from '@playwright/test';

const eventId = '01M00000000000000000000160';
const voucherId = '01M00000000000000000000161';
const companyId = '01M00000000000000000000162';
const projectId = '01M00000000000000000000163';
const counterpartyId = '01M00000000000000000000164';
const debitAccountId = '01M00000000000000000000165';
const creditAccountId = '01M00000000000000000000166';

interface AccountingFixtureOptions {
  initialTab?: 'pending' | 'draft';
  initialVoucher?: ReturnType<typeof voucher>;
  initialEvidence?: Array<Record<string, unknown>>;
  generateRequests?: Array<Record<string, unknown>>;
  updateRequests?: Array<Record<string, unknown>>;
  recordRequests?: Array<Record<string, unknown>>;
  verifyRequests?: Array<Record<string, unknown>>;
  reverseRequests?: Array<Record<string, unknown>>;
  reopenRequests?: Array<Record<string, unknown>>;
}

function accountingEvent() {
  return {
    publicId: eventId,
    businessNo: 'EVT-E2E-001',
    eventType: 'PAYABLE',
    sourceType: 'PAYABLE',
    sourcePublicId: '01M00000000000000000000167',
    sourceVersion: '1',
    eventSequence: 1,
    sourceEventKey: 'PAYABLE:E2E:1',
    company: { publicId: companyId, code: 'GS-E2E-001', name: '凯迪测试公司' },
    project: { publicId: projectId, code: 'XM-E2E-001', name: '记账验收项目' },
    counterparty: { publicId: counterpartyId, code: 'GY-E2E-001', name: '验收供应商' },
    businessDate: '2026-08-15',
    period: '2026-08',
    amount: '1000.00',
    currency: 'CNY',
    status: 'PENDING',
    voucherPublicId: null,
    version: 0,
    createdAt: '2026-08-15T08:00:00Z',
    allowedActions: ['GENERATE_DRAFT'],
  };
}

function voucher(overrides: Record<string, unknown> = {}) {
  return {
    publicId: voucherId,
    businessNo: 'VCH-202608-E2E001',
    eventPublicId: eventId,
    eventBusinessNo: 'EVT-E2E-001',
    company: { publicId: companyId, code: 'GS-E2E-001', name: '凯迪测试公司' },
    project: { publicId: projectId, code: 'XM-E2E-001', name: '记账验收项目' },
    period: '2026-08',
    businessDate: '2026-08-15',
    summary: '应付确认 EVT-E2E-001',
    debitTotal: '1000.00',
    creditTotal: '1000.00',
    balanceStatus: 'BALANCED',
    status: 'DRAFT',
    submittedByName: null,
    reviewedByName: null,
    exportedAt: null,
    exportBatchNo: null,
    exportSha256: null,
    exportFileId: null,
    ruleVersion: 'ACCOUNTING-RULE-V1',
    externalVoucherNo: null,
    resultAt: null,
    resultCycleNo: 0,
    evidenceFileIds: [],
    resultRecordedByName: null,
    resultRecordedAt: null,
    resultRecordRemark: null,
    resultVerifiedByName: null,
    resultVerifiedAt: null,
    resultVerifyOpinion: null,
    voidReason: null,
    version: 1,
    createdAt: '2026-08-15T08:01:00Z',
    updatedAt: '2026-08-15T08:01:00Z',
    allowedActions: ['EDIT', 'SUBMIT', 'VOID'],
    ...overrides,
  };
}

function entries() {
  const auxiliaryJson = JSON.stringify({ projectId, counterpartyId });
  return [
    {
      publicId: '01M00000000000000000000168',
      lineNo: 1,
      direction: 'DEBIT',
      account: { publicId: debitAccountId, code: '6601', name: '项目成本' },
      amount: '1000.00',
      summary: '应付确认 EVT-E2E-001',
      auxiliaryJson,
    },
    {
      publicId: '01M00000000000000000000169',
      lineNo: 2,
      direction: 'CREDIT',
      account: { publicId: creditAccountId, code: '2202', name: '应付账款' },
      amount: '1000.00',
      summary: '应付确认 EVT-E2E-001',
      auxiliaryJson,
    },
  ];
}

function voucherDetail(
  currentVoucher = voucher(),
  evidenceFiles: Array<Record<string, unknown>> = [],
  resultActions: Array<Record<string, unknown>> = [],
) {
  return { voucher: currentVoucher, event: accountingEvent(), entries: entries(), evidenceFiles, resultActions };
}

function userSession(reviewer = false) {
  return {
    authenticated: true,
    user: {
      publicId: reviewer ? '01M00000000000000000000183' : '01M00000000000000000000170',
      username: reviewer ? 'accounting-reviewer-e2e' : 'accounting-recorder-e2e',
      displayName: reviewer ? '记账复核员' : '记账登记员',
      departmentName: '财务部',
      mustChangePassword: false,
    },
    roles: [{ code: 'FINANCE_MANAGER', name: '财务管理人员', workbenchRoute: '/workbench/finance' }],
    activeRole: 'FINANCE_MANAGER',
    permissions: [
      'accounting:event:view',
      'accounting:event:generate',
      'accounting:voucher:view',
      'accounting:voucher:edit',
      'accounting:voucher:reverse-result',
      'accounting:voucher:reopen-result',
    ],
  };
}

async function installAccountingFixture(page: Page, options: AccountingFixtureOptions = {}) {
  let reviewerSession = false;
  let currentVoucher = options.initialVoucher || voucher();
  let currentEvidence: Array<Record<string, unknown>> = options.initialEvidence || [];
  const resultActions: Array<Record<string, unknown>> = [];

  await page.route('**/api/v1/**', async (route: Route) => {
    const request = route.request();
    const pathname = new URL(request.url()).pathname;
    const session = userSession(reviewerSession);

    if (pathname === '/api/v1/auth/session') {
      await route.fulfill({ json: { data: session, requestId: '01M00000000000000000000171' } });
      return;
    }
    if (pathname === '/api/v1/auth/profile') {
      await route.fulfill({ json: { data: session.user, requestId: '01M00000000000000000000172' } });
      return;
    }
    if (pathname === '/api/v1/auth/roles') {
      await route.fulfill({ json: { data: session.roles, requestId: '01M00000000000000000000173' } });
      return;
    }
    if (pathname === '/api/v1/auth/csrf') {
      await route.fulfill({
        headers: { 'set-cookie': 'XSRF-TOKEN=accounting-e2e-csrf; Path=/' },
        json: { data: { token: 'accounting-e2e-csrf' }, requestId: '01M00000000000000000000174' },
      });
      return;
    }
    if (request.method() === 'GET' && pathname === '/api/v1/accounting/accounts') {
      await route.fulfill({
        json: {
          data: [
            {
              publicId: debitAccountId,
              code: '6601',
              name: '项目成本',
              accountType: 'EXPENSE',
              auxiliaryRequired: true,
            },
            {
              publicId: creditAccountId,
              code: '2202',
              name: '应付账款',
              accountType: 'LIABILITY',
              auxiliaryRequired: true,
            },
          ],
          requestId: '01M00000000000000000000175',
        },
      });
      return;
    }
    if (request.method() === 'GET' && pathname === '/api/v1/masterdata/references') {
      await route.fulfill({
        json: {
          data: {
            companies: [accountingEvent().company],
            projects: [accountingEvent().project],
            counterparties: [accountingEvent().counterparty],
            costCategories: [],
          },
          requestId: '01M00000000000000000000176',
        },
      });
      return;
    }
    if (request.method() === 'GET' && pathname === '/api/v1/accounting/events') {
      await route.fulfill({
        json: {
          data: [accountingEvent()],
          meta: { page: 1, size: 20, totalElements: 1, totalPages: 1 },
          requestId: '01M00000000000000000000177',
        },
      });
      return;
    }
    if (request.method() === 'GET' && pathname === '/api/v1/accounting/vouchers') {
      await route.fulfill({
        json: {
          data: [currentVoucher],
          meta: { page: 1, size: 20, totalElements: 1, totalPages: 1 },
          requestId: '01M00000000000000000000178',
        },
      });
      return;
    }
    if (request.method() === 'GET' && pathname === `/api/v1/accounting/vouchers/${voucherId}`) {
      await route.fulfill({
        json: {
          data: voucherDetail(currentVoucher, currentEvidence, resultActions),
          requestId: '01M00000000000000000000179',
        },
      });
      return;
    }
    if (request.method() === 'POST' && pathname === `/api/v1/accounting/events/${eventId}/generate-draft`) {
      options.generateRequests?.push(request.postDataJSON() as Record<string, unknown>);
      await route.fulfill({
        json: { data: voucherDetail(currentVoucher), requestId: '01M00000000000000000000180' },
      });
      return;
    }
    if (request.method() === 'PATCH' && pathname === `/api/v1/accounting/vouchers/${voucherId}`) {
      const payload = request.postDataJSON() as Record<string, unknown>;
      options.updateRequests?.push(payload);
      currentVoucher = voucher({ summary: payload.summary, version: 2, updatedAt: '2026-08-15T08:02:00Z' });
      await route.fulfill({
        json: { data: voucherDetail(currentVoucher), requestId: '01M00000000000000000000181' },
      });
      return;
    }
    if (request.method() === 'POST' && pathname === '/api/v1/files') {
      currentEvidence = [
        {
          publicId: '01M00000000000000000000184',
          originalName: 'accounting-result.pdf',
          mediaType: 'application/pdf',
          sizeBytes: 20,
          sha256: 'c'.repeat(64),
          scanStatus: 'AVAILABLE',
        },
      ];
      await route.fulfill({
        json: { data: currentEvidence[0], requestId: '01M00000000000000000000185' },
      });
      return;
    }
    if (request.method() === 'POST' && pathname === `/api/v1/accounting/vouchers/${voucherId}/record-result`) {
      const payload = request.postDataJSON() as Record<string, unknown>;
      options.recordRequests?.push(payload);
      currentVoucher = voucher({
        status: 'RESULT_RECORDED',
        version: 4,
        allowedActions: ['VERIFY_RESULT'],
        externalVoucherNo: payload.externalVoucherNo,
        resultAt: payload.resultAt,
        evidenceFileIds: payload.evidenceFileIds,
        resultRecordedByName: '记账登记员',
        resultRecordedAt: '2026-08-15T08:10:00Z',
        resultRecordRemark: payload.remark,
      });
      reviewerSession = true;
      await route.fulfill({
        json: {
          data: voucherDetail(currentVoucher, currentEvidence, resultActions),
          requestId: '01M00000000000000000000186',
        },
      });
      return;
    }
    if (request.method() === 'POST' && pathname === `/api/v1/accounting/vouchers/${voucherId}/verify-result`) {
      const payload = request.postDataJSON() as Record<string, unknown>;
      options.verifyRequests?.push(payload);
      currentVoucher = voucher({
        ...currentVoucher,
        status: 'COMPLETED',
        version: 5,
        allowedActions: [],
        resultVerifiedByName: '记账复核员',
        resultVerifiedAt: '2026-08-15T08:15:00Z',
        resultVerifyOpinion: payload.opinion,
      });
      await route.fulfill({
        json: {
          data: voucherDetail(currentVoucher, currentEvidence, resultActions),
          requestId: '01M00000000000000000000187',
        },
      });
      return;
    }
    if (request.method() === 'POST' && pathname === `/api/v1/accounting/vouchers/${voucherId}/reverse-result`) {
      const payload = request.postDataJSON() as Record<string, unknown>;
      options.reverseRequests?.push(payload);
      resultActions.unshift({
        publicId: '01M00000000000000000000188',
        sequenceNo: 1,
        resultCycleNo: 0,
        actionType: 'REVERSE',
        reason: payload.reason,
        externalVoucherNo: currentVoucher.externalVoucherNo,
        resultAt: currentVoucher.resultAt,
        resultRecordedByName: currentVoucher.resultRecordedByName,
        resultRecordedAt: currentVoucher.resultRecordedAt,
        resultRecordRemark: currentVoucher.resultRecordRemark,
        resultVerifiedByName: currentVoucher.resultVerifiedByName,
        resultVerifiedAt: currentVoucher.resultVerifiedAt,
        resultVerifyOpinion: currentVoucher.resultVerifyOpinion,
        evidenceFiles: currentEvidence,
        operatedByName: '记账复核员',
        operatedAt: '2026-08-15T08:20:00Z',
        versionBefore: 5,
        versionAfter: 6,
      });
      currentVoucher = voucher({
        ...currentVoucher,
        status: 'RESULT_REVERSED',
        version: 6,
        allowedActions: ['REOPEN_RESULT'],
      });
      reviewerSession = false;
      await route.fulfill({
        json: {
          data: voucherDetail(currentVoucher, currentEvidence, resultActions),
          requestId: '01M00000000000000000000189',
        },
      });
      return;
    }
    if (request.method() === 'POST' && pathname === `/api/v1/accounting/vouchers/${voucherId}/reopen-result`) {
      const payload = request.postDataJSON() as Record<string, unknown>;
      options.reopenRequests?.push(payload);
      resultActions.unshift({
        ...resultActions[0],
        publicId: '01M00000000000000000000190',
        sequenceNo: 2,
        actionType: 'REOPEN',
        reason: payload.reason,
        operatedByName: '记账登记员',
        operatedAt: '2026-08-15T08:25:00Z',
        versionBefore: 6,
        versionAfter: 7,
      });
      currentVoucher = voucher({
        ...currentVoucher,
        status: 'EXPORTED',
        version: 7,
        resultCycleNo: 1,
        allowedActions: ['RECORD_RESULT'],
        externalVoucherNo: null,
        resultAt: null,
        evidenceFileIds: [],
        resultRecordedByName: null,
        resultRecordedAt: null,
        resultRecordRemark: null,
        resultVerifiedByName: null,
        resultVerifiedAt: null,
        resultVerifyOpinion: null,
      });
      currentEvidence = [];
      await route.fulfill({
        json: {
          data: voucherDetail(currentVoucher, currentEvidence, resultActions),
          requestId: '01M00000000000000000000191',
        },
      });
      return;
    }
    if (request.method() === 'GET') {
      await route.fulfill({
        json: {
          data: [],
          meta: { page: 1, size: 20, totalElements: 0, totalPages: 0 },
          requestId: '01M00000000000000000000182',
        },
      });
      return;
    }
    await route.fulfill({ status: 204 });
  });
}

test('PAGE-16 generates one voucher draft with the fixed rule version', async ({ page }) => {
  const generateRequests: Array<Record<string, unknown>> = [];
  await installAccountingFixture(page, { generateRequests });

  await page.goto('/finance/accounting?tab=pending');
  await expect(page.getByRole('heading', { name: '记账准备', exact: true })).toBeVisible();
  await expect(page.getByText('EVT-E2E-001', { exact: true }).first()).toBeVisible();
  await page.getByRole('button', { name: '生成草稿', exact: true }).click();

  await expect.poll(() => generateRequests.length).toBe(1);
  expect(generateRequests[0]).toEqual({ version: 0, ruleVersion: 'ACCOUNTING-RULE-V1' });
  await expect(page.getByText('凭证草稿已生成', { exact: true })).toBeVisible();
  await expect(page.getByText('借贷平衡', { exact: true })).toBeVisible();
});

test('PAGE-16 edits an auxiliary voucher directly from the list without raw JSON input', async ({ page }) => {
  const updateRequests: Array<Record<string, unknown>> = [];
  await installAccountingFixture(page, { initialTab: 'draft', updateRequests });

  await page.goto('/finance/accounting?tab=draft');
  await expect(page.getByText('VCH-202608-E2E001', { exact: true }).first()).toBeVisible();
  await page.getByRole('button', { name: '更多操作', exact: true }).click();
  await page.getByText('编辑草稿', { exact: true }).click();

  const dialog = page.locator('.t-dialog').filter({ hasText: '编辑凭证草稿' });
  await expect(dialog.getByText('项目：XM-E2E-001 记账验收项目', { exact: true }).first()).toBeVisible();
  await expect(dialog.getByText('往来单位：GY-E2E-001 验收供应商', { exact: true }).first()).toBeVisible();
  await expect(dialog.getByText('辅助核算 JSON', { exact: true })).toHaveCount(0);
  await dialog.locator('textarea').fill('核对来源维度后保存');
  await dialog.getByRole('button', { name: '保存草稿', exact: true }).click();

  await expect.poll(() => updateRequests.length).toBe(1);
  const payload = updateRequests[0];
  const payloadEntries = payload.entries as Array<Record<string, unknown>>;
  expect(payloadEntries).toHaveLength(2);
  for (const entry of payloadEntries) {
    expect(JSON.parse(String(entry.auxiliaryJson))).toEqual({ projectId, counterpartyId });
  }
  expect(payload.changeReason).toBe('核对来源维度后保存');
  await expect(dialog).toBeHidden();
  await expect(page.getByText('凭证草稿已保存', { exact: true })).toBeVisible();
});

test('PAGE-16 records evidence and preserves separate record and verification notes', async ({ page }) => {
  const recordRequests: Array<Record<string, unknown>> = [];
  const verifyRequests: Array<Record<string, unknown>> = [];
  await installAccountingFixture(page, {
    initialVoucher: voucher({ status: 'EXPORTED', version: 3, allowedActions: ['RECORD_RESULT'] }),
    recordRequests,
    verifyRequests,
  });

  await page.goto('/finance/accounting?tab=result');
  await expect(page.getByText('VCH-202608-E2E001', { exact: true }).first()).toBeVisible();
  await page.getByRole('button', { name: '更多操作', exact: true }).click();
  await page.getByText('登记记账结果', { exact: true }).click();

  const recordDialog = page.locator('.t-dialog').filter({ hasText: '登记记账结果' });
  const resultDate = await page.evaluate(() => {
    const now = new Date();
    return new Date(now.getTime() - now.getTimezoneOffset() * 60_000).toISOString().slice(0, 10);
  });
  await expect(recordDialog.locator('.t-date-picker input')).toHaveValue(resultDate);
  await recordDialog.getByPlaceholder('请输入', { exact: true }).fill('TPLUS-E2E-001');
  await recordDialog.locator('textarea').fill('人工导入成功');
  await recordDialog.locator('input[type="file"]').setInputFiles({
    name: 'accounting-result.pdf',
    mimeType: 'application/pdf',
    buffer: Buffer.from('accounting-result-evidence'),
  });
  await recordDialog.getByRole('button', { name: '上传已选文件', exact: true }).click();
  await expect(recordDialog.getByText('可用', { exact: true })).toBeVisible();
  await recordDialog.getByRole('button', { name: '确认登记记账结果', exact: true }).click();

  await expect.poll(() => recordRequests.length).toBe(1);
  expect(recordRequests[0]).toEqual({
    version: 3,
    externalVoucherNo: 'TPLUS-E2E-001',
    resultAt: resultDate,
    evidenceFileIds: ['01M00000000000000000000184'],
    remark: '人工导入成功',
  });
  await expect(recordDialog).toBeHidden();

  await page.reload();
  await page.getByRole('button', { name: '更多操作', exact: true }).click();
  await page.getByText('复核记账结果', { exact: true }).click();
  const verifyDialog = page.locator('.t-dialog').filter({ hasText: '复核记账结果' });
  await verifyDialog.locator('textarea').fill('凭证号和导入结果一致');
  await verifyDialog.getByRole('button', { name: '确认复核记账结果', exact: true }).click();

  await expect.poll(() => verifyRequests.length).toBe(1);
  expect(verifyRequests[0]).toEqual({ version: 4, opinion: '凭证号和导入结果一致' });
  await expect(verifyDialog).toBeHidden();

  await page.getByText('VCH-202608-E2E001', { exact: true }).first().click();
  await expect(page.getByText('人工导入成功', { exact: true })).toBeVisible();
  await expect(page.getByText('凭证号和导入结果一致', { exact: true })).toBeVisible();
});

test('PAGE-16 reverses and reopens a completed result from server allowed actions', async ({ page }) => {
  const reverseRequests: Array<Record<string, unknown>> = [];
  const reopenRequests: Array<Record<string, unknown>> = [];
  const evidence = {
    publicId: '01M00000000000000000000184',
    originalName: 'accounting-result.pdf',
    mediaType: 'application/pdf',
    sizeBytes: 20,
    sha256: 'c'.repeat(64),
    scanStatus: 'AVAILABLE',
  };
  await installAccountingFixture(page, {
    initialVoucher: voucher({
      status: 'COMPLETED',
      version: 5,
      allowedActions: ['REVERSE_RESULT'],
      externalVoucherNo: 'TPLUS-E2E-REVERSED',
      resultAt: '2026-08-15',
      evidenceFileIds: [evidence.publicId],
      resultRecordedByName: '记账登记员',
      resultRecordedAt: '2026-08-15T08:10:00Z',
      resultRecordRemark: '原记账结果',
      resultVerifiedByName: '记账复核员',
      resultVerifiedAt: '2026-08-15T08:15:00Z',
      resultVerifyOpinion: '原结果复核通过',
    }),
    initialEvidence: [evidence],
    reverseRequests,
    reopenRequests,
  });

  await page.goto('/finance/accounting?tab=completed');
  await page.getByRole('button', { name: '更多操作', exact: true }).click();
  await page.getByText('冲销记账结果', { exact: true }).click();
  const reverseDialog = page.locator('.t-dialog').filter({ hasText: '冲销记账结果' });
  await reverseDialog.getByRole('button', { name: '确认冲销记账结果', exact: true }).click();
  await expect(reverseDialog.getByText('处理意见或原因至少填写 2 个字符。', { exact: true })).toBeVisible();
  await reverseDialog.locator('textarea').fill('外部账套凭证有误');
  await reverseDialog.getByRole('button', { name: '确认冲销记账结果', exact: true }).click();

  await expect.poll(() => reverseRequests.length).toBe(1);
  expect(reverseRequests[0]).toEqual({ version: 5, reason: '外部账套凭证有误' });
  await expect(reverseDialog).toBeHidden();

  await page.getByRole('button', { name: '更多操作', exact: true }).click();
  await page.getByText('重开记账结果', { exact: true }).click();
  const reopenDialog = page.locator('.t-dialog').filter({ hasText: '重开记账结果' });
  await reopenDialog.locator('textarea').fill('更正后重新登记');
  await reopenDialog.getByRole('button', { name: '确认重开记账结果', exact: true }).click();

  await expect.poll(() => reopenRequests.length).toBe(1);
  expect(reopenRequests[0]).toEqual({ version: 6, reason: '更正后重新登记' });
  await expect(reopenDialog).toBeHidden();

  await page.getByText('VCH-202608-E2E001', { exact: true }).first().click();
  await expect(page.getByRole('region', { name: '记账结果冲销与重开记录' })).toBeVisible();
  await expect(page.getByText('TPLUS-E2E-REVERSED', { exact: true })).toHaveCount(2);
  await expect(page.getByText('外部账套凭证有误', { exact: true })).toBeVisible();
  await expect(page.getByText('更正后重新登记', { exact: true })).toBeVisible();
  await expect(page.getByText('1 份证据', { exact: true })).toHaveCount(2);
  await expect(page.getByRole('region', { name: '记账结果证据' })).toHaveCount(0);
});