/**
 * 用户管理工作流实现
 * 实现用户管理相关的端到端业务流程
 */

import { Page } from '@playwright/test';
import { BusinessWorkflow, WorkflowStep } from '../core/business-workflows.js';
import { TestLogger } from '../core/test-logger.js';
import { TestDataManager, TestUser } from '../core/test-data-manager.js';
import { LoginPage } from '../pages/login-page.js';
import { UserManagementPage } from '../pages/user-management-page.js';

export interface UserWorkflowContext {
  page: Page;
  testLogger: TestLogger;
  testDataManager: TestDataManager;
  loginPage: LoginPage;
  userManagementPage: UserManagementPage;
  createdUser?: TestUser;
  createdUserId?: string;
}

/**
 * 创建用户工作流
 */
export function createUserWorkflow(context: UserWorkflowContext): BusinessWorkflow {
  const { page, testLogger, testDataManager, loginPage, userManagementPage } = context;

  return {
    name: 'createUser',
    description: '创建新用户的完整流程',
    
    preconditions: async () => {
      testLogger.info('🔍 检查前置条件: 用户已登录');
      // 检查是否已登录
      const currentUrl = page.url();
      if (!currentUrl.includes('/dashboard') && !currentUrl.includes('/users')) {
        testLogger.info('用户未登录，执行登录');
        await loginPage.navigate();
        await loginPage.login('admin', 'admin123');
        await page.waitForURL('**/dashboard', { timeout: 10000 });
      }
      return true;
    },

    steps: [
      {
        name: 'navigateToUserManagement',
        action: async () => {
          testLogger.info('🌐 导航到用户管理页面');
          await userManagementPage.navigate();
          await userManagementPage.waitForLoad();
        },
        timeout: 15000,
        retryCount: 3
      },
      {
        name: 'clickAddUserButton',
        action: async () => {
          testLogger.info('🖱️ 点击新增用户按钮');
          await userManagementPage.clickAddUser();
        },
        timeout: 10000,
        retryCount: 3
      },
      {
        name: 'fillUserForm',
        action: async () => {
          testLogger.info('📝 填写用户表单');
          context.createdUser = testDataManager.createTestUser();
          
          // 填写表单字段
          await page.fill('input[name="username"]', context.createdUser.username);
          await page.fill('input[name="password"]', context.createdUser.password);
          await page.fill('input[name="email"]', context.createdUser.email);
          
          if (context.createdUser.phone) {
            await page.fill('input[name="phone"]', context.createdUser.phone);
          }
          if (context.createdUser.realName) {
            await page.fill('input[name="realName"]', context.createdUser.realName);
          }
        },
        timeout: 15000,
        retryCount: 3
      },
      {
        name: 'submitUserForm',
        action: async () => {
          testLogger.info('📤 提交用户表单');
          await page.click('button[type="submit"]');
          
          // 等待提交完成
          await page.waitForSelector('.ant-message-success', {
            state: 'visible',
            timeout: 10000
          });
        },
        timeout: 15000,
        retryCount: 3
      },
      {
        name: 'verifyUserCreated',
        action: async () => {
          testLogger.info('✅ 验证用户创建成功');
          
          // 搜索新创建的用户
          if (context.createdUser) {
            await userManagementPage.searchUser(context.createdUser.username);
            
            // 验证用户出现在列表中
            const userCount = await userManagementPage.getUserCount();
            if (userCount === 0) {
              throw new Error('用户创建后未在列表中找到');
            }
          }
        },
        timeout: 15000,
        retryCount: 3
      }
    ],

    postconditions: async () => {
      testLogger.info('🔍 检查后置条件: 用户创建成功');
      return !!context.createdUser;
    },

    cleanup: async () => {
      testLogger.info('🧹 执行清理操作');
      // 清理创建的用户
      if (context.createdUser) {
        try {
          await userManagementPage.searchUser(context.createdUser.username);
          // 如果找到用户，执行删除
          const userCount = await userManagementPage.getUserCount();
          if (userCount > 0) {
            await userManagementPage.clickDeleteUser(0);
            await userManagementPage.confirmDelete();
          }
        } catch (error) {
          testLogger.warn('清理用户失败，可能用户不存在');
        }
      }
    }
  };
}

/**
 * 编辑用户工作流
 */
export function editUserWorkflow(context: UserWorkflowContext, targetUsername?: string): BusinessWorkflow {
  const { page, testLogger, testDataManager, loginPage, userManagementPage } = context;

  return {
    name: 'editUser',
    description: '编辑用户的完整流程',
    
    preconditions: async () => {
      testLogger.info('🔍 检查前置条件');
      // 确保已登录
      const currentUrl = page.url();
      if (!currentUrl.includes('/dashboard') && !currentUrl.includes('/users')) {
        await loginPage.navigate();
        await loginPage.login('admin', 'admin123');
        await page.waitForURL('**/dashboard', { timeout: 10000 });
      }
      return true;
    },

    steps: [
      {
        name: 'navigateToUserManagement',
        action: async () => {
          testLogger.info('🌐 导航到用户管理页面');
          await userManagementPage.navigate();
          await userManagementPage.waitForLoad();
        },
        timeout: 15000,
        retryCount: 3
      },
      {
        name: 'searchUser',
        action: async () => {
          testLogger.info('🔍 搜索目标用户');
          const searchUsername = targetUsername || context.createdUser?.username || 'admin';
          await userManagementPage.searchUser(searchUsername);
          
          // 验证找到用户
          const userCount = await userManagementPage.getUserCount();
          if (userCount === 0) {
            throw new Error(`未找到用户: ${searchUsername}`);
          }
        },
        timeout: 15000,
        retryCount: 3
      },
      {
        name: 'clickEditButton',
        action: async () => {
          testLogger.info('🖱️ 点击编辑按钮');
          await userManagementPage.clickEditUser(0);
        },
        timeout: 10000,
        retryCount: 3
      },
      {
        name: 'updateUserForm',
        action: async () => {
          testLogger.info('📝 更新用户表单');
          
          // 更新邮箱
          const newEmail = testDataManager.generateEmail('updated');
          await page.fill('input[name="email"]', newEmail);
          
          // 更新手机号
          const newPhone = testDataManager.generatePhone();
          await page.fill('input[name="phone"]', newPhone);
        },
        timeout: 10000,
        retryCount: 3
      },
      {
        name: 'submitUserForm',
        action: async () => {
          testLogger.info('📤 提交用户表单');
          await page.click('button[type="submit"]');
          
          // 等待提交完成
          await page.waitForSelector('.ant-message-success', {
            state: 'visible',
            timeout: 10000
          });
        },
        timeout: 15000,
        retryCount: 3
      },
      {
        name: 'verifyUserUpdated',
        action: async () => {
          testLogger.info('✅ 验证用户更新成功');
          
          // 验证成功消息
          const successMessage = await userManagementPage.getSuccessMessage();
          if (!successMessage.includes('成功')) {
            throw new Error('用户更新未显示成功消息');
          }
        },
        timeout: 10000,
        retryCount: 3
      }
    ]
  };
}

/**
 * 删除用户工作流
 */
export function deleteUserWorkflow(context: UserWorkflowContext, targetUsername?: string): BusinessWorkflow {
  const { page, testLogger, userManagementPage, loginPage } = context;

  return {
    name: 'deleteUser',
    description: '删除用户的完整流程',
    
    preconditions: async () => {
      testLogger.info('🔍 检查前置条件');
      const currentUrl = page.url();
      if (!currentUrl.includes('/dashboard') && !currentUrl.includes('/users')) {
        await loginPage.navigate();
        await loginPage.login('admin', 'admin123');
        await page.waitForURL('**/dashboard', { timeout: 10000 });
      }
      return true;
    },

    steps: [
      {
        name: 'navigateToUserManagement',
        action: async () => {
          testLogger.info('🌐 导航到用户管理页面');
          await userManagementPage.navigate();
          await userManagementPage.waitForLoad();
        },
        timeout: 15000,
        retryCount: 3
      },
      {
        name: 'searchUser',
        action: async () => {
          testLogger.info('🔍 搜索目标用户');
          const searchUsername = targetUsername || context.createdUser?.username;
          if (!searchUsername) {
            throw new Error('未指定要删除的用户');
          }
          await userManagementPage.searchUser(searchUsername);
          
          const userCount = await userManagementPage.getUserCount();
          if (userCount === 0) {
            throw new Error(`未找到用户: ${searchUsername}`);
          }
        },
        timeout: 15000,
        retryCount: 3
      },
      {
        name: 'clickDeleteButton',
        action: async () => {
          testLogger.info('🖱️ 点击删除按钮');
          await userManagementPage.clickDeleteUser(0);
        },
        timeout: 10000,
        retryCount: 3
      },
      {
        name: 'confirmDelete',
        action: async () => {
          testLogger.info('✅ 确认删除');
          await userManagementPage.confirmDelete();
        },
        timeout: 10000,
        retryCount: 3
      },
      {
        name: 'verifyUserDeleted',
        action: async () => {
          testLogger.info('✅ 验证用户删除成功');
          
          // 验证成功消息
          const successMessage = await userManagementPage.getSuccessMessage();
          if (!successMessage.includes('成功')) {
            throw new Error('用户删除未显示成功消息');
          }
        },
        timeout: 10000,
        retryCount: 3
      }
    ]
  };
}

/**
 * 用户生命周期工作流
 */
export function userLifecycleWorkflow(context: UserWorkflowContext): BusinessWorkflow {
  const { testLogger, testDataManager } = context;
  let createdUsername: string | undefined;

  return {
    name: 'userLifecycle',
    description: '用户从创建到删除的完整生命周期',
    
    steps: [
      {
        name: 'login',
        action: async () => {
          const loginWorkflow = createUserWorkflow(context);
          if (loginWorkflow.preconditions) {
            await loginWorkflow.preconditions();
          }
        },
        timeout: 20000,
        retryCount: 3
      },
      {
        name: 'createUser',
        action: async () => {
          const createWorkflow = createUserWorkflow(context);
          for (const step of createWorkflow.steps) {
            await step.action();
          }
          createdUsername = context.createdUser?.username;
        },
        timeout: 60000,
        retryCount: 3
      },
      {
        name: 'verifyUserInList',
        action: async () => {
          if (!createdUsername) {
            throw new Error('用户创建失败');
          }
          await context.userManagementPage.searchUser(createdUsername);
          const count = await context.userManagementPage.getUserCount();
          if (count === 0) {
            throw new Error('新创建的用户未在列表中');
          }
        },
        timeout: 15000,
        retryCount: 3
      },
      {
        name: 'editUser',
        action: async () => {
          const editWorkflow = editUserWorkflow(context, createdUsername);
          for (const step of editWorkflow.steps.slice(2)) { // 跳过导航和搜索
            await step.action();
          }
        },
        timeout: 45000,
        retryCount: 3
      },
      {
        name: 'verifyUserUpdated',
        action: async () => {
          testLogger.info('✅ 验证用户更新成功');
          const successMessage = await context.userManagementPage.getSuccessMessage();
          if (!successMessage.includes('成功')) {
            throw new Error('用户更新验证失败');
          }
        },
        timeout: 10000,
        retryCount: 3
      },
      {
        name: 'deleteUser',
        action: async () => {
          const deleteWorkflow = deleteUserWorkflow(context, createdUsername);
          for (const step of deleteWorkflow.steps.slice(2)) { // 跳过导航和搜索
            await step.action();
          }
        },
        timeout: 30000,
        retryCount: 3
      },
      {
        name: 'verifyUserDeleted',
        action: async () => {
          testLogger.info('✅ 验证用户删除成功');
          if (!createdUsername) return;
          
          await context.userManagementPage.searchUser(createdUsername);
          const count = await context.userManagementPage.getUserCount();
          if (count > 0) {
            throw new Error('用户删除后仍存在于列表中');
          }
        },
        timeout: 15000,
        retryCount: 3
      }
    ]
  };
}