import { FullConfig } from '@playwright/test';
import { spawn, ChildProcess } from 'child_process';
import path from 'path';
import { fileURLToPath } from 'url';
import { existsSync } from 'fs';

const __filename = fileURLToPath(import.meta.url);
const __dirname = path.dirname(__filename);

let backendProcess: ChildProcess | null = null;
let frontendProcess: ChildProcess | null = null;
let healthCheckInterval: NodeJS.Timeout | null = null;

async function checkBackendHealth(): Promise<boolean> {
  try {
    const response = await fetch('http://localhost:8084/actuator/health', {
      signal: AbortSignal.timeout(5000)
    } as any);
    if (response.ok) {
      const data = await response.json();
      return data.status === 'UP';
    }
    return false;
  } catch (error) {
    return false;
  }
}

function startHealthMonitoring() {
  if (healthCheckInterval) {
    clearInterval(healthCheckInterval);
  }
  
  healthCheckInterval = setInterval(async () => {
    const isHealthy = await checkBackendHealth();
    if (!isHealthy) {
      console.error('⚠️  后端服务健康检查失败！');
    }
  }, 30000);
}

function stopHealthMonitoring() {
  if (healthCheckInterval) {
    clearInterval(healthCheckInterval);
    healthCheckInterval = null;
  }
}

async function globalSetup(config: FullConfig) {
  console.log('🚀 开始全局测试环境设置...');
  
  process.env.NODE_ENV = 'test';
  process.env.PLAYWRIGHT_HEADLESS = 'false';
  
  const backendDir = path.resolve(__dirname, '../../novalon-manage-api/manage-app');
  const jarFile = path.join(backendDir, 'target/manage-app-1.0.0.jar');
  
  let backendCommand: string;
  let backendArgs: string[];
  
  if (existsSync(jarFile)) {
    console.log('📦 使用JAR文件启动后端服务...');
    console.log(`   JAR文件: ${jarFile}`);
    backendCommand = 'java';
    backendArgs = [
      '-jar',
      jarFile,
      '--spring.profiles.active=test',
      '-Xms256m',
      '-Xmx512m'
    ];
  } else {
    console.log('📦 使用Maven启动后端服务...');
    console.log('   提示: 运行 "mvn clean package -DskipTests" 构建JAR文件以获得更快的启动速度');
    backendCommand = 'mvn';
    backendArgs = ['spring-boot:run', '-Dspring-boot.run.profiles=test'];
  }
  
  console.log(`   目录: ${backendDir}`);
  console.log(`   命令: ${backendCommand} ${backendArgs.join(' ')}`);
  
  backendProcess = spawn(backendCommand, backendArgs, {
    cwd: backendDir,
    stdio: 'pipe',
    shell: true,
    detached: false,
    env: { ...process.env, SPRING_PROFILES_ACTIVE: 'test' }
  });
  
  if (backendProcess.stdout) {
    backendProcess.stdout.on('data', (data) => {
      const output = data.toString();
      if (output.includes('Started ManageApplication') || output.includes('Tomcat started on port')) {
        console.log('✅ 后端服务启动成功');
      }
    });
  }
  
  if (backendProcess.stderr) {
    backendProcess.stderr.on('data', (data) => {
      const output = data.toString();
      if (output.includes('ERROR') || output.includes('Exception')) {
        console.error('❌ 后端服务启动错误:', output);
      }
    });
  }
  
  backendProcess.on('error', (error) => {
    console.error('❌ 后端服务启动失败:', error);
  });
  
  backendProcess.on('exit', (code, signal) => {
    if (code !== 0 && code !== null) {
      console.error(`❌ 后端服务异常退出，退出码: ${code}, 信号: ${signal}`);
    }
  });
  
  console.log('⏳ 等待后端服务就绪...');
  await waitForBackendReady();
  
  const frontendDir = path.resolve(__dirname, '..');
  console.log('🌐 启动前端服务...');
  console.log(`   目录: ${frontendDir}`);
  
  frontendProcess = spawn('pnpm', ['run', 'dev'], {
    cwd: frontendDir,
    stdio: 'pipe',
    shell: true,
    detached: false,
    env: { ...process.env, NODE_ENV: 'test' }
  });
  
  if (frontendProcess.stdout) {
    frontendProcess.stdout.on('data', (data) => {
      const output = data.toString();
      if (output.includes('Local:') || output.includes('localhost:3002')) {
        console.log('✅ 前端服务启动成功');
      }
    });
  }
  
  if (frontendProcess.stderr) {
    frontendProcess.stderr.on('data', (data) => {
      const output = data.toString();
      if (output.includes('ERROR') || output.includes('error')) {
        console.error('❌ 前端服务启动错误:', output);
      }
    });
  }
  
  frontendProcess.on('error', (error) => {
    console.error('❌ 前端服务启动失败:', error);
  });
  
  frontendProcess.on('exit', (code, signal) => {
    if (code !== 0 && code !== null) {
      console.error(`❌ 前端服务异常退出，退出码: ${code}, 信号: ${signal}`);
    }
  });
  
  console.log('⏳ 等待前端服务就绪...');
  await waitForFrontendReady();
  
  console.log('🧹 清理测试数据...');
  await cleanupTestData();
  
  startHealthMonitoring();
  
  console.log('✅ 全局测试环境设置完成');
}

async function waitForBackendReady(): Promise<void> {
  const maxRetries = 60;
  const retryInterval = 1000;
  
  for (let i = 0; i < maxRetries; i++) {
    try {
      const response = await fetch('http://localhost:8084/actuator/health');
      if (response.ok) {
        const data = await response.json();
        if (data.status === 'UP') {
          console.log(`✅ 后端服务健康检查通过 (尝试 ${i + 1}/${maxRetries})`);
          return;
        }
      }
    } catch (error) {
      // 服务还未就绪，继续等待
    }
    
    if (i < maxRetries - 1) {
      await new Promise(resolve => setTimeout(resolve, retryInterval));
    }
  }
  
  throw new Error('❌ 后端服务启动超时');
}

async function waitForFrontendReady(): Promise<void> {
  const maxRetries = 60;
  const retryInterval = 1000;
  
  for (let i = 0; i < maxRetries; i++) {
    try {
      const response = await fetch('http://localhost:3002', {
        signal: AbortSignal.timeout(5000) as any
      });
      if (response.ok) {
        console.log(`✅ 前端服务健康检查通过 (尝试 ${i + 1}/${maxRetries})`);
        return;
      }
    } catch (error) {
      // 服务还未就绪，继续等待
    }
    
    if (i < maxRetries - 1) {
      await new Promise(resolve => setTimeout(resolve, retryInterval));
    }
  }
  
  throw new Error('❌ 前端服务启动超时');
}

async function cleanupTestData(): Promise<void> {
  try {
    // 登录获取token
    const loginResponse = await fetch('http://localhost:8084/api/auth/login', {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
      },
      body: JSON.stringify({
        username: 'admin',
        password: 'admin123'
      })
    });
    
    if (!loginResponse.ok) {
      console.log('⚠️  无法登录，跳过数据清理');
      return;
    }
    
    const loginData = await loginResponse.json();
    const token = loginData.token;
    
    // 获取所有用户
    const usersResponse = await fetch('http://localhost:8084/api/users', {
      headers: {
        'Authorization': `Bearer ${token}`
      }
    });
    
    if (usersResponse.ok) {
      const users = await usersResponse.json();
      
      // 删除测试创建的用户（保留ID 1-10的初始用户）
      for (const user of users) {
        if (user.id > 10) {
          try {
            await fetch(`http://localhost:8084/api/users/${user.id}`, {
              method: 'DELETE',
              headers: {
                'Authorization': `Bearer ${token}`
              }
            });
            console.log(`   删除用户: ${user.username}`);
          } catch (error) {
            console.log(`   ⚠️  无法删除用户 ${user.username}`);
          }
        }
      }
    }
    
    // 获取所有角色
    const rolesResponse = await fetch('http://localhost:8084/api/roles', {
      headers: {
        'Authorization': `Bearer ${token}`
      }
    });
    
    if (rolesResponse.ok) {
      const roles = await rolesResponse.json();
      
      // 删除测试创建的角色（保留ID 1-4的初始角色）
      for (const role of roles) {
        if (role.id > 4) {
          try {
            await fetch(`http://localhost:8084/api/roles/${role.id}`, {
              method: 'DELETE',
              headers: {
                'Authorization': `Bearer ${token}`
              }
            });
            console.log(`   删除角色: ${role.roleName}`);
          } catch (error) {
            console.log(`   ⚠️  无法删除角色 ${role.roleName}`);
          }
        }
      }
    }
    
    console.log('✅ 测试数据清理完成');
  } catch (error) {
    console.log('⚠️  数据清理失败，继续执行测试');
    console.error('清理错误:', error);
  }
}

async function globalTeardown() {
  console.log('🧹 开始全局测试环境清理...');
  
  stopHealthMonitoring();
  
  if (backendProcess) {
    console.log('🛑 停止后端服务...');
    backendProcess.kill('SIGTERM');
    
    await new Promise<void>((resolve) => {
      if (backendProcess) {
        backendProcess.on('exit', () => {
          console.log('✅ 后端服务已停止');
          resolve();
        });
        
        setTimeout(() => {
          if (backendProcess) {
            backendProcess.kill('SIGKILL');
            console.log('⚠️  强制停止后端服务');
            resolve();
          }
        }, 10000);
      } else {
        resolve();
      }
    });
  }
  
  if (frontendProcess) {
    console.log('🛑 停止前端服务...');
    frontendProcess.kill('SIGTERM');
    
    await new Promise<void>((resolve) => {
      if (frontendProcess) {
        frontendProcess.on('exit', () => {
          console.log('✅ 前端服务已停止');
          resolve();
        });
        
        setTimeout(() => {
          if (frontendProcess) {
            frontendProcess.kill('SIGKILL');
            console.log('⚠️  强制停止前端服务');
            resolve();
          }
        }, 10000);
      } else {
        resolve();
      }
    });
  }
  
  console.log('✅ 全局测试环境清理完成');
}

export default globalSetup;
export { globalTeardown };