/**
 * 订单状态流转 E2E 测试
 *
 * 测试范围：
 * - 激活草稿订单
 * - 关闭进行中订单
 * - 状态限制验证
 * - 状态流转后的 Toast 消息验证
 *
 * @packageDocumentation
 */

import { test, expect, Page } from '../../utils/test-setup';
import { ORDER_STATUS, type OrderStatus, ORDER_STATUS_LABELS } from '../../pages/admin/order-management.page';

/**
 * 辅助函数：获取订单列表中第一个订单的名称
 *
 * @param page - Playwright Page 对象
 * @returns 第一个订单的名称，如果没有则返回 null
 */
async function getFirstOrderName(page: Page): Promise<string | null> {
  const table = page.locator('table tbody tr');

  // 等待表格数据加载完成（跳过"加载中"等占位符文本）
  await page.waitForTimeout(1000);

  const count = await table.count();

  if (count === 0) {
    return null;
  }

  // 需要跳过的占位符文本列表
  const placeholderTexts = [
    '加载中...',
    '暂无数据',
    '暂无订单数据',
    '无数据',
    '没有数据'
  ];

  // 查找第一个有效的订单行（排除占位符）
  for (let i = 0; i < count; i++) {
    const row = table.nth(i);
    const nameCell = row.locator('td').first();
    const name = await nameCell.textContent();
    const trimmedName = name?.trim() || '';

    // 跳过占位符文本
    const isPlaceholder = placeholderTexts.some(placeholder => trimmedName.includes(placeholder));

    if (trimmedName && !isPlaceholder && !trimmedName.includes('加载')) {
      return trimmedName;
    }
  }

  return null;
}

/**
 * 辅助函数：在创建订单对话框中选择残疾人
 *
 * @param page - Playwright Page 对象
 * @returns 是否成功选择了残疾人
 */
async function selectDisabledPersonForOrder(page: Page): Promise<boolean> {
  const selectPersonButton = page.getByRole('button', { name: '选择残疾人' });
  await selectPersonButton.click();

  await page.waitForSelector('[role="dialog"]', { state: 'visible', timeout: 5000 });

  let hasData = false;
  try {
    const firstCheckbox = page.locator('table tbody tr').first().locator('input[type="checkbox"]').first();
    await firstCheckbox.waitFor({ state: 'visible', timeout: 3000 });
    await firstCheckbox.check();
    console.debug('✓ 已选择第一个残疾人');
    hasData = true;
  } catch (error) {
    console.debug('没有可用的残疾人数据');
    hasData = false;
  }

  if (hasData) {
    const confirmButton = page.getByRole('button', { name: /^(确定|确认|选择)$/ });
    await confirmButton.click().catch(() => {
      console.debug('没有找到确认按钮，尝试关闭对话框');
      page.keyboard.press('Escape');
    });
  } else {
    await page.keyboard.press('Escape').catch(() => {
      console.debug('无法关闭对话框，可能已经自动关闭');
    });
  }

  await page.waitForTimeout(500);
  return hasData;
}

/**
 * 辅助函数：创建测试订单
 *
 * @param page - Playwright Page 对象
 * @param orderName - 订单名称
 * @param status - 订单状态（默认为草稿）
 * @returns 是否成功创建
 */
async function createTestOrder(page: Page, orderName: string, status?: OrderStatus): Promise<boolean> {
  // 打开创建对话框
  const addOrderButton = page.getByTestId('create-order-button');
  await addOrderButton.click();
  await page.waitForSelector('[role="dialog"]', { state: 'visible', timeout: 5000 });

  // 填写必填字段
  await page.getByLabel(/订单名称|名称/).fill(orderName);
  await page.getByLabel(/预计开始日期|开始日期/).fill('2025-01-15');

  // 选择残疾人（必填）
  const hasDisabledPerson = await selectDisabledPersonForOrder(page);

  if (!hasDisabledPerson) {
    await page.keyboard.press('Escape');
    return false;
  }

  // 如果指定了非草稿状态，需要在编辑模式下修改（这里先创建草稿）
  // 提交表单
  const submitButton = page.getByRole('button', { name: /^(创建|更新|保存)$/ });
  await submitButton.click();

  // 等待网络请求完成
  try {
    await page.waitForLoadState('networkidle', { timeout: 5000 });
  } catch {
    console.debug('networkidle 超时，继续检查 Toast 消息');
  }

  await page.waitForTimeout(2000);

  // 检查成功消息
  const successToast = page.locator('[data-sonner-toast][data-type="success"]');
  const hasSuccess = await successToast.count() > 0;

  // 等待对话框关闭
  const dialog = page.locator('[role="dialog"]');
  await dialog.waitFor({ state: 'hidden', timeout: 5000 }).catch(() => {
    console.debug('对话框关闭超时，可能已经关闭');
  });

  return hasSuccess;
}

test.describe('订单状态流转测试', () => {
  test.describe('激活草稿订单', () => {
    let draftOrderName: string;

    test.beforeEach(async ({ adminLoginPage, orderManagementPage, testUsers }) => {
      // 以管理员身份登录后台
      await adminLoginPage.goto();
      await adminLoginPage.login(testUsers.admin.username, testUsers.admin.password);
      await adminLoginPage.expectLoginSuccess();
      await orderManagementPage.goto();

      // 创建一个草稿状态的测试订单
      const timestamp = Date.now();
      draftOrderName = `激活测试_${timestamp}`;

      const created = await createTestOrder(orderManagementPage.page, draftOrderName);

      if (!created) {
        test.skip(true, '没有残疾人数据，无法创建测试订单');
      }

      // 验证订单出现在列表中
      await expect(async () => {
        const exists = await orderManagementPage.orderExists(draftOrderName);
        expect(exists).toBe(true);
      }).toPass({ timeout: 5000 });

      // 验证初始状态为草稿
      const initialStatus = await orderManagementPage.getOrderStatus(draftOrderName);
      console.debug(`✓ 订单初始状态: ${initialStatus ? ORDER_STATUS_LABELS[initialStatus] : '未知'}`);
    });

    test('应该成功激活草稿订单', async ({ orderManagementPage }) => {
      // 执行激活操作
      const success = await orderManagementPage.activateOrder(draftOrderName);

      // 验证激活成功
      expect(success).toBe(true);

      // 验证状态从草稿变为进行中
      await expect(async () => {
        const currentStatus = await orderManagementPage.getOrderStatus(draftOrderName);
        expect(currentStatus).toBe(ORDER_STATUS.IN_PROGRESS);
      }).toPass({ timeout: 5000 });
    });

    test('激活后应该显示成功提示', async ({ orderManagementPage }) => {
      await orderManagementPage.activateOrder(draftOrderName);

      // 验证 Toast 成功消息
      const successToast = orderManagementPage.page.locator('[data-sonner-toast][data-type="success"]');
      await expect(successToast).toBeVisible();
      const message = await successToast.textContent();
      expect(message).toBeDefined();
      expect(message?.length).toBeGreaterThan(0);
      // 验证消息包含激活相关的关键词
      expect(message).toMatch(/激活|成功|已激活/);
    });

    test('激活确认对话框应该正确显示', async ({ orderManagementPage, page }) => {
      await orderManagementPage.openActivateDialog(draftOrderName);

      // 验证对话框可见
      const dialog = page.locator('[role="alertdialog"]');
      await expect(dialog).toBeVisible();

      // 验证确认按钮存在（支持多种可能的按钮名称）
      const confirmButton = page.locator('[role="alertdialog"]').getByRole('button', {
        name: /^(确认激活|激活|确定|确认)$/
      });
      await expect(confirmButton).toBeVisible();

      // 验证取消按钮存在
      const cancelButton = page.locator('[role="alertdialog"]').getByRole('button', { name: '取消' });
      await expect(cancelButton).toBeVisible();

      // 取消激活以清理
      await page.keyboard.press('Escape');
    });
  });

  test.describe('关闭进行中订单', () => {
    let inProgressOrderName: string;

    test.beforeEach(async ({ adminLoginPage, orderManagementPage, testUsers }) => {
      // 以管理员身份登录后台
      await adminLoginPage.goto();
      await adminLoginPage.login(testUsers.admin.username, testUsers.admin.password);
      await adminLoginPage.expectLoginSuccess();
      await orderManagementPage.goto();

      // 创建一个草稿订单然后激活为进行中状态
      const timestamp = Date.now();
      inProgressOrderName = `关闭测试_${timestamp}`;

      const created = await createTestOrder(orderManagementPage.page, inProgressOrderName);

      if (!created) {
        test.skip(true, '没有残疾人数据，无法创建测试订单');
      }

      // 验证订单出现在列表中
      await expect(async () => {
        const exists = await orderManagementPage.orderExists(inProgressOrderName);
        expect(exists).toBe(true);
      }).toPass({ timeout: 5000 });

      // 激活订单到进行中状态
      await orderManagementPage.activateOrder(inProgressOrderName);

      // 验证状态变为进行中
      await expect(async () => {
        const currentStatus = await orderManagementPage.getOrderStatus(inProgressOrderName);
        expect(currentStatus).toBe(ORDER_STATUS.IN_PROGRESS);
      }).toPass({ timeout: 5000 });

      console.debug(`✓ 订单已激活为进行中状态`);
    });

    test('应该成功关闭进行中订单', async ({ orderManagementPage }) => {
      // 执行关闭操作
      const success = await orderManagementPage.closeOrder(inProgressOrderName);

      // 验证关闭成功
      expect(success).toBe(true);

      // 验证状态从进行中变为已完成
      await expect(async () => {
        const currentStatus = await orderManagementPage.getOrderStatus(inProgressOrderName);
        expect(currentStatus).toBe(ORDER_STATUS.COMPLETED);
      }).toPass({ timeout: 5000 });
    });

    test('关闭后应该显示成功提示', async ({ orderManagementPage }) => {
      await orderManagementPage.closeOrder(inProgressOrderName);

      // 验证 Toast 成功消息
      const successToast = orderManagementPage.page.locator('[data-sonner-toast][data-type="success"]');
      await expect(successToast).toBeVisible();
      const message = await successToast.textContent();
      expect(message).toBeDefined();
      expect(message?.length).toBeGreaterThan(0);
      // 验证消息包含关闭相关的关键词
      expect(message).toMatch(/关闭|完成|成功|已关闭|已完成/);
    });

    test('关闭确认对话框应该正确显示', async ({ orderManagementPage, page }) => {
      await orderManagementPage.openCloseDialog(inProgressOrderName);

      // 验证对话框可见
      const dialog = page.locator('[role="alertdialog"]');
      await expect(dialog).toBeVisible();

      // 验证确认按钮存在（支持多种可能的按钮名称）
      const confirmButton = page.locator('[role="alertdialog"]').getByRole('button', {
        name: /^(确认关闭|关闭|确定|确认)$/
      });
      await expect(confirmButton).toBeVisible();

      // 验证取消按钮存在
      const cancelButton = page.locator('[role="alertdialog"]').getByRole('button', { name: '取消' });
      await expect(cancelButton).toBeVisible();

      // 取消关闭以清理
      await page.keyboard.press('Escape');
    });
  });

  test.describe('状态限制验证', () => {
    let testOrderName: string;
    let currentStatus: OrderStatus;
    let shouldSkipTests = false;

    test.beforeEach(async ({ adminLoginPage, orderManagementPage, testUsers }) => {
      // 以管理员身份登录后台
      await adminLoginPage.goto();
      await adminLoginPage.login(testUsers.admin.username, testUsers.admin.password);
      await adminLoginPage.expectLoginSuccess();
      await orderManagementPage.goto();

      // 尝试使用现有订单
      const existingOrder = await getFirstOrderName(orderManagementPage.page);

      if (existingOrder) {
        testOrderName = existingOrder;
        currentStatus = (await orderManagementPage.getOrderStatus(testOrderName)) || ORDER_STATUS.DRAFT;
        console.debug(`✓ 使用现有订单: ${testOrderName}, 状态: ${ORDER_STATUS_LABELS[currentStatus]}`);
      } else {
        // 如果没有现有订单，创建一个
        const timestamp = Date.now();
        testOrderName = `状态限制测试_${timestamp}`;

        const created = await createTestOrder(orderManagementPage.page, testOrderName);

        if (!created) {
          shouldSkipTests = true;
          test.skip(true, '没有残疾人数据，无法创建测试订单');
          return;
        }

        // 验证订单出现在列表中
        await expect(async () => {
          const exists = await orderManagementPage.orderExists(testOrderName);
          expect(exists).toBe(true);
        }).toPass({ timeout: 5000 });

        currentStatus = ORDER_STATUS.DRAFT;
      }
    });

    test('不能激活非草稿状态的订单', async ({ orderManagementPage }) => {
      if (shouldSkipTests) {
        test.skip(true, '测试数据不可用');
        return;
      }

      // 如果当前是草稿状态，先激活为进行中
      if (currentStatus === ORDER_STATUS.DRAFT) {
        await orderManagementPage.activateOrder(testOrderName);
        currentStatus = ORDER_STATUS.IN_PROGRESS;
        console.debug(`✓ 已激活订单用于测试`);
      }

      // 对于非草稿状态的订单，激活按钮应该被禁用或不可见
      const isActivatedEnabled = await orderManagementPage.isActivateButtonEnabled(testOrderName);

      // 根据当前状态验证
      if (currentStatus === ORDER_STATUS.IN_PROGRESS ||
          currentStatus === ORDER_STATUS.COMPLETED ||
          currentStatus === ORDER_STATUS.CONFIRMED) {
        // 非草稿状态不应该能激活
        expect(isActivatedEnabled).toBe(false);
        console.debug(`✓ 状态 ${ORDER_STATUS_LABELS[currentStatus]} 的订单不能激活`);
      }
    });

    test('不能关闭非进行中状态的订单', async ({ orderManagementPage }) => {
      if (shouldSkipTests) {
        test.skip(true, '测试数据不可用');
        return;
      }

      // 对于非进行中状态的订单，关闭按钮应该被禁用或不可见
      const isCloseEnabled = await orderManagementPage.isCloseButtonEnabled(testOrderName);

      // 根据当前状态验证
      if (currentStatus === ORDER_STATUS.DRAFT ||
          currentStatus === ORDER_STATUS.COMPLETED ||
          currentStatus === ORDER_STATUS.CONFIRMED) {
        // 非进行中状态不应该能关闭
        expect(isCloseEnabled).toBe(false);
        console.debug(`✓ 状态 ${ORDER_STATUS_LABELS[currentStatus]} 的订单不能关闭`);
      }
    });

    test('已完成状态不能再次操作', async ({ orderManagementPage }) => {
      if (shouldSkipTests) {
        test.skip(true, '测试数据不可用');
        return;
      }

      // 如果当前不是已完成状态，先操作到已完成
      if (currentStatus === ORDER_STATUS.DRAFT) {
        await orderManagementPage.activateOrder(testOrderName);
        await orderManagementPage.closeOrder(testOrderName);
        console.debug(`✓ 已将订单操作到已完成状态`);
      } else if (currentStatus === ORDER_STATUS.IN_PROGRESS) {
        await orderManagementPage.closeOrder(testOrderName);
        console.debug(`✓ 已关闭订单`);
      }

      // 验证订单状态为已完成
      await expect(async () => {
        const status = await orderManagementPage.getOrderStatus(testOrderName);
        expect(status).toBe(ORDER_STATUS.COMPLETED);
      }).toPass({ timeout: 5000 });

      // 已完成状态的订单不能激活也不能关闭
      const isActivateEnabled = await orderManagementPage.isActivateButtonEnabled(testOrderName);
      const isCloseEnabled = await orderManagementPage.isCloseButtonEnabled(testOrderName);

      expect(isActivateEnabled).toBe(false);
      expect(isCloseEnabled).toBe(false);
      console.debug(`✓ 已完成状态的订单不能激活或关闭`);
    });
  });

  test.describe('完整状态流转流程', () => {
    test('应该支持草稿→进行中→已完成的完整流转', async ({ adminLoginPage, orderManagementPage, testUsers }) => {
      // 以管理员身份登录后台
      await adminLoginPage.goto();
      await adminLoginPage.login(testUsers.admin.username, testUsers.admin.password);
      await adminLoginPage.expectLoginSuccess();
      await orderManagementPage.goto();

      // 创建草稿订单
      const timestamp = Date.now();
      const orderName = `完整流转测试_${timestamp}`;

      const created = await createTestOrder(orderManagementPage.page, orderName);

      if (!created) {
        test.skip(true, '没有残疾人数据，无法创建测试订单');
      }

      // 验证订单出现在列表中
      await expect(async () => {
        const exists = await orderManagementPage.orderExists(orderName);
        expect(exists).toBe(true);
      }).toPass({ timeout: 5000 });

      // 验证初始状态为草稿
      let currentStatus = await orderManagementPage.getOrderStatus(orderName);
      expect(currentStatus).toBe(ORDER_STATUS.DRAFT);
      console.debug(`✓ 初始状态: ${ORDER_STATUS_LABELS[ORDER_STATUS.DRAFT]}`);

      // 激活订单
      await orderManagementPage.activateOrder(orderName);
      currentStatus = await orderManagementPage.getOrderStatus(orderName);
      expect(currentStatus).toBe(ORDER_STATUS.IN_PROGRESS);
      console.debug(`✓ 激活后状态: ${ORDER_STATUS_LABELS[ORDER_STATUS.IN_PROGRESS]}`);

      // 关闭订单
      await orderManagementPage.closeOrder(orderName);
      currentStatus = await orderManagementPage.getOrderStatus(orderName);
      expect(currentStatus).toBe(ORDER_STATUS.COMPLETED);
      console.debug(`✓ 关闭后状态: ${ORDER_STATUS_LABELS[ORDER_STATUS.COMPLETED]}`);
    });
  });
});