const { MongoClient } = require('mongodb');
const Redis = require('ioredis');
const Parse = require('parse/node');
require('dotenv').config();

// 测试结果收集器
const testResults = {
  mongodb: {
    status: 'pending',
    responseTime: null,
    error: null,
    details: {}
  },
  redis: {
    status: 'pending',
    responseTime: null,
    error: null,
    details: {}
  },
  parseServer: {
    status: 'pending',
    responseTime: null,
    error: null,
    details: {}
  }
};

// 颜色输出函数
const colors = {
  green: '\x1b[32m',
  red: '\x1b[31m',
  yellow: '\x1b[33m',
  blue: '\x1b[34m',
  reset: '\x1b[0m'
};

function log(message, color = colors.reset) {
  console.log(`${color}${message}${colors.reset}`);
}

// 测试MongoDB连接
async function testMongoDBConnection() {
  log('\n===== 测试MongoDB连接 =====', colors.blue);
  const startTime = Date.now();
  
  try {
    // 从环境变量获取MongoDB连接字符串
    const mongoUri = process.env.MONGODB_URI || 'mongodb://admin:admin123@localhost:27017/ecommerce_dev?authSource=admin';
    log(`连接字符串: ${mongoUri.replace(/\/\/([^:]+):([^@]+)@/, '//***:***@')}`, colors.yellow);
    
    const client = new MongoClient(mongoUri);
    
    // 尝试连接
    await client.connect();
    const responseTime = Date.now() - startTime;
    
    // 测试基本操作
    const admin = client.db().admin();
    const serverStatus = await admin.serverStatus();
    
    // 获取数据库列表
    const databases = await admin.listDatabases();
    
    testResults.mongodb = {
      status: 'success',
      responseTime,
      error: null,
      details: {
        version: serverStatus.version,
        host: serverStatus.host,
        databases: databases.databases.length,
        uptime: serverStatus.uptime
      }
    };
    
    log(`✅ MongoDB连接成功!`, colors.green);
    log(`   响应时间: ${responseTime}ms`, colors.green);
    log(`   MongoDB版本: ${serverStatus.version}`, colors.green);
    log(`   主机: ${serverStatus.host}`, colors.green);
    log(`   数据库数量: ${databases.databases.length}`, colors.green);
    
    await client.close();
  } catch (error) {
    const responseTime = Date.now() - startTime;
    testResults.mongodb = {
      status: 'failed',
      responseTime,
      error: error.message,
      details: {
        errorCode: error.code,
        errorName: error.name
      }
    };
    
    log(`❌ MongoDB连接失败!`, colors.red);
    log(`   错误: ${error.message}`, colors.red);
    log(`   响应时间: ${responseTime}ms`, colors.red);
  }
}

// 测试Redis连接
async function testRedisConnection() {
  log('\n===== 测试Redis连接 =====', colors.blue);
  const startTime = Date.now();
  
  try {
    // 从环境变量获取Redis连接配置
    const redisHost = process.env.REDIS_HOST || 'localhost';
    const redisPort = process.env.REDIS_PORT || 6379;
    const redisUrl = process.env.REDIS_URL || `redis://${redisHost}:${redisPort}`;
    
    log(`连接地址: ${redisUrl}`, colors.yellow);
    
    const redis = new Redis(redisUrl);
    
    // 测试连接
    const pong = await redis.ping();
    const responseTime = Date.now() - startTime;
    
    // 测试基本操作
    const testKey = 'test_connection_' + Date.now();
    await redis.set(testKey, 'test_value', 'EX', 10);
    const getValue = await redis.get(testKey);
    await redis.del(testKey);
    
    // 获取Redis信息
    const info = await redis.info('server');
    
    testResults.redis = {
      status: 'success',
      responseTime,
      error: null,
      details: {
        pong,
        testResult: getValue === 'test_value',
        redisVersion: info.match(/redis_version:(.+)/)?.[1] || 'unknown'
      }
    };
    
    log(`✅ Redis连接成功!`, colors.green);
    log(`   响应时间: ${responseTime}ms`, colors.green);
    log(`   PING响应: ${pong}`, colors.green);
    log(`   测试读写: ${getValue === 'test_value' ? '成功' : '失败'}`, colors.green);
    log(`   Redis版本: ${info.match(/redis_version:(.+)/)?.[1] || 'unknown'}`, colors.green);
    
    await redis.quit();
  } catch (error) {
    const responseTime = Date.now() - startTime;
    testResults.redis = {
      status: 'failed',
      responseTime,
      error: error.message,
      details: {
        errorCode: error.code,
        errorName: error.name
      }
    };
    
    log(`❌ Redis连接失败!`, colors.red);
    log(`   错误: ${error.message}`, colors.red);
    log(`   响应时间: ${responseTime}ms`, colors.red);
  }
}

// 测试Parse Server连接
async function testParseServerConnection() {
  log('\n===== 测试Parse Server连接 =====', colors.blue);
  const startTime = Date.now();
  
  try {
    // 从环境变量获取Parse Server配置
    const appId = process.env.PARSE_APP_ID || 'your-parse-application-id';
    const masterKey = process.env.PARSE_MASTER_KEY || 'your-parse-master-key-change-this';
    const serverURL = process.env.PARSE_SERVER_URL || 'http://localhost:1337/parse';
    
    log(`Parse Server URL: ${serverURL}`, colors.yellow);
    log(`Application ID: ${appId}`, colors.yellow);
    
    // 初始化Parse SDK
    Parse.initialize(appId, masterKey);
    Parse.serverURL = serverURL;
    
    // 测试连接 - 创建一个测试对象
    const TestObject = Parse.Object.extend('TestConnection');
    const testObject = new TestObject();
    testObject.set('message', 'Connection test at ' + new Date().toISOString());
    
    const savedObject = await testObject.save();
    const responseTime = Date.now() - startTime;
    
    // 测试查询
    const query = new Parse.Query(TestObject);
    query.equalTo('objectId', savedObject.id);
    const retrievedObject = await query.first();
    
    // 清理测试数据
    await retrievedObject.destroy();
    
    // 获取服务器状态
    const healthResponse = await fetch(`${serverURL}/health`).catch(() => null);
    
    testResults.parseServer = {
      status: 'success',
      responseTime,
      error: null,
      details: {
        objectId: savedObject.id,
        saveSuccess: true,
        retrieveSuccess: retrievedObject.id === savedObject.id,
        deleteSuccess: true,
        healthStatus: healthResponse ? healthResponse.status : 'not_available'
      }
    };
    
    log(`✅ Parse Server连接成功!`, colors.green);
    log(`   响应时间: ${responseTime}ms`, colors.green);
    log(`   对象保存: 成功`, colors.green);
    log(`   对象查询: 成功`, colors.green);
    log(`   对象删除: 成功`, colors.green);
    log(`   健康检查: ${healthResponse ? `HTTP ${healthResponse.status}` : '不可用'}`, colors.green);
  } catch (error) {
    const responseTime = Date.now() - startTime;
    testResults.parseServer = {
      status: 'failed',
      responseTime,
      error: error.message,
      details: {
        errorCode: error.code,
        errorName: error.name
      }
    };
    
    log(`❌ Parse Server连接失败!`, colors.red);
    log(`   错误: ${error.message}`, colors.red);
    log(`   响应时间: ${responseTime}ms`, colors.red);
  }
}

// 生成测试报告
function generateReport() {
  log('\n\n===== 连接测试报告 =====', colors.blue);
  log(`测试时间: ${new Date().toISOString()}`, colors.yellow);
  log('========================', colors.blue);
  
  let allSuccess = true;
  
  // MongoDB报告
  log('\n【MongoDB】', colors.blue);
  if (testResults.mongodb.status === 'success') {
    log(`状态: ✅ 成功`, colors.green);
    log(`响应时间: ${testResults.mongodb.responseTime}ms`, colors.green);
    log(`版本: ${testResults.mongodb.details.version}`, colors.green);
    log(`主机: ${testResults.mongodb.details.host}`, colors.green);
    log(`数据库数量: ${testResults.mongodb.details.databases}`, colors.green);
  } else {
    log(`状态: ❌ 失败`, colors.red);
    log(`错误: ${testResults.mongodb.error}`, colors.red);
    allSuccess = false;
  }
  
  // Redis报告
  log('\n【Redis】', colors.blue);
  if (testResults.redis.status === 'success') {
    log(`状态: ✅ 成功`, colors.green);
    log(`响应时间: ${testResults.redis.responseTime}ms`, colors.green);
    log(`PING响应: ${testResults.redis.details.pong}`, colors.green);
    log(`测试读写: ${testResults.redis.details.testResult ? '成功' : '失败'}`, colors.green);
    log(`版本: ${testResults.redis.details.redisVersion}`, colors.green);
  } else {
    log(`状态: ❌ 失败`, colors.red);
    log(`错误: ${testResults.redis.error}`, colors.red);
    allSuccess = false;
  }
  
  // Parse Server报告
  log('\n【Parse Server】', colors.blue);
  if (testResults.parseServer.status === 'success') {
    log(`状态: ✅ 成功`, colors.green);
    log(`响应时间: ${testResults.parseServer.responseTime}ms`, colors.green);
    log(`对象保存: ${testResults.parseServer.details.saveSuccess ? '成功' : '失败'}`, colors.green);
    log(`对象查询: ${testResults.parseServer.details.retrieveSuccess ? '成功' : '失败'}`, colors.green);
    log(`对象删除: ${testResults.parseServer.details.deleteSuccess ? '成功' : '失败'}`, colors.green);
    log(`健康检查: ${testResults.parseServer.details.healthStatus}`, colors.green);
  } else {
    log(`状态: ❌ 失败`, colors.red);
    log(`错误: ${testResults.parseServer.error}`, colors.red);
    allSuccess = false;
  }
  
  // 总体状态
  log('\n========================', colors.blue);
  if (allSuccess) {
    log('总体状态: ✅ 所有服务连接正常', colors.green);
  } else {
    log('总体状态: ❌ 部分服务连接失败', colors.red);
  }
  log('========================', colors.blue);
  
  // 保存报告到文件
  const reportData = {
    timestamp: new Date().toISOString(),
    results: testResults,
    overallStatus: allSuccess ? 'success' : 'failed'
  };
  
  const fs = require('fs');
  fs.writeFileSync(
    './connection-test-report.json', 
    JSON.stringify(reportData, null, 2)
  );
  
  log('\n详细报告已保存到: connection-test-report.json', colors.yellow);
  
  return allSuccess;
}

// 主函数
async function runConnectionTests() {
  log('开始执行连接测试...', colors.blue);
  
  await testMongoDBConnection();
  await testRedisConnection();
  await testParseServerConnection();
  
  const allSuccess = generateReport();
  
  process.exit(allSuccess ? 0 : 1);
}

// 运行测试
runConnectionTests().catch(error => {
  log(`\n测试执行过程中发生错误: ${error.message}`, colors.red);
  console.error(error);
  process.exit(1);
});