const {
  createRequest,
  createSuccessResponse,
  createErrorResponse,
  ErrorCode
} = require('@neural-trader/mcp-protocol');

// Create a JSON-RPC 2.0 request
const request = createRequest('list_strategies', { category: 'momentum' }, 'req-001');

console.log(request);
// {
//   jsonrpc: '2.0',
//   method: 'list_strategies',
//   params: { category: 'momentum' },
//   id: 'req-001'
// }

// Create a success response
const response = createSuccessResponse(
  { strategies: ['momentum-v1', 'momentum-v2'] },
  'req-001'
);

console.log(response);
// {
//   jsonrpc: '2.0',
//   result: { strategies: ['momentum-v1', 'momentum-v2'] },
//   id: 'req-001'
// }

// Create an error response
const error = createErrorResponse(
  ErrorCode.METHOD_NOT_FOUND,
  'Method not found',
  'req-002'
);

console.log(error);
// {
//   jsonrpc: '2.0',
//   error: { code: -32601, message: 'Method not found' },
//   id: 'req-002'
// }

const { createRequest } = require('@neural-trader/mcp-protocol');

// Request with ID (expects response)
const requestWithId = createRequest('method_name', { param: 'value' }, 'unique-id');

// Notification (no ID, no response expected)
const notification = createRequest('notify_event', { data: 'value' });

// Request with complex parameters
const complexRequest = createRequest(
  'execute_trade',
  {
    symbol: 'AAPL',
    side: 'BUY',
    quantity: 100,
    orderType: 'LIMIT',
    limitPrice: 175.50
  },
  'trade-001'
);

const {
  createRequest,
  createSuccessResponse,
  createErrorResponse,
  ErrorCode
} = require('@neural-trader/mcp-protocol');

// Client creates request
const request = createRequest('get_portfolio', { detailed: true }, 'port-001');

// Server processes and responds
try {
  const portfolioData = { /* ... portfolio data ... */ };
  const response = createSuccessResponse(portfolioData, request.id);
  // Send response back to client
} catch (error) {
  const errorResponse = createErrorResponse(
    ErrorCode.INTERNAL_ERROR,
    error.message,
    request.id
  );
  // Send error response back to client
}

const { ErrorCode } = require('@neural-trader/mcp-protocol');

// Standard error codes
console.log(ErrorCode.PARSE_ERROR);        // -32700: Invalid JSON
console.log(ErrorCode.INVALID_REQUEST);    // -32600: Invalid request object
console.log(ErrorCode.METHOD_NOT_FOUND);   // -32601: Method does not exist
console.log(ErrorCode.INVALID_PARAMS);     // -32602: Invalid method parameters
console.log(ErrorCode.INTERNAL_ERROR);     // -32603: Internal JSON-RPC error

// Server-defined error range
console.log(ErrorCode.SERVER_ERROR_START); // -32099
console.log(ErrorCode.SERVER_ERROR_END);   // -32000

const request = {
  jsonrpc: '2.0',
  method: 'run_backtest',
  params: {
    strategy: 'momentum',
    symbol: 'AAPL',
    startDate: '2024-01-01',
    endDate: '2024-12-31'
  },
  id: 'backtest-001'
};

// Success response
const successResponse = {
  jsonrpc: '2.0',
  result: {
    sharpeRatio: 1.85,
    totalReturn: 0.342,
    maxDrawdown: -0.125
  },
  id: 'backtest-001'
};

// Error response
const errorResponse = {
  jsonrpc: '2.0',
  error: {
    code: -32602,
    message: 'Invalid params: startDate must be before endDate'
  },
  id: 'backtest-001'
};

const error = {
  code: -32603,
  message: 'Internal error: Database connection failed',
  data: {
    timestamp: '2024-01-15T14:30:00Z',
    retryable: true,
    details: 'Connection timeout after 30s'
  }
};

const { createRequest } = require('@neural-trader/mcp-protocol');

// Simple request
const simpleRequest = createRequest('list_tools');

// Request with parameters
const paramRequest = createRequest('get_strategy_info', {
  strategyId: 'momentum-v1'
});

// Request with ID for response tracking
const trackedRequest = createRequest(
  'execute_trade',
  {
    symbol: 'AAPL',
    side: 'BUY',
    quantity: 100
  },
  'trade-12345'
);

// Notification (no ID, no response)
const notification = createRequest('price_update', {
  symbol: 'AAPL',
  price: 175.50
});

const { createSuccessResponse } = require('@neural-trader/mcp-protocol');

// Simple success response
const response1 = createSuccessResponse({ status: 'ok' }, 'req-001');

// Response with complex data
const response2 = createSuccessResponse(
  {
    portfolio: {
      cash: 50000,
      equity: 125000,
      positions: [
        { symbol: 'AAPL', quantity: 100, value: 17550 },
        { symbol: 'NVDA', quantity: 50, value: 24790 }
      ]
    }
  },
  'portfolio-001'
);

// Response with array data
const response3 = createSuccessResponse(
  ['momentum-v1', 'mean-reversion-v2', 'pairs-trading-v1'],
  'list-strategies-001'
);

const { createErrorResponse, ErrorCode } = require('@neural-trader/mcp-protocol');

// Method not found error
const error1 = createErrorResponse(
  ErrorCode.METHOD_NOT_FOUND,
  'Method "invalid_method" does not exist',
  'req-001'
);

// Invalid parameters error with details
const error2 = createErrorResponse(
  ErrorCode.INVALID_PARAMS,
  'Invalid trade parameters',
  'trade-001',
  {
    missing: ['symbol', 'quantity'],
    invalid: { side: 'INVALID_SIDE' }
  }
);

// Internal error with stack trace
const error3 = createErrorResponse(
  ErrorCode.INTERNAL_ERROR,
  'Database query failed',
  'db-query-001',
  {
    query: 'SELECT * FROM trades WHERE ...',
    error: 'Connection timeout',
    timestamp: new Date().toISOString()
  }
);

const { ErrorCode } = require('@neural-trader/mcp-protocol');

// Use constants instead of magic numbers
if (error.code === ErrorCode.METHOD_NOT_FOUND) {
  console.log('Method does not exist');
}

// Custom server errors (between SERVER_ERROR_END and SERVER_ERROR_START)
const CUSTOM_ERROR_CODE = -32050;
const customError = createErrorResponse(
  CUSTOM_ERROR_CODE,
  'Strategy execution failed',
  'strategy-001'
);

const {
  createRequest,
  createSuccessResponse,
  createErrorResponse,
  ErrorCode
} = require('@neural-trader/mcp-protocol');

class TradingRequestHandler {
  constructor() {
    this.requestCounter = 0;
  }

  // Generate unique request ID
  generateRequestId() {
    return `req-${Date.now()}-${++this.requestCounter}`;
  }

  // Create a trading request
  createTradeRequest(symbol, side, quantity, orderType) {
    return createRequest(
      'execute_trade',
      {
        symbol,
        side,
        quantity,
        orderType,
        timestamp: new Date().toISOString()
      },
      this.generateRequestId()
    );
  }

  // Create a backtest request
  createBacktestRequest(strategy, config) {
    return createRequest(
      'run_backtest',
      {
        strategy,
        config,
        timestamp: new Date().toISOString()
      },
      this.generateRequestId()
    );
  }

  // Create a query request
  createQueryRequest(method, params) {
    return createRequest(method, params, this.generateRequestId());
  }
}

// Usage
const handler = new TradingRequestHandler();
const tradeRequest = handler.createTradeRequest('AAPL', 'BUY', 100, 'MARKET');
console.log(tradeRequest);

class TradingResponseHandler {
  // Handle successful trade execution
  handleTradeSuccess(orderId, fillPrice, requestId) {
    return createSuccessResponse(
      {
        orderId,
        status: 'FILLED',
        fillPrice,
        timestamp: new Date().toISOString()
      },
      requestId
    );
  }

  // Handle backtest results
  handleBacktestSuccess(results, requestId) {
    return createSuccessResponse(
      {
        metrics: results.metrics,
        trades: results.trades,
        equityCurve: results.equityCurve
      },
      requestId
    );
  }

  // Handle errors
  handleError(code, message, requestId, details) {
    return createErrorResponse(code, message, requestId, details);
  }

  // Validate and route response
  routeResponse(response) {
    if (response.error) {
      console.error(`Error ${response.error.code}: ${response.error.message}`);
      return { success: false, error: response.error };
    } else {
      console.log('Success:', response.result);
      return { success: true, result: response.result };
    }
  }
}

// Usage
const responseHandler = new TradingResponseHandler();
const successResponse = responseHandler.handleTradeSuccess(
  'order-12345',
  175.50,
  'req-001'
);
console.log(successResponse);

async function completeTradingCycle() {
  const requestHandler = new TradingRequestHandler();
  const responseHandler = new TradingResponseHandler();

  // Create request
  const request = requestHandler.createTradeRequest('AAPL', 'BUY', 100, 'MARKET');
  console.log('Request:', request);

  // Simulate processing (in real app, this would be network call)
  try {
    // Simulate successful trade
    const orderId = 'order-' + Date.now();
    const fillPrice = 175.50;

    const response = responseHandler.handleTradeSuccess(
      orderId,
      fillPrice,
      request.id
    );

    console.log('Response:', response);

    // Route and handle response
    const result = responseHandler.routeResponse(response);
    if (result.success) {
      console.log('Trade executed successfully:', result.result);
    }
  } catch (error) {
    const errorResponse = responseHandler.handleError(
      ErrorCode.INTERNAL_ERROR,
      error.message,
      request.id,
      { error: error.toString() }
    );

    console.log('Error Response:', errorResponse);
  }
}

completeTradingCycle();

const {
  createErrorResponse,
  ErrorCode
} = require('@neural-trader/mcp-protocol');

class TradingErrorHandler {
  // Parse error - invalid JSON received
  handleParseError(requestId, rawData) {
    return createErrorResponse(
      ErrorCode.PARSE_ERROR,
      'Parse error: Invalid JSON',
      requestId || null,
      {
        receivedData: rawData.substring(0, 100), // First 100 chars
        timestamp: new Date().toISOString()
      }
    );
  }

  // Invalid request - missing required fields
  handleInvalidRequest(requestId, missingFields) {
    return createErrorResponse(
      ErrorCode.INVALID_REQUEST,
      'Invalid Request: Missing required fields',
      requestId || null,
      {
        missing: missingFields,
        requiredFields: ['jsonrpc', 'method'],
        timestamp: new Date().toISOString()
      }
    );
  }

  // Method not found
  handleMethodNotFound(method, requestId) {
    return createErrorResponse(
      ErrorCode.METHOD_NOT_FOUND,
      `Method not found: ${method}`,
      requestId,
      {
        method,
        availableMethods: [
          'execute_trade',
          'run_backtest',
          'get_portfolio',
          'list_strategies'
        ],
        timestamp: new Date().toISOString()
      }
    );
  }

  // Invalid parameters
  handleInvalidParams(method, requestId, validationErrors) {
    return createErrorResponse(
      ErrorCode.INVALID_PARAMS,
      `Invalid params for method: ${method}`,
      requestId,
      {
        method,
        errors: validationErrors,
        timestamp: new Date().toISOString()
      }
    );
  }

  // Internal error
  handleInternalError(requestId, error) {
    return createErrorResponse(
      ErrorCode.INTERNAL_ERROR,
      'Internal error occurred',
      requestId,
      {
        error: error.message,
        stack: process.env.NODE_ENV === 'development' ? error.stack : undefined,
        timestamp: new Date().toISOString()
      }
    );
  }

  // Custom server error
  handleCustomError(code, message, requestId, details) {
    // Ensure code is in server error range
    if (code > ErrorCode.SERVER_ERROR_END || code < ErrorCode.SERVER_ERROR_START) {
      code = ErrorCode.SERVER_ERROR_END - 1; // Default custom error code
    }

    return createErrorResponse(code, message, requestId, details);
  }

  // Validation helper
  validateTradeParams(params) {
    const errors = [];

    if (!params.symbol || typeof params.symbol !== 'string') {
      errors.push({ field: 'symbol', message: 'Required string field' });
    }

    if (!params.side || !['BUY', 'SELL'].includes(params.side)) {
      errors.push({ field: 'side', message: 'Must be BUY or SELL' });
    }

    if (!params.quantity || typeof params.quantity !== 'number' || params.quantity <= 0) {
      errors.push({ field: 'quantity', message: 'Must be positive number' });
    }

    return errors;
  }

  // Process request with error handling
  async processRequest(request) {
    try {
      // Validate request structure
      if (!request.jsonrpc || request.jsonrpc !== '2.0') {
        return this.handleInvalidRequest(request.id, ['jsonrpc']);
      }

      if (!request.method) {
        return this.handleInvalidRequest(request.id, ['method']);
      }

      // Check method exists
      const validMethods = ['execute_trade', 'run_backtest', 'get_portfolio'];
      if (!validMethods.includes(request.method)) {
        return this.handleMethodNotFound(request.method, request.id);
      }

      // Validate parameters
      if (request.method === 'execute_trade') {
        const validationErrors = this.validateTradeParams(request.params || {});
        if (validationErrors.length > 0) {
          return this.handleInvalidParams(request.method, request.id, validationErrors);
        }
      }

      // Process valid request (would call actual implementation)
      // ... processing logic ...

      return null; // No error
    } catch (error) {
      return this.handleInternalError(request.id, error);
    }
  }
}

// Usage example
const errorHandler = new TradingErrorHandler();

// Test various error scenarios
const requests = [
  // Invalid JSON structure
  { invalidData: 'not json' },

  // Missing method
  { jsonrpc: '2.0', id: 'req-001' },

  // Method not found
  { jsonrpc: '2.0', method: 'invalid_method', id: 'req-002' },

  // Invalid parameters
  { jsonrpc: '2.0', method: 'execute_trade', params: { side: 'BUY' }, id: 'req-003' },

  // Valid request
  {
    jsonrpc: '2.0',
    method: 'execute_trade',
    params: { symbol: 'AAPL', side: 'BUY', quantity: 100 },
    id: 'req-004'
  }
];

requests.forEach(async (request) => {
  const error = await errorHandler.processRequest(request);
  if (error) {
    console.log('Error Response:', JSON.stringify(error, null, 2));
  } else {
    console.log('Request valid, processing...');
  }
});

const {
  createRequest,
  createSuccessResponse,
  createErrorResponse,
  ErrorCode
} = require('@neural-trader/mcp-protocol');

class MCPClient {
  constructor() {
    this.pendingRequests = new Map();
    this.requestCounter = 0;
  }

  // Send request and track for response
  async sendRequest(method, params) {
    const id = `client-${Date.now()}-${++this.requestCounter}`;
    const request = createRequest(method, params, id);

    // Create promise that resolves when response received
    return new Promise((resolve, reject) => {
      this.pendingRequests.set(id, { resolve, reject });

      // Send request (in real app, this would be network call)
      this.transport(request);

      // Timeout after 30 seconds
      setTimeout(() => {
        if (this.pendingRequests.has(id)) {
          this.pendingRequests.delete(id);
          reject(new Error('Request timeout'));
        }
      }, 30000);
    });
  }

  // Handle response received
  handleResponse(response) {
    const pending = this.pendingRequests.get(response.id);
    if (!pending) {
      console.warn('Received response for unknown request:', response.id);
      return;
    }

    this.pendingRequests.delete(response.id);

    if (response.error) {
      pending.reject(new Error(response.error.message));
    } else {
      pending.resolve(response.result);
    }
  }

  // Transport layer (placeholder)
  transport(request) {
    // In real implementation, this would send over WebSocket/HTTP
    console.log('Sending request:', request);

    // Simulate response (in real app, response comes from server)
    setTimeout(() => {
      const response = createSuccessResponse(
        { status: 'processed' },
        request.id
      );
      this.handleResponse(response);
    }, 100);
  }
}

class MCPServer {
  constructor() {
    this.methods = new Map();
    this.registerDefaultMethods();
  }

  // Register method handler
  registerMethod(name, handler) {
    this.methods.set(name, handler);
  }

  // Register default trading methods
  registerDefaultMethods() {
    this.registerMethod('execute_trade', async (params) => {
      return {
        orderId: 'order-' + Date.now(),
        status: 'FILLED',
        fillPrice: 175.50
      };
    });

    this.registerMethod('get_portfolio', async (params) => {
      return {
        cash: 50000,
        equity: 125000,
        positions: [
          { symbol: 'AAPL', quantity: 100 }
        ]
      };
    });

    this.registerMethod('list_strategies', async (params) => {
      return {
        strategies: ['momentum-v1', 'mean-reversion-v2']
      };
    });
  }

  // Handle incoming request
  async handleRequest(request) {
    try {
      // Validate request
      if (!request.jsonrpc || request.jsonrpc !== '2.0') {
        return createErrorResponse(
          ErrorCode.INVALID_REQUEST,
          'Invalid JSON-RPC version',
          request.id || null
        );
      }

      // Check if method exists
      if (!this.methods.has(request.method)) {
        return createErrorResponse(
          ErrorCode.METHOD_NOT_FOUND,
          `Method not found: ${request.method}`,
          request.id,
          { availableMethods: Array.from(this.methods.keys()) }
        );
      }

      // Execute method
      const handler = this.methods.get(request.method);
      const result = await handler(request.params || {});

      // Return success response (or null for notifications)
      return request.id ? createSuccessResponse(result, request.id) : null;
    } catch (error) {
      return createErrorResponse(
        ErrorCode.INTERNAL_ERROR,
        error.message,
        request.id || null,
        { error: error.toString() }
      );
    }
  }
}

// Usage example: Complete client-server cycle
async function demonstrateClientServer() {
  const client = new MCPClient();
  const server = new MCPServer();

  // Override client transport to actually call server
  client.transport = async (request) => {
    console.log('Client → Server:', request);

    const response = await server.handleRequest(request);
    if (response) {
      console.log('Server → Client:', response);
      client.handleResponse(response);
    }
  };

  // Execute requests
  try {
    // Request 1: Execute trade
    const tradeResult = await client.sendRequest('execute_trade', {
      symbol: 'AAPL',
      side: 'BUY',
      quantity: 100
    });
    console.log('Trade Result:', tradeResult);

    // Request 2: Get portfolio
    const portfolio = await client.sendRequest('get_portfolio', {});
    console.log('Portfolio:', portfolio);

    // Request 3: List strategies
    const strategies = await client.sendRequest('list_strategies', {});
    console.log('Strategies:', strategies);

    // Request 4: Invalid method (error)
    try {
      await client.sendRequest('invalid_method', {});
    } catch (error) {
      console.log('Expected error:', error.message);
    }
  } catch (error) {
    console.error('Request failed:', error);
  }
}

demonstrateClientServer();

const {
  createRequest,
  createSuccessResponse,
  createErrorResponse,
  ErrorCode
} = require('@neural-trader/mcp-protocol');

class BatchRequestProcessor {
  // Create batch of requests
  createBatch(requests) {
    return requests.map((req, index) =>
      createRequest(req.method, req.params, `batch-${index}`)
    );
  }

  // Process batch of requests
  async processBatch(requests) {
    const responses = [];

    for (const request of requests) {
      try {
        // Process each request
        const result = await this.processRequest(request);
        responses.push(createSuccessResponse(result, request.id));
      } catch (error) {
        responses.push(
          createErrorResponse(
            ErrorCode.INTERNAL_ERROR,
            error.message,
            request.id
          )
        );
      }
    }

    return responses;
  }

  // Single request processor
  async processRequest(request) {
    // Simulate processing
    switch (request.method) {
      case 'get_price':
        return { symbol: request.params.symbol, price: 175.50 };
      case 'get_portfolio':
        return { cash: 50000, equity: 125000 };
      case 'list_strategies':
        return { strategies: ['momentum-v1', 'mean-reversion-v2'] };
      default:
        throw new Error('Method not found');
    }
  }
}

// Usage
async function demonstrateBatchProcessing() {
  const processor = new BatchRequestProcessor();

  // Create batch of requests
  const batch = processor.createBatch([
    { method: 'get_price', params: { symbol: 'AAPL' } },
    { method: 'get_price', params: { symbol: 'NVDA' } },
    { method: 'get_portfolio', params: {} },
    { method: 'list_strategies', params: {} }
  ]);

  console.log('Batch requests:', batch);

  // Process batch
  const responses = await processor.processBatch(batch);
  console.log('Batch responses:', responses);
}

demonstrateBatchProcessing();

const { McpServer } = require('@neural-trader/mcp');
const {
  createRequest,
  createSuccessResponse,
  ErrorCode
} = require('@neural-trader/mcp-protocol');

// MCP server automatically handles protocol
const server = new McpServer({ transport: 'stdio' });

// All requests/responses use mcp-protocol types
await server.start();

const {
  createRequest,
  createSuccessResponse
} = require('@neural-trader/mcp-protocol');
const { BacktestConfig } = require('@neural-trader/core');

// Create backtest request with core types
const backtestConfig = {
  initialCapital: 100000,
  startDate: '2024-01-01',
  endDate: '2024-12-31',
  commission: 0.001,
  slippage: 0.0005,
  useMarkToMarket: true
};

const request = createRequest('run_backtest', backtestConfig, 'backtest-001');

// Response also uses core types
const response = createSuccessResponse(
  {
    metrics: { /* BacktestMetrics */ },
    trades: [ /* Trade[] */ ]
  },
  'backtest-001'
);

const {
  createRequest,
  createSuccessResponse
} = require('@neural-trader/mcp-protocol');

class WebSocketTransport {
  constructor(url) {
    this.ws = new WebSocket(url);
    this.ws.onmessage = (event) => this.handleMessage(event.data);
  }

  send(method, params, id) {
    const request = createRequest(method, params, id);
    this.ws.send(JSON.stringify(request));
  }

  handleMessage(data) {
    const response = JSON.parse(data);
    // Process response...
  }
}