import Koa from 'koa';
import bodyParser from 'koa-bodyparser';
import koaRedis from 'koa-redis';
import { redisConfig } from '../config/dbConfig';
import { Server } from 'http';

export class ServerManager {
  private servers: Map<number, { app: Koa; server: Server }> = new Map();
  private router: any;
  
  constructor(router: any) {
    this.router = router;
  }
  
  // 创建并启动一个新的服务器实例
  public createServer(port: number): boolean {
    if (this.servers.has(port)) {
      console.log(`端口 ${port} 已经在使用中`);
      return false;
    }
    
    try {
      const app = new Koa();
      app.proxy = true;
      
      // 配置Redis
      app.context.redis = koaRedis(redisConfig as any);
      
      // 配置中间件
      this.setupMiddlewares(app);
      
      // 启动服务器
      const server = app.listen(port, () => {
        console.log(`服务器成功启动在端口: ${port}`);
      });
      
      // 添加服务器错误处理
      server.on('error', (err: any) => {
        if (err.code === 'EADDRINUSE') {
          console.error(`端口 ${port} 已被占用`);
        } else {
          console.error(`服务器错误 (端口 ${port}):`, err);
        }
      });
      
      // 添加客户端连接错误处理
      server.on('clientError', (err: any, socket: any) => {
        if (err.message && err.message.includes('Parse Error')) {
          console.warn('客户端HTTP解析错误:', err.message);
          socket.end('HTTP/1.1 400 Bad Request\r\n\r\n');
        } else {
          console.error('客户端连接错误:', err);
          socket.end('HTTP/1.1 400 Bad Request\r\n\r\n');
        }
      });
      
      // 存储服务器实例
      this.servers.set(port, { app, server });
      return true;
    } catch (error) {
      console.error(`在端口 ${port} 启动服务器失败:`, error);
      return false;
    }
  }
  
  // 停止并移除一个服务器实例
  public removeServer(port: number): boolean {
    const serverInfo = this.servers.get(port);
    if (!serverInfo) {
      console.log(`端口 ${port} 没有运行中的服务器`);
      return false;
    }
    
    try {
      // 关闭服务器
      serverInfo.server.close();
      this.servers.delete(port);
      console.log(`端口 ${port} 的服务器已关闭`);
      return true;
    } catch (error) {
      console.error(`关闭端口 ${port} 的服务器失败:`, error);
      return false;
    }
  }
  
  // 获取所有活动的端口
  public getActivePorts(): number[] {
    return Array.from(this.servers.keys());
  }
  
  // 配置中间件
  private setupMiddlewares(app: Koa): void {
    // 全局错误处理中间件（必须在最前面）
    app.use(async (ctx, next) => {
      try {
        await next();
      } catch (err: any) {
        // 处理HTTP解析错误
        if (err.message && err.message.includes('Parse Error')) {
          console.warn('HTTP解析错误（可能是无效请求）:', err.message);
          ctx.status = 400;
          ctx.body = { error: 'Bad Request', message: 'Invalid HTTP request' };
          return;
        }
        
        // 其他错误
        console.error('服务器错误:', err);
        ctx.status = err.status || 500;
        ctx.body = { error: 'Internal Server Error', message: err.message };
      }
    });

    // CORS中间件
    app.use(async (ctx, next) => {
      ctx.set('Access-Control-Allow-Origin', '*');
      ctx.set('Access-Control-Allow-Headers', 'content-type');
      ctx.set('Access-Control-Allow-Methods', 'OPTIONS,GET,PUT,POST,DELETE');
      await next();
      
      if (ctx.request.method === 'OPTIONS') {
        console.log('跨域请求');
        ctx.response.status = 200;
        ctx.response.message = 'OK';
      }
    });
    
    // Body解析中间件（添加错误处理选项）
    app.use(bodyParser({
      enableTypes: ['json', 'form'],
      jsonLimit: '10mb',
      formLimit: '10mb',
      onerror: (err: Error, ctx: Koa.Context) => {
        console.warn('Body解析错误:', err.message);
        ctx.status = 400;
        ctx.body = { error: 'Bad Request', message: 'Invalid request body' };
      }
    }));
    
    // 路由中间件
    app.use(this.router.routes());
    app.use(this.router.allowedMethods());
  }
}