// REST API 示例：用户管理
// GET /api/users - 获取用户列表
app.get('/api/users', async (req, res) => {
  try {
    const users = await User.findAll();
    res.json({
      success: true,
      data: users,
      total: users.length
    });
  } catch (error) {
    res.status(500).json({
      success: false,
      message: error.message
    });
  }
});
// POST /api/users - 创建用户
app.post('/api/users', async (req, res) => {
  try {
    const { name, email, role } = req.body;
    const user = await User.create({ name, email, role });
    res.status(201).json({
      success: true,
      data: user
    });
  } catch (error) {
    res.status(400).json({
      success: false,
      message: error.message
    });
  }
});

// GraphQL Schema 定义
const typeDefs = `
  type User {
    id: ID!
    name: String!
    email: String!
    posts: [Post!]!
  }
  
  type Post {
    id: ID!
    title: String!
    content: String!
    author: User!
  }
  
  type Query {
    users(limit: Int, offset: Int): [User!]!
    user(id: ID!): User
    posts(authorId: ID): [Post!]!
  }
  
  type Mutation {
    createUser(input: CreateUserInput!): User!
    updateUser(id: ID!, input: UpdateUserInput!): User!
  }
`;
// Resolver 实现
const resolvers = {
  Query: {
    users: async (_, { limit = 10, offset = 0 }) => {
      return await User.findAll({ limit, offset });
    },
    user: async (_, { id }) => {
      return await User.findByPk(id);
    }
  },
  User: {
    posts: async (user) => {
      return await Post.findAll({ where: { authorId: user.id } });
    }
  },
  Mutation: {
    createUser: async (_, { input }) => {
      return await User.create(input);
    }
  }
};

// user.proto - Protocol Buffers 定义
syntax = "proto3";
package user;
service UserService {
  rpc GetUser(GetUserRequest) returns (User);
  rpc CreateUser(CreateUserRequest) returns (User);
  rpc ListUsers(ListUsersRequest) returns (ListUsersResponse);
  rpc StreamUsers(StreamUsersRequest) returns (stream User);
}
message User {
  int32 id = 1;
  string name = 2;
  string email = 3;
  repeated string roles = 4;
}
message GetUserRequest {
  int32 id = 1;
}
message CreateUserRequest {
  string name = 1;
  string email = 2;
  repeated string roles = 3;
}

// gRPC 服务实现
const grpc = require('@grpc/grpc-js');
const protoLoader = require('@grpc/proto-loader');
const packageDefinition = protoLoader.loadSync('user.proto');
const userProto = grpc.loadPackageDefinition(packageDefinition).user;
const server = new grpc.Server();
server.addService(userProto.UserService.service, {
  getUser: async (call, callback) => {
    try {
      const user = await User.findByPk(call.request.id);
      callback(null, user);
    } catch (error) {
      callback(error);
    }
  },
  
  createUser: async (call, callback) => {
    try {
      const user = await User.create(call.request);
      callback(null, user);
    } catch (error) {
      callback(error);
    }
  },
  
  streamUsers: (call) => {
    // 流式响应示例
    const stream = User.findAllStream();
    stream.on('data', (user) => {
      call.write(user);
    });
    stream.on('end', () => {
      call.end();
    });
  }
});

// MCP 服务器实现示例
import { Server } from '@modelcontextprotocol/sdk/server/index.js';
import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
class AIDataService {
  constructor() {
    this.server = new Server(
      {
        name: 'ai-data-service',
        version: '1.0.0',
      },
      {
        capabilities: {
          resources: {},
          tools: {},
          prompts: {},
        },
      }
    );
    
    this.setupHandlers();
  }
  
  setupHandlers() {
    // 资源处理器
    this.server.setRequestHandler('resources/list', async () => {
      return {
        resources: [
          {
            uri: 'data://users',
            name: 'User Database',
            description: 'Access to user information',
            mimeType: 'application/json'
          },
          {
            uri: 'data://analytics',
            name: 'Analytics Data',
            description: 'Real-time analytics information',
            mimeType: 'application/json'
          }
        ]
      };
    });
    
    // 工具处理器
    this.server.setRequestHandler('tools/list', async () => {
      return {
        tools: [
          {
            name: 'query_users',
            description: 'Query user information with filters',
            inputSchema: {
              type: 'object',
              properties: {
                filters: {
                  type: 'object',
                  properties: {
                    role: { type: 'string' },
                    active: { type: 'boolean' }
                  }
                },
                limit: { type: 'number', default: 10 }
              }
            }
          }
        ]
      };
    });
    
    // 工具调用处理器
    this.server.setRequestHandler('tools/call', async (request) => {
      const { name, arguments: args } = request.params;
      
      switch (name) {
        case 'query_users':
          return await this.queryUsers(args);
        default:
          throw new Error(`Unknown tool: ${name}`);
      }
    });
  }
  
  async queryUsers(args) {
    const { filters = {}, limit = 10 } = args;
    
    // 模拟数据库查询
    const users = await User.findAll({
      where: filters,
      limit: limit
    });
    
    return {
      content: [
        {
          type: 'text',
          text: `Found ${users.length} users matching criteria`
        },
        {
          type: 'resource',
          resource: {
            uri: 'data://query-result',
            text: JSON.stringify(users, null, 2)
          }
        }
      ]
    };
  }
}
// 启动服务
const service = new AIDataService();
const transport = new StdioServerTransport();
await service.server.connect(transport);

// MCP 安全认证实现
class SecureMCPServer {
  constructor() {
    this.server = new Server({
      name: 'secure-mcp-service',
      version: '1.0.0'
    });
    
    this.setupSecurity();
  }
  
  setupSecurity() {
    // 认证中间件
    this.server.use(async (request, next) => {
      const token = request.headers?.authorization?.replace('Bearer ', '');
      
      if (!token) {
        throw new Error('Authentication required');
      }
      
      try {
        const payload = jwt.verify(token, process.env.JWT_SECRET);
        request.user = payload;
        
        // 记录访问日志
        this.logAccess(request.user, request.method, request.params);
        
        return await next();
      } catch (error) {
        throw new Error('Invalid authentication token');
      }
    });
    
    // 权限检查
    this.server.setRequestHandler('tools/call', async (request) => {
      const { name } = request.params;
      
      // 检查用户权限
      if (!this.hasPermission(request.user, name)) {
        throw new Error(`Insufficient permissions for tool: ${name}`);
      }
      
      return await this.executeTool(name, request.params.arguments);
    });
  }
  
  hasPermission(user, toolName) {
    const permissions = {
      'admin': ['*'],
      'user': ['query_users', 'get_profile'],
      'readonly': ['query_users']
    };
    
    const userPermissions = permissions[user.role] || [];
    return userPermissions.includes('*') || userPermissions.includes(toolName);
  }
  
  logAccess(user, method, params) {
    console.log(JSON.stringify({
      timestamp: new Date().toISOString(),
      userId: user.id,
      userRole: user.role,
      method: method,
      params: params,
      ip: this.getClientIP()
    }));
  }
}

// AI上下文管理示例
class AIContextManager {
  constructor() {
    this.contexts = new Map();
    this.tools = new Map();
  }
  
  // 动态上下文构建
  async buildContext(sessionId, query) {
    const context = {
      session: sessionId,
      timestamp: Date.now(),
      query: query,
      resources: [],
      tools: []
    };
    
    // 根据查询内容动态加载相关资源
    const relevantResources = await this.findRelevantResources(query);
    context.resources = relevantResources;
    
    // 识别可用工具
    const availableTools = await this.identifyTools(query);
    context.tools = availableTools;
    
    this.contexts.set(sessionId, context);
    return context;
  }
  
  // 智能工具调用
  async executeToolChain(sessionId, toolChain) {
    const context = this.contexts.get(sessionId);
    const results = [];
    
    for (const tool of toolChain) {
      const result = await this.executeTool(tool.name, tool.params, context);
      results.push(result);
      
      // 更新上下文
      context.previousResults = results;
    }
    
    return results;
  }
}

// 技术方案评分系统
class TechStackEvaluator {
  constructor() {
    this.criteria = {
      performance: { weight: 0.25, description: '性能表现' },
      maintainability: { weight: 0.20, description: '可维护性' },
      security: { weight: 0.20, description: '安全性' },
      ecosystem: { weight: 0.15, description: '生态系统' },
      learningCurve: { weight: 0.10, description: '学习曲线' },
      aiCompatibility: { weight: 0.10, description: 'AI兼容性' }
    };
  }
  
  evaluate(solutions) {
    const results = {};
    
    for (const [name, scores] of Object.entries(solutions)) {
      let totalScore = 0;
      const details = {};
      
      for (const [criterion, config] of Object.entries(this.criteria)) {
        const score = scores[criterion] || 0;
        const weightedScore = score * config.weight;
        totalScore += weightedScore;
        
        details[criterion] = {
          score: score,
          weighted: weightedScore
        };
      }
      
      results[name] = {
        totalScore: totalScore,
        details: details
      };
    }
    
    return results;
  }
}
// 使用示例
const evaluator = new TechStackEvaluator();
const solutions = {
  'REST API': {
    performance: 7,
    maintainability: 8,
    security: 7,
    ecosystem: 9,
    learningCurve: 9,
    aiCompatibility: 5
  },
  'GraphQL': {
    performance: 6,
    maintainability: 7,
    security: 8,
    ecosystem: 7,
    learningCurve: 6,
    aiCompatibility: 7
  },
  'gRPC': {
    performance: 9,
    maintainability: 6,
    security: 9,
    ecosystem: 6,
    learningCurve: 5,
    aiCompatibility: 6
  },
  'MCP': {
    performance: 8,
    maintainability: 9,
    security: 9,
    ecosystem: 5,
    learningCurve: 7,
    aiCompatibility: 10
  }
};
const evaluationResults = evaluator.evaluate(solutions);

// MCP实施最佳实践示例
class MCPBestPractices {
  constructor() {
    this.connectionPool = new MCPConnectionPool();
    this.securityManager = new MCPSecurityManager();
    this.monitoringSystem = new MCPMonitoringSystem();
  }
  
  // 最佳实践1：连接管理
  async establishConnection(serverConfig) {
    try {
      // 使用连接池管理连接
      const connection = await this.connectionPool.getConnection(serverConfig);
      
      // 设置连接监控
      this.monitoringSystem.monitorConnection(connection);
      
      // 配置安全策略
      await this.securityManager.applySecurityPolicy(connection);
      
      return connection;
    } catch (error) {
      this.handleConnectionError(error);
      throw error;
    }
  }
  
  // 最佳实践2：错误处理
  handleConnectionError(error) {
    const errorHandlers = {
      'CONNECTION_TIMEOUT': () => this.retryWithBackoff(),
      'AUTHENTICATION_FAILED': () => this.refreshCredentials(),
      'RATE_LIMIT_EXCEEDED': () => this.implementBackpressure(),
      'SERVER_UNAVAILABLE': () => this.switchToBackupServer()
    };
    
    const handler = errorHandlers[error.code];
    if (handler) {
      handler();
    } else {
      this.logUnknownError(error);
    }
  }
  
  // 最佳实践3：性能优化
  async optimizePerformance() {
    // 启用请求批处理
    this.enableRequestBatching();
    
    // 配置智能缓存
    this.configureIntelligentCaching();
    
    // 实施连接复用
    this.enableConnectionReuse();
    
    // 启用压缩传输
    this.enableCompression();
  }
}

# 迁移工具示例
class MCPMigrationTool:
    def __init__(self):
        self.legacy_apis = []
        self.mcp_servers = []
        self.migration_plan = {}
    
    def analyze_legacy_system(self, api_endpoints):
        """分析现有API系统"""
        analysis_result = {
            'total_endpoints': len(api_endpoints),
            'complexity_score': self.calculate_complexity(api_endpoints),
            'migration_priority': self.prioritize_migration(api_endpoints),
            'estimated_effort': self.estimate_effort(api_endpoints)
        }
        return analysis_result
    
    def generate_migration_plan(self, analysis_result):
        """生成迁移计划"""
        plan = {
            'phases': [],
            'timeline': {},
            'resource_requirements': {},
            'risk_assessment': {}
        }
        
        # 根据优先级和复杂度生成分阶段迁移计划
        high_priority = analysis_result['migration_priority']['high']
        medium_priority = analysis_result['migration_priority']['medium']
        low_priority = analysis_result['migration_priority']['low']
        
        plan['phases'] = [
            {'name': 'Phase 1', 'apis': high_priority, 'duration': '4-6 weeks'},
            {'name': 'Phase 2', 'apis': medium_priority, 'duration': '6-8 weeks'},
            {'name': 'Phase 3', 'apis': low_priority, 'duration': '4-6 weeks'}
        ]
        
        return plan
    
    def create_mcp_adapter(self, legacy_api):
        """为传统API创建MCP适配器"""
        adapter_code = f"""
        class {legacy_api.name}MCPAdapter:
            def __init__(self):
                self.legacy_client = {legacy_api.name}Client()
            
            async def handle_mcp_request(self, request):
                # 将MCP请求转换为传统API调用
                legacy_params = self.convert_mcp_to_legacy(request.params)
                result = await self.legacy_client.call(legacy_params)
                
                # 将传统API响应转换为MCP格式
                return self.convert_legacy_to_mcp(result)
        """
        return adapter_code

# ROI计算模型
class IntegrationROICalculator:
    def __init__(self):
        self.cost_factors = {
            'development_time': 0,
            'maintenance_effort': 0,
            'infrastructure_cost': 0,
            'training_cost': 0,
            'migration_cost': 0
        }
        
        self.benefit_factors = {
            'development_speed_improvement': 0,
            'maintenance_cost_reduction': 0,
            'performance_improvement': 0,
            'security_enhancement': 0,
            'scalability_benefit': 0
        }
    
    def calculate_total_cost(self, solution_type: str, project_size: str) -> float:
        """计算总成本"""
        base_costs = {
            'REST': {'small': 50000, 'medium': 150000, 'large': 500000},
            'GraphQL': {'small': 60000, 'medium': 180000, 'large': 600000},
            'gRPC': {'small': 70000, 'medium': 200000, 'large': 700000},
            'MCP': {'small': 40000, 'medium': 120000, 'large': 400000}
        }
        
        base_cost = base_costs[solution_type][project_size]
        
        # 添加维护成本（3年）
        maintenance_multiplier = {
            'REST': 1.5, 'GraphQL': 1.3, 'gRPC': 1.6, 'MCP': 1.2
        }
        
        total_cost = base_cost * maintenance_multiplier[solution_type]
        return total_cost
    
    def calculate_benefits(self, solution_type: str, project_size: str) -> float:
        """计算收益"""
        benefit_multipliers = {
            'REST': 1.0,
            'GraphQL': 1.2,
            'gRPC': 1.4,
            'MCP': 1.8
        }
        
        base_benefit = self.calculate_total_cost('REST', project_size)
        return base_benefit * benefit_multipliers[solution_type]
    
    def calculate_roi(self, solution_type: str, project_size: str) -> dict:
        """计算ROI"""
        total_cost = self.calculate_total_cost(solution_type, project_size)
        total_benefit = self.calculate_benefits(solution_type, project_size)
        
        roi_percentage = ((total_benefit - total_cost) / total_cost) * 100
        payback_period = total_cost / (total_benefit / 36)  # 36个月
        
        return {
            'total_cost': total_cost,
            'total_benefit': total_benefit,
            'roi_percentage': roi_percentage,
            'payback_period_months': payback_period,
            'net_present_value': total_benefit - total_cost
        }

# 风险缓解策略实现
class RiskMitigationStrategy:
    def __init__(self):
        self.risk_registry = {}
        self.mitigation_plans = {}
    
    def assess_protocol_maturity_risk(self):
        """评估协议成熟度风险"""
        risk = {
            'id': 'PROTOCOL_MATURITY',
            'level': 'MEDIUM',
            'description': 'MCP协议相对较新，可能存在未知问题',
            'probability': 0.3,
            'impact': 0.6,
            'risk_score': 0.18
        }
        
        mitigation = {
            'strategy': 'GRADUAL_ADOPTION',
            'actions': [
                '从非关键系统开始试点',
                '建立回退机制',
                '密切关注协议更新',
                '参与社区反馈'
            ],
            'timeline': '6-12个月',
            'cost': 'LOW'
        }
        
        self.risk_registry[risk['id']] = risk
        self.mitigation_plans[risk['id']] = mitigation
        
        return risk, mitigation
    
    def create_contingency_plan(self):
        """创建应急预案"""
        contingency_plan = {
            'trigger_conditions': [
                'MCP服务器不可用超过30分钟',
                '性能下降超过50%',
                '安全漏洞被发现'
            ],
            'response_actions': [
                '自动切换到备用系统',
                '启动降级服务模式',
                '通知相关团队',
                '执行数据备份'
            ],
            'recovery_procedures': [
                '问题根因分析',
                '系统修复验证',
                '服务逐步恢复',
                '事后总结改进'
            ]
        }
        return contingency_plan