import { act, cleanup, fireEvent, render, screen, waitFor, within } from '@testing-library/react';
import { afterEach, beforeEach, expect, it, vi } from 'vitest';
import { CloudRecovery } from '@/pages/CloudAgents/CloudRecovery';
import { AppError } from '@/lib/error-model';
import type { CloudPendingOperation } from '../../shared/cloud-agents';

const api = vi.hoisted(() => ({ resolvePending: vi.fn() }));
vi.mock('@/lib/cloud-agents-api', () => ({ cloudAgentsApi: api }));
const first: CloudPendingOperation = { id: 'create:first', operation: 'createAgent', input: { operation_id: 'original-first', name: '故事搭档' }, created_at: '2026-10-13T03:54:49Z' };
const second: CloudPendingOperation = { id: 'create:second', operation: 'createAgent', input: { operation_id: 'original-second', name: '阅读伙伴' }, created_at: '2026-10-13T03:55:18Z' };
const key: CloudPendingOperation = { id: 'key:original', operation: 'createKey', input: { application_id: 'application', operation_id: 'original-key', name: '应用密钥' }, created_at: '2026-10-13T04:00:00Z' };
const resolved = vi.fn();
beforeEach(() => { vi.resetAllMocks(); });
afterEach(cleanup);
async function openRecords() {
  fireEvent.click(screen.getByRole('button', { name: /^(创建记录|待处理记录)/ }));
  return await screen.findByRole('dialog');
}
function deferred<T>() {
  let resolve!: (value: T) => void;
  const promise = new Promise<T>(yes => { resolve = yes; });
  return { promise, resolve };
}

it('shows only a compact counted creation entry until explicitly opened, without retrying or discarding records', async () => {
  render(<CloudRecovery pending={[first, second]} onResolved={resolved} />);
  expect(screen.getByRole('button', { name: /^创建记录/ })).toHaveTextContent('2');
  expect(screen.queryByRole('dialog')).not.toBeInTheDocument();
  expect(screen.queryByRole('complementary', { name: '未确认的云端操作' })).not.toBeInTheDocument();
  expect(screen.queryByRole('article', { name: '创建「故事搭档」' })).not.toBeInTheDocument();
  expect(screen.queryByText(/有 2 个操作的结果尚未确认/)).not.toBeInTheDocument();
  const dialog = await openRecords();
  expect(within(dialog).getByRole('article', { name: '创建「故事搭档」' })).toBeVisible();
  expect(within(dialog).getByRole('article', { name: '创建「阅读伙伴」' })).toBeVisible();
  expect(within(dialog).getAllByRole('button', { name: '再试一次', exact: true })).toHaveLength(2);
  expect(within(dialog).getAllByRole('button', { name: '不再提醒', exact: true })).toHaveLength(2);
  expect(api.resolvePending).not.toHaveBeenCalled(); expect(resolved).not.toHaveBeenCalled();
});

it('uses a general records entry for mixed operations and keeps the original message visible only inside the dialog', async () => {
  const message = { ...second, id: 'message:original', operation: 'submit', input: { query: '我的上次问题' } };
  render(<CloudRecovery pending={[first, message]} onResolved={resolved} />);
  expect(screen.getByRole('button', { name: /^待处理记录/ })).toHaveTextContent('2');
  expect(screen.queryByText('我的上次问题')).not.toBeInTheDocument();
  const dialog = await openRecords();
  expect(within(dialog).getByText('我的上次问题')).toBeVisible();
  expect(api.resolvePending).not.toHaveBeenCalled();
});

it('keeps failed records and retries the same record ID after closing and reopening the dialog', async () => {
  api.resolvePending.mockRejectedValueOnce(new Error('原操作仍未确认')).mockResolvedValueOnce({ result: { slug: 'original-agent' } });
  render(<CloudRecovery pending={[first]} onResolved={resolved} />);
  const dialog = await openRecords();
  fireEvent.click(within(dialog).getByRole('button', { name: '再试一次' }));
  await screen.findByRole('alert');
  expect(screen.getByRole('alert')).toHaveTextContent('原操作仍未确认');
  expect(resolved).not.toHaveBeenCalled();
  fireEvent.click(screen.getByRole('button', { name: '关闭记录' }));
  expect(screen.queryByRole('alert')).not.toBeInTheDocument();
  const reopened = await openRecords();
  expect(within(reopened).getByRole('article', { name: '创建「故事搭档」' })).toBeVisible();
  fireEvent.click(within(reopened).getByRole('button', { name: '再试一次' }));
  await waitFor(() => expect(resolved).toHaveBeenCalledOnce());
  expect(api.resolvePending.mock.calls).toEqual([[first.id, false], [first.id, false]]);
  expect(screen.queryByRole('alert')).not.toBeInTheDocument();
});

it('removes only the explicitly chosen local reminder and never implicitly retries it', async () => {
  api.resolvePending.mockResolvedValue({ discarded: true });
  const view = render(<CloudRecovery pending={[first, second]} onResolved={resolved} />);
  const dialog = await openRecords();
  fireEvent.click(within(dialog).getAllByRole('button', { name: '不再提醒' })[1]);
  await waitFor(() => expect(resolved).toHaveBeenCalledOnce());
  expect(api.resolvePending.mock.calls).toEqual([[second.id, true]]);
  view.rerender(<CloudRecovery pending={[first]} onResolved={resolved} />);
  expect(screen.getByRole('article', { name: '创建「故事搭档」' })).toBeVisible();
  expect(screen.queryByRole('article', { name: '创建「阅读伙伴」' })).not.toBeInTheDocument();
});

it('serializes double clicks and other actions and prevents dismissal until a request finishes', async () => {
  const response = deferred<{ result: { slug: string } }>();
  api.resolvePending.mockReturnValue(response.promise);
  render(<CloudRecovery pending={[first, second]} onResolved={resolved} />);
  const dialog = await openRecords();
  await act(async () => { await new Promise(resolve => setTimeout(resolve, 0)); });
  const retry = within(dialog).getAllByRole('button', { name: '再试一次' })[0];
  act(() => { fireEvent.click(retry); fireEvent.click(retry); });
  expect(api.resolvePending).toHaveBeenCalledTimes(1);
  expect(within(dialog).getByRole('button', { name: '关闭记录' })).toBeDisabled();
  for (const discard of within(dialog).getAllByRole('button', { name: '不再提醒' })) expect(discard).toBeDisabled();
  fireEvent.keyDown(dialog, { key: 'Escape' });
  fireEvent.pointerDown(document.body, { button: 0, pointerType: 'mouse' });
  expect(screen.getByRole('dialog')).toBeVisible();
  expect(resolved).not.toHaveBeenCalled();
  await act(async () => response.resolve({ result: { slug: 'original-agent' } }));
  expect(resolved).toHaveBeenCalledOnce();
  expect(within(dialog).getByRole('button', { name: '关闭记录' })).toBeEnabled();
});

it('keeps a returned key available after modal close and reopen until the result is explicitly closed', async () => {
  const secret = 'fixture-key-for-unit-only';
  api.resolvePending.mockResolvedValue({ result: { secret, id: 'created-key' } });
  const view = render(<CloudRecovery pending={[key, first]} onResolved={resolved} />);
  const dialog = await openRecords();
  fireEvent.click(within(dialog).getAllByRole('button', { name: '再试一次' })[0]);
  await screen.findByText(new RegExp(secret));
  view.rerender(<CloudRecovery pending={[first]} onResolved={resolved} />);
  fireEvent.click(screen.getByRole('button', { name: '关闭记录' }));
  expect(screen.queryByText(new RegExp(secret))).not.toBeInTheDocument();
  await openRecords();
  expect(screen.getByText(new RegExp(secret))).toBeVisible();
  expect(api.resolvePending).toHaveBeenCalledTimes(1);
  fireEvent.click(screen.getByRole('button', { name: '关闭结果' }));
  expect(screen.queryByText(new RegExp(secret))).not.toBeInTheDocument();
  fireEvent.click(screen.getByRole('button', { name: '关闭记录' }));
  await openRecords();
  expect(screen.queryByText(new RegExp(secret))).not.toBeInTheDocument();
});

it('keeps a result entry available when the final pending record was acknowledged', async () => {
  api.resolvePending.mockResolvedValue({ result: { secret: 'last-key-fixture' } });
  const view = render(<CloudRecovery pending={[key]} onResolved={resolved} />);
  await openRecords(); fireEvent.click(screen.getByRole('button', { name: '再试一次' }));
  await screen.findByText(/last-key-fixture/);
  view.rerender(<CloudRecovery pending={[]} onResolved={resolved} />);
  fireEvent.click(screen.getByRole('button', { name: '关闭记录' }));
  await openRecords(); expect(screen.getByText(/last-key-fixture/)).toBeVisible();
  fireEvent.click(screen.getByRole('button', { name: '关闭结果' }));
  expect(screen.queryByText(/last-key-fixture/)).not.toBeInTheDocument();
});

it('guides verification requiring fresh input without claiming that verification completed', async () => {
  const verification = { ...first, id: 'wechat:verification', operation: 'wechatBindVerification', input: { session_key: 'fixture-session' } };
  api.resolvePending.mockResolvedValue({ requires_input: true, operation: verification.operation });
  render(<CloudRecovery pending={[verification]} onResolved={resolved} />);
  await openRecords(); fireEvent.click(screen.getByRole('button', { name: '再试一次' }));
  expect(await screen.findByText(/还需要验证码/)).toBeVisible();
  expect(screen.queryByText('微信连接验证的结果已确认。')).not.toBeInTheDocument();
  expect(api.resolvePending).toHaveBeenCalledWith(verification.id, false);
});

it('offers only explicit discard for retired operations and explains the retired result without auto actions', async () => {
  const retired = { ...first, id: 'retired:policy', operation: 'channelPolicy', input: {} };
  api.resolvePending.mockResolvedValue({ retired: true, discarded: true, operation: retired.operation });
  render(<CloudRecovery pending={[retired]} onResolved={resolved} />);
  expect(api.resolvePending).not.toHaveBeenCalled();
  await openRecords();
  expect(screen.queryByRole('button', { name: '再试一次' })).not.toBeInTheDocument();
  fireEvent.click(screen.getByRole('button', { name: '丢弃旧记录' }));
  expect(await screen.findByText(/旧版联系人权限操作已移除/)).toBeVisible();
  expect(api.resolvePending).toHaveBeenCalledWith(retired.id, false);
});

it('keeps a channel operation visibly pending without claiming a confirmed result', async () => {
  const operation: CloudPendingOperation = { id: 'unbind:original', operation: 'unbindChannelAccount',
    input: { channel_account_id: 'wechat-1', operation_id: 'original-unbind', expected_revision: 2 },
    created_at: '2026-10-13T04:00:00Z' };
  api.resolvePending.mockResolvedValue({ operation: operation.operation, pending: true, result: { status: 'pending' } });
  render(<CloudRecovery pending={[operation]} onResolved={resolved} />);
  const dialog = await openRecords();
  expect(within(dialog).getByRole('article', { name: '解除微信绑定' })).toBeVisible();
  fireEvent.click(within(dialog).getByRole('button', { name: '再试一次' }));
  expect(await within(dialog).findByRole('status')).toHaveTextContent('这次操作还在确认中');
  expect(within(dialog).queryByText(/结果已确认/)).not.toBeInTheDocument();
  expect(within(dialog).getByRole('article', { name: '解除微信绑定' })).toBeVisible();
  expect(resolved).toHaveBeenCalledOnce();
});

it('renders no entry or dialog when there are no pending records or retained results', () => {
  render(<CloudRecovery pending={[]} onResolved={resolved} />);
  expect(screen.queryByRole('button')).not.toBeInTheDocument();
  expect(screen.queryByRole('dialog')).not.toBeInTheDocument();
  expect(api.resolvePending).not.toHaveBeenCalled();
});

it('does not let another action replace an unclosed key result, and unlocks actions after explicit result closure', async () => {
  const verification = { ...second, operation: 'wechatBindVerification' };
  api.resolvePending.mockImplementation(async id => id === key.id
    ? { result: { secret: 'protected-key-fixture' } } : { requires_input: true, operation: verification.operation });
  const view = render(<CloudRecovery pending={[key, verification]} onResolved={resolved} />);
  await openRecords();
  fireEvent.click(within(screen.getByRole('article', { name: '创建密钥' })).getByRole('button', { name: '再试一次' }));
  await screen.findByText(/protected-key-fixture/);
  view.rerender(<CloudRecovery pending={[verification]} onResolved={resolved} />);
  const row = screen.getByRole('article', { name: '微信连接验证' });
  const retry = within(row).getByRole('button', { name: '再试一次' });
  const discard = within(row).getByRole('button', { name: '不再提醒' });
  expect(retry).toBeDisabled(); expect(discard).toBeDisabled();
  fireEvent.click(retry); fireEvent.click(discard);
  expect(api.resolvePending).toHaveBeenCalledTimes(1);
  expect(screen.getByText(/protected-key-fixture/)).toBeVisible();
  fireEvent.click(screen.getByRole('button', { name: '关闭结果' }));
  expect(retry).toBeEnabled();
  fireEvent.click(retry);
  await screen.findByText(/还需要验证码/);
  expect(api.resolvePending.mock.calls).toEqual([[key.id, false], [verification.id, false]]);
});

it('refreshes pending records after a definite rejection while keeping the error inside the explicit dialog', async () => {
  api.resolvePending.mockRejectedValue(new AppError('CONFIG', '这条创建已被拒绝', undefined, { commandOutcome: 'definitive_failure' }));
  const view = render(<CloudRecovery pending={[first]} onResolved={resolved} />);
  await openRecords(); fireEvent.click(screen.getByRole('button', { name: '再试一次' }));
  expect(await screen.findByRole('alert')).toHaveTextContent('这条创建已被拒绝');
  expect(resolved).toHaveBeenCalledOnce();
  expect(api.resolvePending).toHaveBeenCalledWith(first.id, false);
  view.rerender(<CloudRecovery pending={[]} onResolved={resolved} />);
  fireEvent.click(screen.getByRole('button', { name: '关闭记录' }));
  expect(screen.queryByRole('alert')).not.toBeInTheDocument();
  await openRecords();
  expect(screen.queryByRole('article')).not.toBeInTheDocument();
  expect(screen.getByRole('alert')).toHaveTextContent('这条创建已被拒绝');
});

it('keeps an explicitly unknown command outcome recoverable without refreshing it as a definite failure', async () => {
  api.resolvePending.mockRejectedValue(new AppError('NETWORK', '请求结果仍未知', undefined, { commandOutcome: 'unknown' }));
  render(<CloudRecovery pending={[first]} onResolved={resolved} />);
  await openRecords(); fireEvent.click(screen.getByRole('button', { name: '再试一次' }));
  expect(await screen.findByRole('alert')).toHaveTextContent('请求结果仍未知');
  expect(resolved).not.toHaveBeenCalled();
  expect(screen.getByRole('article', { name: '创建「故事搭档」' })).toBeVisible();
  fireEvent.click(screen.getByRole('button', { name: '再试一次' }));
  await waitFor(() => expect(api.resolvePending).toHaveBeenCalledTimes(2));
  expect(api.resolvePending.mock.calls).toEqual([[first.id, false], [first.id, false]]);
});