import { test as base, Page, BrowserContext, APIRequestContext } from '@playwright/test';
import { testConfig, TestEnvironment } from './core/test-config';
import { testDataGenerator, UserData, RoleData, MenuData, PermissionData } from './core/test-data';
import { testLogger } from './core/test-logger';
import { testReporter } from './core/test-reporter';
import { ActuatorMonitor } from './core/actuator-monitor';
import { TestDataManager } from './core/test-data-manager';
import { DataStrategyManager, dataStrategyManager } from './core/data-strategy-manager';
import { BasePage } from './pages/base-page';
import { LoginPage } from './pages/login-page';
import { DashboardPage } from './pages/dashboard-page';
import { UserManagementPage } from './pages/user-management-page';
import { RoleManagementPage } from './pages/role-management-page';
import { MenuManagementPage } from './pages/menu-management-page';
import { ScreenshotHelper } from './helpers/screenshot-helper';
import { FormHelper } from './helpers/form-helper';
import { TableHelper } from './helpers/table-helper';
import { AssertionHelper } from './helpers/assertion-helper';
import { APIHelper } from './helpers/api-helper';
import { MockManager, MockConfig } from './mock-manager';

export interface TestFixtures {
  page: Page;
  context: BrowserContext;
  request: APIRequestContext;
  testConfig: TestEnvironment;
  testDataGenerator: typeof testDataGenerator;
  testLogger: typeof testLogger;
  testReporter: typeof testReporter;
  actuatorMonitor: ActuatorMonitor;
  testDataManager: TestDataManager;
  dataStrategyManager: DataStrategyManager;
  
  pageObjects: {
    basePage: BasePage;
    loginPage: LoginPage;
    dashboardPage: DashboardPage;
    userManagementPage: UserManagementPage;
    roleManagementPage: RoleManagementPage;
    menuManagementPage: MenuManagementPage;
  };
  
  helpers: {
    screenshot: ScreenshotHelper;
    form: FormHelper;
    table: TableHelper;
    assertion: AssertionHelper;
    api: APIHelper;
  };
  
  mockManager: MockManager;
  
  testData: {
    user: UserData;
    admin: UserData;
    role: RoleData;
    menu: MenuData;
    permission: PermissionData;
  };
}

export const test = base.extend<TestFixtures>({
  page: async ({ page }, use) => {
    await use(page);
  },
  
  context: async ({ context }, use) => {
    await context.addInitScript(() => {
      localStorage.setItem('E2E_TEST', 'true');
    });
    await use(context);
  },
  
  request: async ({ request }, use) => {
    await use(request);
  },
  
  actuatorMonitor: async ({ request }, use) => {
    const apiBaseURL = process.env.API_BASE_URL || 'http://localhost:8080';
    const authToken = process.env.E2E_AUTH_TOKEN;
    const monitor = new ActuatorMonitor(request, apiBaseURL, authToken);
    
    await use(monitor);
  },
  
  testDataManager: async ({ request, testConfig }, use) => {
    const manager = new TestDataManager(request, testConfig.apiBaseURL);
    await use(manager);
    await manager.cleanup();
  },
  
  dataStrategyManager: async ({}, use) => {
    await use(dataStrategyManager);
  },
  
  testConfig: async ({}, use) => {
    const config = testConfig.getEnvironment();
    await use(config);
  },
  
  testDataGenerator: async ({}, use) => {
    await use(testDataGenerator);
  },
  
  testLogger: async ({}, use) => {
    await use(testLogger);
  },
  
  testReporter: async ({}, use) => {
    await use(testReporter);
  },
  
  pageObjects: async ({ page, testConfig }, use) => {
    const baseURL = testConfig.baseURL;
    const pageObjects = {
      basePage: new BasePage(page),
      loginPage: new LoginPage(page, testLogger, baseURL),
      dashboardPage: new DashboardPage(page),
      userManagementPage: new UserManagementPage(page),
      roleManagementPage: new RoleManagementPage(page),
      menuManagementPage: new MenuManagementPage(page)
    };
    
    await use(pageObjects);
  },
  
  helpers: async ({ page, request, testConfig }, use) => {
    const apiHelper = new APIHelper(request, testConfig.apiBaseURL);
    const helpers = {
      screenshot: new ScreenshotHelper(page),
      form: new FormHelper(page),
      table: new TableHelper(page),
      assertion: new AssertionHelper(),
      api: apiHelper
    };
    
    await use(helpers);
  },
  
  mockManager: async ({ page }, use) => {
    const mockConfig: MockConfig = {
      enabled: process.env.E2E_MOCK_ENABLED === 'true',
      mode: (process.env.E2E_MOCK_MODE as 'full' | 'partial' | 'none') || 'none',
      mockPaths: [],
      delay: 0,
      logCalls: true,
      validateResponses: true,
      dataSource: 'memory'
    };
    
    const mockManager = new MockManager(mockConfig);
    
    await mockManager.interceptAPIRequest(page);
    
    await use(mockManager);
  },
  
  testData: async ({}, use) => {
    const testData = {
      user: testDataGenerator.generateUserData({
        username: 'testuser',
        email: 'test@example.com',
        status: 'active'
      }),
      
      admin: testDataGenerator.generateUserData({
        username: 'admin',
        password: 'admin123456',
        email: 'admin@example.com',
        status: 'active',
        roleIds: [1]
      }),
      
      role: testDataGenerator.generateRoleData({
        name: '测试角色',
        code: 'test_role',
        status: 'active'
      }),
      
      menu: testDataGenerator.generateMenuData({
        name: '测试菜单',
        path: '/test',
        status: 'active'
      }),
      
      permission: testDataGenerator.generatePermissionData({
        name: '测试权限',
        code: 'test:permission',
        type: 'button'
      })
    };
    
    await use(testData);
  }
});

export const expect = test.expect;

export type PageObjects = TestFixtures['pageObjects'];
export type Helpers = TestFixtures['helpers'];
export type TestData = TestFixtures['testData'];