import { test, expect } from '@playwright/test';
import { LoginPage } from './pages/LoginPage';
import { DashboardPage } from './pages/DashboardPage';
import { SystemConfigPage } from './pages/SystemConfigPage';
import { DictionaryManagementPage } from './pages/DictionaryManagementPage';

test.describe('系统配置 E2E 测试', () => {
  let loginPage: LoginPage;
  let dashboardPage: DashboardPage;
  let systemConfigPage: SystemConfigPage;
  let dictionaryManagementPage: DictionaryManagementPage;

  test.beforeEach(async ({ page }) => {
    loginPage = new LoginPage(page);
    dashboardPage = new DashboardPage(page);
    systemConfigPage = new SystemConfigPage(page);
    dictionaryManagementPage = new DictionaryManagementPage(page);
  });

  test('CONFIG-001: 管理员查看系统配置列表', async ({ page }) => {
    await test.step('管理员登录', async () => {
      await loginPage.goto();
      await loginPage.login('admin', 'admin123');
      await expect(page).toHaveURL(/.*dashboard/);
    });

    await test.step('导航到系统配置页面', async () => {
      await page.goto('/sys/config');
      await page.waitForLoadState('networkidle');
    });

    await test.step('验证系统配置页面加载', async () => {
      await expect(systemConfigPage.table).toBeVisible();
      const rowCount = await systemConfigPage.getTableRowCount();
      expect(rowCount).toBeGreaterThan(0);
    });

    await test.step('验证配置表格包含必要列', async () => {
      await expect(systemConfigPage.table).toContainText('参数名称');
      await expect(systemConfigPage.table).toContainText('参数键名');
      await expect(systemConfigPage.table).toContainText('参数值');
      await expect(systemConfigPage.table).toContainText('类型');
    });
  });

  test('CONFIG-002: 管理员新增系统配置', async ({ page }) => {
    await test.step('管理员登录并导航到系统配置', async () => {
      await loginPage.goto();
      await loginPage.login('admin', 'admin123');
      await systemConfigPage.goto();
    });

    await test.step('新增系统配置', async () => {
      const testConfigName = `测试配置_${Date.now()}`;
      const testConfigKey = `test.config.${Date.now()}`;
      const testConfigValue = 'test_value_123';
      
      await systemConfigPage.addConfig(testConfigName, testConfigKey, testConfigValue);
      await page.waitForTimeout(1000);
      
      await expect(systemConfigPage.table).toBeVisible();
    });
  });

  test('CONFIG-003: 管理员修改系统配置', async ({ page }) => {
    await test.step('管理员登录并导航到系统配置', async () => {
      await loginPage.goto();
      await loginPage.login('admin', 'admin123');
      await systemConfigPage.goto();
    });

    await test.step('修改系统配置', async () => {
      const rows = await systemConfigPage.table.locator('.el-table__row').count();
      if (rows > 0) {
        const firstRow = systemConfigPage.table.locator('.el-table__row').first();
        const configKey = await firstRow.locator('td').nth(1).textContent();
        
        if (configKey && configKey.includes('test.config')) {
          const newValue = `updated_value_${Date.now()}`;
          await systemConfigPage.editConfig(configKey, newValue);
          await page.waitForTimeout(1000);
          
          await expect(systemConfigPage.table).toBeVisible();
        }
      }
    });
  });

  test('CONFIG-004: 管理员删除系统配置', async ({ page }) => {
    await test.step('管理员登录并导航到系统配置', async () => {
      await loginPage.goto();
      await loginPage.login('admin', 'admin123');
      await systemConfigPage.goto();
    });

    await test.step('删除系统配置', async () => {
      const rows = await systemConfigPage.table.locator('.el-table__row').count();
      if (rows > 0) {
        const testRow = systemConfigPage.table.locator('tr').filter({ hasText: 'test.config' }).first();
        const testRowCount = await testRow.count();
        
        if (testRowCount > 0) {
          const configKey = await testRow.locator('td').nth(1).textContent();
          
          if (configKey) {
            await systemConfigPage.deleteConfig(configKey);
            await page.waitForTimeout(1000);
            
            await expect(systemConfigPage.table).toBeVisible();
          }
        }
      }
    });
  });

  test('CONFIG-005: 管理员搜索系统配置', async ({ page }) => {
    await test.step('管理员登录并导航到系统配置', async () => {
      await loginPage.goto();
      await loginPage.login('admin', 'admin123');
      await systemConfigPage.goto();
    });

    await test.step('搜索系统配置', async () => {
      await systemConfigPage.searchConfig('用户');
      await page.waitForTimeout(1000);
    });

    await test.step('清除搜索条件', async () => {
      await systemConfigPage.clearSearch();
      const rowCount = await systemConfigPage.getTableRowCount();
      expect(rowCount).toBeGreaterThan(0);
    });
  });

  test('CONFIG-006: 验证系统配置权限控制', async ({ page }) => {
    await test.step('普通用户登录', async () => {
      await loginPage.goto();
      await loginPage.login('user', 'user123');
      await expect(page).toHaveURL(/.*dashboard/);
    });

    await test.step('尝试访问系统配置页面', async () => {
      await page.goto('/sysconfig');
      await page.waitForLoadState('networkidle');
      
      const currentURL = page.url();
      if (currentURL.includes('/sys/config')) {
        await expect(systemConfigPage.table).toBeVisible();
      } else {
        await expect(page).toHaveURL(/.*dashboard/);
      }
    });
  });

  test('CONFIG-007: 验证配置修改生效', async ({ page }) => {
    await test.step('管理员登录并导航到系统配置', async () => {
      await loginPage.goto();
      await loginPage.login('admin', 'admin123');
      await systemConfigPage.goto();
    });

    await test.step('修改配置并验证生效', async () => {
      const rows = await systemConfigPage.table.locator('.el-table__row').count();
      if (rows > 0) {
        const firstRow = systemConfigPage.table.locator('.el-table__row').first();
        const configKey = await firstRow.locator('td').nth(1).textContent();
        
        if (configKey) {
          const newValue = `test_value_${Date.now()}`;
          await systemConfigPage.editConfig(configKey, newValue);
          await page.waitForTimeout(1000);
          
          await expect(systemConfigPage.table).toBeVisible();
        }
      }
    });
  });

  test('CONFIG-008: 管理员查看字典管理列表', async ({ page }) => {
    await test.step('管理员登录', async () => {
      await loginPage.goto();
      await loginPage.login('admin', 'admin123');
      await expect(page).toHaveURL(/.*dashboard/);
    });

    await test.step('导航到字典管理页面', async () => {
      await page.goto('/dict');
      await page.waitForLoadState('networkidle');
    });

    await test.step('验证字典管理页面加载', async () => {
      await expect(dictionaryManagementPage.table).toBeVisible();
      const rowCount = await dictionaryManagementPage.getTableRowCount();
      expect(rowCount).toBeGreaterThan(0);
    });

    await test.step('验证字典表格包含必要列', async () => {
      await expect(dictionaryManagementPage.table).toContainText('字典名称');
      await expect(dictionaryManagementPage.table).toContainText('字典类型');
      await expect(dictionaryManagementPage.table).toContainText('状态');
      await expect(dictionaryManagementPage.table).toContainText('备注');
    });
  });

  test('CONFIG-009: 管理员新增字典类型', async ({ page }) => {
    await test.step('管理员登录并导航到字典管理', async () => {
      await loginPage.goto();
      await loginPage.login('admin', 'admin123');
      await dictionaryManagementPage.goto();
    });

    await test.step('新增字典类型', async () => {
      const testDictName = `测试字典_${Date.now()}`;
      const testDictType = `test_dict_${Date.now()}`;
      
      await dictionaryManagementPage.addDictionary(testDictName, testDictType);
      await page.waitForTimeout(1000);
      
      await expect(dictionaryManagementPage.table).toBeVisible();
    });
  });

  test('CONFIG-010: 管理员搜索字典类型', async ({ page }) => {
    await test.step('管理员登录并导航到字典管理', async () => {
      await loginPage.goto();
      await loginPage.login('admin', 'admin123');
      await dictionaryManagementPage.goto();
    });

    await test.step('搜索字典类型', async () => {
      await dictionaryManagementPage.searchDictionary('用户');
      await page.waitForTimeout(1000);
    });

    await test.step('清除搜索条件', async () => {
      await dictionaryManagementPage.clearSearch();
      const rowCount = await dictionaryManagementPage.getTableRowCount();
      expect(rowCount).toBeGreaterThan(0);
    });
  });

  test('CONFIG-011: 验证字典管理权限控制', async ({ page }) => {
    await test.step('普通用户登录', async () => {
      await loginPage.goto();
      await loginPage.login('user', 'user123');
      await expect(page).toHaveURL(/.*dashboard/);
    });

    await test.step('尝试访问字典管理页面', async () => {
      await page.goto('/system/dict');
      await page.waitForLoadState('networkidle');
      
      const currentURL = page.url();
      if (currentURL.includes('/system/dict')) {
        await expect(dictionaryManagementPage.table).toBeVisible();
      } else {
        await expect(page).toHaveURL(/.*dashboard/);
      }
    });
  });

  test('CONFIG-012: 验证配置数据完整性', async ({ page }) => {
    await test.step('管理员登录并导航到系统配置', async () => {
      await loginPage.goto();
      await loginPage.login('admin', 'admin123');
      await systemConfigPage.goto();
    });

    await test.step('验证配置数据完整性', async () => {
      const rows = await systemConfigPage.table.locator('.el-table__row').count();
      expect(rows).toBeGreaterThan(0);
      
      const firstRow = systemConfigPage.table.locator('.el-table__row').first();
      await expect(firstRow).toBeVisible();
    });
  });

  test('CONFIG-013: 验证字典数据完整性', async ({ page }) => {
    await test.step('管理员登录并导航到字典管理', async () => {
      await loginPage.goto();
      await loginPage.login('admin', 'admin123');
      await dictionaryManagementPage.goto();
    });

    await test.step('验证字典数据完整性', async () => {
      const rows = await dictionaryManagementPage.table.locator('.el-table__row').count();
      expect(rows).toBeGreaterThan(0);
      
      const firstRow = dictionaryManagementPage.table.locator('.el-table__row').first();
      await expect(firstRow).toBeVisible();
    });
  });

  test('CONFIG-014: 验证配置操作按钮可见性', async ({ page }) => {
    await test.step('管理员登录并导航到系统配置', async () => {
      await loginPage.goto();
      await loginPage.login('admin', 'admin123');
      await systemConfigPage.goto();
    });

    await test.step('验证新增按钮可见', async () => {
      await expect(systemConfigPage.addButton).toBeVisible();
    });

    await test.step('验证搜索框可见', async () => {
      await expect(systemConfigPage.searchInput).toBeVisible();
    });
  });

  test('CONFIG-015: 验证字典操作按钮可见性', async ({ page }) => {
    await test.step('管理员登录并导航到字典管理', async () => {
      await loginPage.goto();
      await loginPage.login('admin', 'admin123');
      await dictionaryManagementPage.goto();
    });

    await test.step('验证新增按钮可见', async () => {
      await expect(dictionaryManagementPage.addButton).toBeVisible();
    });

    await test.step('验证搜索框可见', async () => {
      await expect(dictionaryManagementPage.searchInput).toBeVisible();
    });
  });
});