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

// 测试用户配置
const TEST_USERS = {
  superAdmin: {
    username: 'admin',
    password: 'password',
    role: '超级管理员'
  },
  systemAdmin: {
    username: 'sysadmin',
    password: 'SysAdmin123!',
    role: '系统管理员'
  },
  regularUser: {
    username: 'user',
    password: 'User123!',
    role: '普通用户'
  },
  guest: {
    username: '',
    password: '',
    role: '访客'
  }
};

// 权限验证测试套件
test.describe('系统配置功能权限验证测试', () => {
  let loginPage: LoginPage;
  let dashboardPage: DashboardPage;
  let userManagementPage: UserManagementPage;
  let roleManagementPage: RoleManagementPage;
  let menuManagementPage: MenuManagementPage;
  let systemConfigPage: SystemConfigPage;

  test.beforeEach(async ({ page }) => {
    loginPage = new LoginPage(page);
    dashboardPage = new DashboardPage(page);
    userManagementPage = new UserManagementPage(page);
    roleManagementPage = new RoleManagementPage(page);
    menuManagementPage = new MenuManagementPage(page);
    systemConfigPage = new SystemConfigPage(page);
  });

  // 测试1: 超级管理员权限验证
  test('PERM-001: 超级管理员完整权限验证', async ({ page }) => {
    const user = TEST_USERS.superAdmin;
    const testResults = [];

    await test.step(`1. ${user.role}登录系统`, async () => {
      await loginPage.goto();
      await loginPage.login(user.username, user.password);
      await expect(page).toHaveURL(/.*dashboard/);
      testResults.push({ step: '登录系统', result: '通过', details: '成功登录到仪表板' });
    });

    await test.step('2. 验证用户管理权限', async () => {
      await dashboardPage.navigateToUserManagement();
      
      // 验证用户管理页面可访问
      await expect(page.locator('.user-management-header')).toBeVisible();
      
      // 验证创建用户权限
      await userManagementPage.clickCreateUser();
      await expect(page.locator('.user-form')).toBeVisible();
      testResults.push({ step: '用户管理权限', result: '通过', details: '可访问用户管理页面和创建用户功能' });
    });

    await test.step('3. 验证角色管理权限', async () => {
      await dashboardPage.navigateToRoleManagement();
      
      // 验证角色管理页面可访问
      await expect(page.locator('.role-management-header')).toBeVisible();
      
      // 验证创建角色权限
      await roleManagementPage.clickCreateRole();
      await expect(page.locator('.role-form')).toBeVisible();
      testResults.push({ step: '角色管理权限', result: '通过', details: '可访问角色管理页面和创建角色功能' });
    });

    await test.step('4. 验证菜单管理权限', async () => {
      await dashboardPage.navigateToMenuManagement();
      
      // 验证菜单管理页面可访问
      await expect(page.locator('.menu-management-header')).toBeVisible();
      
      // 验证创建菜单权限
      await menuManagementPage.clickCreateMenu();
      await expect(page.locator('.menu-form')).toBeVisible();
      testResults.push({ step: '菜单管理权限', result: '通过', details: '可访问菜单管理页面和创建菜单功能' });
    });

    await test.step('5. 验证系统配置权限', async () => {
      await dashboardPage.navigateToSystemConfig();
      
      // 验证系统配置页面可访问
      await expect(page.locator('.system-config-header')).toBeVisible();
      
      // 验证配置修改权限
      await systemConfigPage.clickEditConfig();
      await expect(page.locator('.config-form')).toBeVisible();
      testResults.push({ step: '系统配置权限', result: '通过', details: '可访问系统配置页面和修改配置功能' });
    });

    // 生成测试报告
    console.log(`\n=== ${user.role}权限验证报告 ===`);
    testResults.forEach(result => {
      console.log(`[${result.result}] ${result.step}: ${result.details}`);
    });
  });

  // 测试2: 系统管理员权限验证
  test('PERM-002: 系统管理员权限验证', async ({ page }) => {
    const user = TEST_USERS.systemAdmin;
    const testResults = [];

    await test.step(`1. ${user.role}登录系统`, async () => {
      await loginPage.goto();
      await loginPage.login(user.username, user.password);
      await expect(page).toHaveURL(/.*dashboard/);
      testResults.push({ step: '登录系统', result: '通过', details: '成功登录到仪表板' });
    });

    await test.step('2. 验证用户管理权限', async () => {
      await dashboardPage.navigateToUserManagement();
      
      // 验证用户管理页面可访问
      await expect(page.locator('.user-management-header')).toBeVisible();
      
      // 验证创建用户权限
      await userManagementPage.clickCreateUser();
      await expect(page.locator('.user-form')).toBeVisible();
      testResults.push({ step: '用户管理权限', result: '通过', details: '可访问用户管理页面和创建用户功能' });
    });

    await test.step('3. 验证角色管理权限', async () => {
      await dashboardPage.navigateToRoleManagement();
      
      // 验证角色管理页面可访问
      await expect(page.locator('.role-management-header')).toBeVisible();
      
      // 验证创建角色权限
      await roleManagementPage.clickCreateRole();
      await expect(page.locator('.role-form')).toBeVisible();
      testResults.push({ step: '角色管理权限', result: '通过', details: '可访问角色管理页面和创建角色功能' });
    });

    await test.step('4. 验证菜单管理权限', async () => {
      await dashboardPage.navigateToMenuManagement();
      
      // 验证菜单管理页面可访问
      await expect(page.locator('.menu-management-header')).toBeVisible();
      
      // 验证创建菜单权限
      await menuManagementPage.clickCreateMenu();
      await expect(page.locator('.menu-form')).toBeVisible();
      testResults.push({ step: '菜单管理权限', result: '通过', details: '可访问菜单管理页面和创建菜单功能' });
    });

    await test.step('5. 验证系统配置权限限制', async () => {
      await dashboardPage.navigateToSystemConfig();
      
      // 验证系统配置页面可访问
      await expect(page.locator('.system-config-header')).toBeVisible();
      
      // 验证配置修改权限（可能受限）
      try {
        await systemConfigPage.clickEditConfig();
        await expect(page.locator('.config-form')).toBeVisible();
        testResults.push({ step: '系统配置权限', result: '通过', details: '可访问系统配置页面和修改配置功能' });
      } catch (error) {
        testResults.push({ step: '系统配置权限', result: '受限', details: '系统配置修改功能受限' });
      }
    });

    // 生成测试报告
    console.log(`\n=== ${user.role}权限验证报告 ===`);
    testResults.forEach(result => {
      console.log(`[${result.result}] ${step}: ${result.details}`);
    });
  });

  // 测试3: 普通用户权限验证
  test('PERM-003: 普通用户权限验证', async ({ page }) => {
    const user = TEST_USERS.regularUser;
    const testResults = [];

    await test.step(`1. ${user.role}登录系统`, async () => {
      await loginPage.goto();
      await loginPage.login(user.username, user.password);
      await expect(page).toHaveURL(/.*dashboard/);
      testResults.push({ step: '登录系统', result: '通过', details: '成功登录到仪表板' });
    });

    await test.step('2. 验证用户管理权限限制', async () => {
      try {
        await dashboardPage.navigateToUserManagement();
        
        // 如果能够访问，验证是否有限制
        const hasAccess = await page.locator('.user-management-header').isVisible();
        if (hasAccess) {
          testResults.push({ step: '用户管理权限', result: '受限', details: '可访问但功能受限' });
        } else {
          testResults.push({ step: '用户管理权限', result: '拒绝', details: '无法访问用户管理页面' });
        }
      } catch (error) {
        testResults.push({ step: '用户管理权限', result: '拒绝', details: '权限不足，无法访问' });
      }
    });

    await test.step('3. 验证角色管理权限限制', async () => {
      try {
        await dashboardPage.navigateToRoleManagement();
        
        const hasAccess = await page.locator('.role-management-header').isVisible();
        if (hasAccess) {
          testResults.push({ step: '角色管理权限', result: '受限', details: '可访问但功能受限' });
        } else {
          testResults.push({ step: '角色管理权限', result: '拒绝', details: '无法访问角色管理页面' });
        }
      } catch (error) {
        testResults.push({ step: '角色管理权限', result: '拒绝', details: '权限不足，无法访问' });
      }
    });

    await test.step('4. 验证菜单管理权限限制', async () => {
      try {
        await dashboardPage.navigateToMenuManagement();
        
        const hasAccess = await page.locator('.menu-management-header').isVisible();
        if (hasAccess) {
          testResults.push({ step: '菜单管理权限', result: '受限', details: '可访问但功能受限' });
        } else {
          testResults.push({ step: '菜单管理权限', result: '拒绝', details: '无法访问菜单管理页面' });
        }
      } catch (error) {
        testResults.push({ step: '菜单管理权限', result: '拒绝', details: '权限不足，无法访问' });
      }
    });

    await test.step('5. 验证系统配置权限限制', async () => {
      try {
        await dashboardPage.navigateToSystemConfig();
        
        const hasAccess = await page.locator('.system-config-header').isVisible();
        if (hasAccess) {
          testResults.push({ step: '系统配置权限', result: '受限', details: '可访问但功能受限' });
        } else {
          testResults.push({ step: '系统配置权限', result: '拒绝', details: '无法访问系统配置页面' });
        }
      } catch (error) {
        testResults.push({ step: '系统配置权限', result: '拒绝', details: '权限不足，无法访问' });
      }
    });

    // 生成测试报告
    console.log(`\n=== ${user.role}权限验证报告 ===`);
    testResults.forEach(result => {
      console.log(`[${result.result}] ${result.step}: ${result.details}`);
    });
  });

  // 测试4: 访客权限验证
  test('PERM-004: 访客权限验证', async ({ page }) => {
    const user = TEST_USERS.guest;
    const testResults = [];

    await test.step('1. 直接访问系统管理页面', async () => {
      await page.goto('/user-management');
      
      // 验证是否被重定向到登录页面
      const currentUrl = page.url();
      if (currentUrl.includes('/login')) {
        testResults.push({ step: '用户管理页面访问', result: '拒绝', details: '被重定向到登录页面' });
      } else {
        testResults.push({ step: '用户管理页面访问', result: '异常', details: '未正确重定向' });
      }
    });

    await test.step('2. 直接访问角色管理页面', async () => {
      await page.goto('/role-management');
      
      const currentUrl = page.url();
      if (currentUrl.includes('/login')) {
        testResults.push({ step: '角色管理页面访问', result: '拒绝', details: '被重定向到登录页面' });
      } else {
        testResults.push({ step: '角色管理页面访问', result: '异常', details: '未正确重定向' });
      }
    });

    await test.step('3. 直接访问菜单管理页面', async () => {
      await page.goto('/menu-management');
      
      const currentUrl = page.url();
      if (currentUrl.includes('/login')) {
        testResults.push({ step: '菜单管理页面访问', result: '拒绝', details: '被重定向到登录页面' });
      } else {
        testResults.push({ step: '菜单管理页面访问', result: '异常', details: '未正确重定向' });
      }
    });

    await test.step('4. 直接访问系统配置页面', async () => {
      await page.goto('/system-config');
      
      const currentUrl = page.url();
      if (currentUrl.includes('/login')) {
        testResults.push({ step: '系统配置页面访问', result: '拒绝', details: '被重定向到登录页面' });
      } else {
        testResults.push({ step: '系统配置页面访问', result: '异常', details: '未正确重定向' });
      }
    });

    // 生成测试报告
    console.log(`\n=== ${user.role}权限验证报告 ===`);
    testResults.forEach(result => {
      console.log(`[${result.result}] ${result.step}: ${result.details}`);
    });
  });

  // 测试5: 权限边界测试
  test('PERM-005: 权限边界测试', async ({ page }) => {
    const testResults = [];

    await test.step('1. 测试越权访问', async () => {
      // 使用普通用户登录
      await loginPage.goto();
      await loginPage.login(TEST_USERS.regularUser.username, TEST_USERS.regularUser.password);
      await expect(page).toHaveURL(/.*dashboard/);

      // 尝试直接访问管理员功能URL
      await page.goto('/user-management/create');
      
      // 验证是否被阻止
      const isBlocked = await page.locator('.access-denied, .permission-error').isVisible() || 
                       page.url().includes('/login') || 
                       page.url().includes('/dashboard');
      
      if (isBlocked) {
        testResults.push({ step: '越权访问测试', result: '通过', details: '系统正确阻止了越权访问' });
      } else {
        testResults.push({ step: '越权访问测试', result: '失败', details: '系统未正确阻止越权访问' });
      }
    });

    await test.step('2. 测试API权限验证', async () => {
      // 模拟API调用权限验证
      const apiResponse = await page.request.get('/api/users');
      
      if (apiResponse.status() === 401 || apiResponse.status() === 403) {
        testResults.push({ step: 'API权限验证', result: '通过', details: 'API权限验证正常工作' });
      } else {
        testResults.push({ step: 'API权限验证', result: '警告', details: 'API权限验证可能需要加强' });
      }
    });

    // 生成测试报告
    console.log('\n=== 权限边界测试报告 ===');
    testResults.forEach(result => {
      console.log(`[${result.result}] ${result.step}: ${result.details}`);
    });
  });
});