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 { TestHelper } from './utils/testHelper';

test.describe('测试并行化验证', () => {
    test('并行执行多个独立测试', async ({ page, context }) => {
        const page1 = page;
        const page2 = await context.newPage();
        const page3 = await context.newPage();

        const loginPage1 = new LoginPage(page1);
        const loginPage2 = new LoginPage(page2);
        const loginPage3 = new LoginPage(page3);

        const startTime = Date.now();

        await test.step('并行登录三个页面', async () => {
            await Promise.all([
                loginPage1.goto(),
                loginPage2.goto(),
                loginPage3.goto()
            ]);

            await Promise.all([
                loginPage1.login('admin', 'admin123'),
                loginPage2.login('admin', 'admin123'),
                loginPage3.login('admin', 'admin123')
            ]);
        });

        const endTime = Date.now();
        const parallelTime = endTime - startTime;

        console.log(`并行登录时间: ${parallelTime}ms`);
        expect(parallelTime).toBeLessThan(5000);

        await test.step('验证所有页面登录成功', async () => {
            const url1 = page1.url();
            const url2 = page2.url();
            const url3 = page3.url();

            expect(url1).toContain('/dashboard');
            expect(url2).toContain('/dashboard');
            expect(url3).toContain('/dashboard');
        });
    });

    test('并行加载不同模块', async ({ page, context }) => {
        const page1 = page;
        const page2 = await context.newPage();
        const page3 = await context.newPage();

        const loginPage1 = new LoginPage(page1);
        const loginPage2 = new LoginPage(page2);
        const loginPage3 = new LoginPage(page3);

        await loginPage1.goto();
        await loginPage1.login('admin', 'admin123');
        await loginPage2.goto();
        await loginPage2.login('admin', 'admin123');
        await loginPage3.goto();
        await loginPage3.login('admin', 'admin123');

        const startTime = Date.now();

        await test.step('并行加载用户、角色、设置模块', async () => {
            await Promise.all([
                page1.goto('/users'),
                page2.goto('/roles'),
                page3.goto('/settings')
            ]);

            await Promise.all([
                page1.waitForSelector('[data-testid="user-table"]'),
                page2.waitForSelector('[data-testid="role-table"]'),
                page3.waitForSelector('[data-testid="settings-form"]')
            ]);
        });

        const endTime = Date.now();
        const parallelLoadTime = endTime - startTime;

        console.log(`并行加载时间: ${parallelLoadTime}ms`);
        expect(parallelLoadTime).toBeLessThan(3000);
    });

    test('并发API请求性能', async ({ page, request }) => {
        const loginPage = new LoginPage(page);
        await loginPage.goto();
        await loginPage.login('admin', 'admin123');
        await page.waitForURL(/.*dashboard/);

        const startTime = Date.now();

        await test.step('并发发送多个API请求', async () => {
            const token = await TestHelper.getAuthToken(page);

            const promises = [
                request.get('http://localhost:8084/api/users', {
                    headers: { 'Authorization': `Bearer ${token}` }
                }),
                request.get('http://localhost:8084/api/roles', {
                    headers: { 'Authorization': `Bearer ${token}` }
                }),
                request.get('http://localhost:8084/api/permissions', {
                    headers: { 'Authorization': `Bearer ${token}` }
                }),
                request.get('http://localhost:8084/api/departments', {
                    headers: { 'Authorization': `Bearer ${token}` }
                })
            ];

            const results = await Promise.all(promises);

            expect(results[0].status()).toBe(200);
            expect(results[1].status()).toBe(200);
            expect(results[2].status()).toBe(200);
            expect(results[3].status()).toBe(200);
        });

        const endTime = Date.now();
        const concurrentApiTime = endTime - startTime;

        console.log(`并发API请求时间: ${concurrentApiTime}ms`);
        expect(concurrentApiTime).toBeLessThan(2000);
    });

    test('测试隔离验证', async ({ page, context }) => {
        const page1 = page;
        const page2 = await context.newPage();

        const loginPage1 = new LoginPage(page1);
        const loginPage2 = new LoginPage(page2);

        await loginPage1.goto();
        await loginPage1.login('admin', 'admin123');
        await loginPage2.goto();
        await loginPage2.login('testuser', 'test123');

        await test.step('验证页面状态隔离', async () => {
            const url1 = page1.url();
            const url2 = page2.url();

            expect(url1).toContain('/dashboard');
            expect(url2).toContain('/dashboard');

            const storage1 = await page1.evaluate(() => {
                return localStorage.getItem('user');
            });

            const storage2 = await page2.evaluate(() => {
                return localStorage.getItem('user');
            });

            expect(storage1).not.toBe(storage2);
        });

        await test.step('验证页面操作隔离', async () => {
            await page1.goto('/users');
            await page2.goto('/roles');

            await page1.waitForSelector('[data-testid="user-table"]');
            await page2.waitForSelector('[data-testid="role-table"]');

            const url1 = page1.url();
            const url2 = page2.url();

            expect(url1).toContain('/users');
            expect(url2).toContain('/roles');
        });
    });
});

test.describe('测试分组策略', () => {
    test('按模块分组执行', async ({ page }) => {
        const loginPage = new LoginPage(page);
        await loginPage.goto();
        await loginPage.login('admin', 'admin123');

        const userModuleTests = [
            async () => {
                await page.goto('/users');
                await page.waitForSelector('[data-testid="user-table"]');
            },
            async () => {
                await page.goto('/users/create');
                await page.waitForSelector('[data-testid="user-form"]');
            }
        ];

        const roleModuleTests = [
            async () => {
                await page.goto('/roles');
                await page.waitForSelector('[data-testid="role-table"]');
            },
            async () => {
                await page.goto('/roles/create');
                await page.waitForSelector('[data-testid="role-form"]');
            }
        ];

        const startTime = Date.now();

        await test.step('按模块顺序执行测试', async () => {
            for (const test of userModuleTests) {
                await test();
            }

            for (const test of roleModuleTests) {
                await test();
            }
        });

        const endTime = Date.now();
        const sequentialTime = endTime - startTime;

        console.log(`顺序执行时间: ${sequentialTime}ms`);
    });

    test('按优先级分组执行', async ({ page }) => {
        const loginPage = new LoginPage(page);
        await loginPage.goto();
        await loginPage.login('admin', 'admin123');

        const highPriorityTests = [
            async () => {
                await page.goto('/users');
                await page.waitForSelector('[data-testid="user-table"]');
            }
        ];

        const lowPriorityTests = [
            async () => {
                await page.goto('/settings');
                await page.waitForSelector('[data-testid="settings-form"]');
            }
        ];

        const startTime = Date.now();

        await test.step('按优先级执行测试', async () => {
            for (const test of highPriorityTests) {
                await test();
            }

            for (const test of lowPriorityTests) {
                await test();
            }
        });

        const endTime = Date.now();
        const priorityTime = endTime - startTime;

        console.log(`优先级执行时间: ${priorityTime}ms`);
    });
});

test.describe('测试依赖优化', () => {
    test('减少测试间依赖', async ({ page }) => {
        const loginPage = new LoginPage(page);
        await loginPage.goto();
        await loginPage.login('admin', 'admin123');

        const startTime = Date.now();

        await test.step('执行独立测试', async () => {
            await page.goto('/users');
            await page.waitForSelector('[data-testid="user-table"]');

            await page.goto('/roles');
            await page.waitForSelector('[data-testid="role-table"]');

            await page.goto('/users');
            await page.waitForSelector('[data-testid="user-table"]');
        });

        const endTime = Date.now();
        const independentTime = endTime - startTime;

        console.log(`独立测试执行时间: ${independentTime}ms`);
        expect(independentTime).toBeLessThan(5000);
    });

    test('优化测试清理逻辑', async ({ page }) => {
        const loginPage = new LoginPage(page);
        await loginPage.goto();
        await loginPage.login('admin', 'admin123');

        const startTime = Date.now();

        await test.step('快速清理测试状态', async () => {
            await page.goto('/users');
            await page.waitForSelector('[data-testid="user-table"]');

            await TestHelper.clearAllStorage(page);

            await page.goto('/roles');
            await page.waitForSelector('[data-testid="role-table"]');

            await TestHelper.clearAllStorage(page);
        });

        const endTime = Date.now();
        const cleanupTime = endTime - startTime;

        console.log(`清理操作时间: ${cleanupTime}ms`);
        expect(cleanupTime).toBeLessThan(3000);
    });
});