import { test as base, expect, Page } from '@playwright/test';
import { LoginPage } from '../pages/login-page';
import { DashboardPage } from '../pages/dashboard-page';
import { UserManagementPage } from '../pages/user-management-page';
import { testConfig } from '../core/test-config';

export type UATFixtures = {
  uatLogin: LoginPage;
  uatDashboard: DashboardPage;
  uatUserManagement: UserManagementPage;
};

export const test = base.extend<UATFixtures>({
  uatLogin: async ({ page }, use) => {
    const loginPage = new LoginPage(page);
    await use(loginPage);
  },
  uatDashboard: async ({ page }, use) => {
    const dashboardPage = new DashboardPage(page);
    await use(dashboardPage);
  },
  uatUserManagement: async ({ page }, use) => {
    const userManagementPage = new UserManagementPage(page);
    await use(userManagementPage);
  }
});

test.describe.configure({
  mode: 'serial',
  timeout: 60000
});

export const UATTestSteps = {
  async completeUserRegistrationFlow(page: Page, username: string, password: string) {
    const loginPage = new LoginPage(page);
    
    await test.step('用户打开登录页面', async () => {
      await page.goto(testConfig.getBaseURL());
      await expect(page).toHaveTitle(/登录/);
    });

    await test.step('用户输入用户名和密码', async () => {
      await loginPage.login(username, password);
    });

    await test.step('验证用户成功登录并跳转到仪表盘', async () => {
      await expect(page).toHaveURL(/.*dashboard/);
    });
  },

  async completeUserManagementFlow(page: Page, username: string, email: string, role: string) {
    const dashboardPage = new DashboardPage(page);
    const userManagementPage = new UserManagementPage(page);

    await test.step('用户导航到用户管理页面', async () => {
      await dashboardPage.navigateToUserManagement();
      await expect(page).toHaveURL(/.*users/);
    });

    await test.step('用户点击新增用户按钮', async () => {
      await userManagementPage.clickAddUser();
    });

    await test.step('用户填写用户信息', async () => {
      await userManagementPage.fillUserForm({
        username,
        email,
        password: 'Test@123456',
        confirmPassword: 'Test@123456',
        role,
        status: 'ACTIVE'
      });
    });

    await test.step('用户提交表单', async () => {
      await userManagementPage.submitUserForm();
    });

    await test.step('验证用户创建成功', async () => {
      await expect(page.locator('.ant-message-success')).toBeVisible();
    });
  },

  async completeAlmanacQueryFlow(page: Page, date: string) {
    await test.step('用户打开黄历查询页面', async () => {
      await page.goto(`${testConfig.getBaseURL()}/almanac`);
    });

    await test.step('用户选择日期', async () => {
      await page.fill('[data-testid="date-picker"]', date);
    });

    await test.step('用户点击查询按钮', async () => {
      await page.click('[data-testid="query-button"]');
    });

    await test.step('验证黄历信息显示', async () => {
      await expect(page.locator('[data-testid="almanac-result"]')).toBeVisible();
      await expect(page.locator('[data-testid="suitable-activities"]')).toBeVisible();
      await expect(page.locator('[data-testid="unsuitable-activities"]')).toBeVisible();
    });
  },

  async completeFortuneAnalysisFlow(page: Page) {
    await test.step('用户打开运势分析页面', async () => {
      await page.goto(`${testConfig.getBaseURL()}/fortune`);
    });

    await test.step('用户查看每日运势', async () => {
      await expect(page.locator('[data-testid="daily-fortune"]')).toBeVisible();
    });

    await test.step('用户查看每月运势', async () => {
      await page.click('[data-testid="monthly-fortune-tab"]');
      await expect(page.locator('[data-testid="monthly-fortune"]')).toBeVisible();
    });

    await test.step('用户查看每年运势', async () => {
      await page.click('[data-testid="yearly-fortune-tab"]');
      await expect(page.locator('[data-testid="yearly-fortune"]')).toBeVisible();
    });
  },

  async completeZiweiChartGenerationFlow(page: Page, birthDate: string, birthTime: string) {
    await test.step('用户打开紫微斗数页面', async () => {
      await page.goto(`${testConfig.getBaseURL()}/ziwei`);
    });

    await test.step('用户输入出生日期和时间', async () => {
      await page.fill('[data-testid="birth-date"]', birthDate);
      await page.fill('[data-testid="birth-time"]', birthTime);
    });

    await test.step('用户选择性别', async () => {
      await page.click('[data-testid="gender-male"]');
    });

    await test.step('用户点击生成命盘按钮', async () => {
      await page.click('[data-testid="generate-chart-button"]');
    });

    await test.step('验证命盘生成成功', async () => {
      await expect(page.locator('[data-testid="ziwei-chart"]')).toBeVisible();
      await expect(page.locator('[data-testid="palace-grid"]')).toBeVisible();
    });
  }
};

export const UATAssertions = {
  assertPageTitle(page: Page, expectedTitle: string) {
    return expect(page).toHaveTitle(new RegExp(expectedTitle));
  },

  assertElementVisible(page: Page, selector: string) {
    return expect(page.locator(selector)).toBeVisible();
  },

  assertElementText(page: Page, selector: string, expectedText: string) {
    return expect(page.locator(selector)).toHaveText(expectedText);
  },

  assertSuccessMessage(page: Page, message: string) {
    return expect(page.locator('.ant-message-success')).toContainText(message);
  },

  assertErrorMessage(page: Page, message: string) {
    return expect(page.locator('.ant-message-error')).toContainText(message);
  }
};