/**
 * Enhanced Autonomous AI Risk Management System with Learning
 * 
 * This system automatically handles risk situations AND learns from every decision.
 * It records decisions, tracks outcomes, and continuously improves its decision-making.
 */

const StopLossDecisionLearner = require('./stop-loss-decision-learner');
const { exec } = require('child_process');
const util = require('util');
const execAsync = util.promisify(exec);

class EnhancedAutonomousRiskManager {
  constructor() {
    this.isActive = false;
    this.learner = new StopLossDecisionLearner();
    this.emergencyThreshold = 1.0; // Will be updated by learning system
    this.riskThreshold = 2.0;
    this.mediumRiskThreshold = 5.0;
    this.pendingDecisions = new Map(); // Track decisions awaiting outcomes
    this.lastAnalysis = null;
  }

  async log(message) {
    const timestamp = new Date().toISOString();
    console.log(`[${timestamp}] 🤖 Enhanced Risk AI: ${message}`);
  }

  /**
   * Main analysis function that integrates learning-based decision making
   */
  async analyzePosition(monitor) {
    try {
      if (!monitor || !monitor.hasPosition) {
        return {
          action: 'NO_ACTION',
          reasoning: 'No position to analyze',
          confidence: 1.0
        };
      }

      const { position, stopLossProximity } = monitor;
      const distance = parseFloat(stopLossProximity.distancePercent);
      
      // Update thresholds based on learning
      await this.updateThresholdsFromLearning();

      // Get AI recommendation based on learned patterns
      const smartRecommendation = await this.learner.getSmartRecommendation({
        distanceFromSL: distance,
        symbol: position.symbol,
        marketConditions: {
          price: position.entryPrice, // Current price context
          unrealizedPnl: position.unrealizedPnl,
          side: position.side
        }
      });

      let decision;

      // Enhanced decision logic using learning
      if (distance < this.emergencyThreshold) {
        decision = await this.handleEmergencyRisk(monitor, smartRecommendation);
      } else if (distance < this.riskThreshold) {
        decision = await this.handleHighRisk(monitor, smartRecommendation);
      } else if (distance < this.mediumRiskThreshold) {
        decision = await this.handleMediumRisk(monitor, smartRecommendation);
      } else {
        decision = await this.handleSafePosition(monitor, smartRecommendation);
      }

      // Record this decision for learning
      const decisionId = await this.recordDecisionForLearning(monitor, decision, smartRecommendation);
      decision.decisionId = decisionId;

      this.lastAnalysis = { monitor, decision, timestamp: new Date() };

      return decision;
    } catch (error) {
      await this.log(`❌ Error in position analysis: ${error.message}`);
      return {
        action: 'ERROR',
        reasoning: `Analysis error: ${error.message}`,
        confidence: 0.1
      };
    }
  }

  async handleEmergencyRisk(monitor, smartRecommendation) {
    const { position, stopLossProximity } = monitor;
    const distance = parseFloat(stopLossProximity.distancePercent);

    await this.log(`🚨 EMERGENCY: Position ${distance}% from stop loss!`);

    // Use learning-based recommendation if highly confident
    if (smartRecommendation.learningBased && smartRecommendation.confidence > 0.8) {
      await this.log(`🧠 Using learned strategy: ${smartRecommendation.suggestedAction} (${(smartRecommendation.confidence * 100).toFixed(1)}% confidence)`);
      
      return {
        action: smartRecommendation.suggestedAction,
        reasoning: `AI Learning: ${smartRecommendation.reasoning}`,
        confidence: smartRecommendation.confidence,
        urgency: 'CRITICAL',
        learningEnhanced: true,
        supportingData: smartRecommendation.supportingData
      };
    }

    // Fallback to rule-based emergency logic
    return {
      action: 'EMERGENCY_EXIT',
      reasoning: 'Price critically close to stop loss. Autonomous exit to preserve capital.',
      confidence: 0.9,
      urgency: 'CRITICAL',
      parameters: {
        exitPercentage: 100,
        maxSlippage: 0.5
      }
    };
  }

  async handleHighRisk(monitor, smartRecommendation) {
    const { position, stopLossProximity } = monitor;
    const distance = parseFloat(stopLossProximity.distancePercent);

    await this.log(`⚠️ HIGH RISK: Position ${distance}% from stop loss`);

    // Check learning recommendation
    if (smartRecommendation.learningBased && smartRecommendation.confidence > 0.7) {
      return {
        action: smartRecommendation.suggestedAction,
        reasoning: `AI Learning: ${smartRecommendation.reasoning}`,
        confidence: smartRecommendation.confidence,
        urgency: 'HIGH',
        learningEnhanced: true
      };
    }

    // Enhanced market analysis for high-risk situations
    const marketAnalysis = await this.analyzeMarketConditions(position.symbol);
    
    if (marketAnalysis.trend === 'BULLISH' && position.side === 'LONG') {
      return {
        action: 'TIGHTEN_STOP_LOSS',
        reasoning: 'Market still favorable. Tightening stop loss for better risk management.',
        confidence: 0.7,
        urgency: 'HIGH',
        parameters: {
          newStopLossDistance: distance * 0.7 // Tighten by 30%
        }
      };
    } else {
      return {
        action: 'PARTIAL_EXIT',
        reasoning: 'Market conditions uncertain. Reducing position size to manage risk.',
        confidence: 0.75,
        urgency: 'HIGH',
        parameters: {
          exitPercentage: 50,
          keepStopLoss: true
        }
      };
    }
  }

  async handleMediumRisk(monitor, smartRecommendation) {
    const { position, stopLossProximity } = monitor;
    const distance = parseFloat(stopLossProximity.distancePercent);

    await this.log(`🟡 MEDIUM RISK: Position ${distance}% from stop loss`);

    // Learning-based decision for medium risk
    if (smartRecommendation.learningBased && smartRecommendation.confidence > 0.6) {
      return {
        action: smartRecommendation.suggestedAction,
        reasoning: `AI Learning: ${smartRecommendation.reasoning}`,
        confidence: smartRecommendation.confidence,
        urgency: 'MEDIUM',
        learningEnhanced: true
      };
    }

    // Default medium risk response
    return {
      action: 'ENHANCED_MONITORING',
      reasoning: 'Increased monitoring frequency. Preparing contingency plans.',
      confidence: 0.6,
      urgency: 'MEDIUM',
      parameters: {
        monitoringInterval: 30, // seconds
        alertThreshold: this.riskThreshold
      }
    };
  }

  async handleSafePosition(monitor, smartRecommendation) {
    const { position } = monitor;

    // Even in safe positions, check for optimization opportunities
    if (smartRecommendation.learningBased && smartRecommendation.confidence > 0.8) {
      if (smartRecommendation.suggestedAction === 'SCALE_POSITION') {
        return {
          action: 'SCALE_POSITION',
          reasoning: `AI Learning: ${smartRecommendation.reasoning}`,
          confidence: smartRecommendation.confidence,
          urgency: 'LOW',
          learningEnhanced: true
        };
      }
    }

    return {
      action: 'MONITOR',
      reasoning: 'Position is safe. Continuing standard monitoring.',
      confidence: 0.8,
      urgency: 'LOW'
    };
  }

  /**
   * Record decision for learning purposes
   */
  async recordDecisionForLearning(monitor, decision, smartRecommendation) {
    try {
      const { position, stopLossProximity } = monitor;
      const distance = parseFloat(stopLossProximity.distancePercent);

      const decisionData = {
        tradeId: position.id || `position_${Date.now()}`,
        symbol: position.symbol,
        decision: decision.action,
        distanceFromSL: distance,
        reasoning: decision.reasoning,
        currentPrice: position.entryPrice,
        confidenceScore: decision.confidence,
        expectedOutcome: this.predictOutcome(decision.action, distance),
        marketConditions: await this.getCurrentMarketConditions(position.symbol),
        learningRecommendation: smartRecommendation
      };

      const decisionId = await this.learner.recordDecision(decisionData);
      
      // Store decision for outcome tracking
      this.pendingDecisions.set(decisionId, {
        ...decisionData,
        timestamp: new Date(),
        monitor: monitor
      });

      await this.log(`📝 Recorded decision ${decisionId} for learning: ${decision.action}`);
      
      return decisionId;
    } catch (error) {
      await this.log(`❌ Error recording decision for learning: ${error.message}`);
      return null;
    }
  }

  /**
   * Assess outcomes of previous decisions
   */
  async assessDecisionOutcomes() {
    try {
      for (const [decisionId, decisionData] of this.pendingDecisions.entries()) {
        const timeSinceDecision = Date.now() - decisionData.timestamp.getTime();
        
        // Assess after sufficient time has passed (5 minutes minimum)
        if (timeSinceDecision > 5 * 60 * 1000) {
          const outcome = await this.determineDecisionOutcome(decisionData);
          
          if (outcome) {
            await this.learner.assessDecisionOutcome({
              decisionId,
              actualOutcome: outcome.result,
              timeToOutcome: Math.floor(timeSinceDecision / 60000), // minutes
              pnlImpact: outcome.pnlImpact,
              additionalContext: outcome.context
            });

            // Remove from pending decisions
            this.pendingDecisions.delete(decisionId);
            await this.log(`✅ Assessed outcome for decision ${decisionId}: ${outcome.result}`);
          }
        }
      }
    } catch (error) {
      await this.log(`❌ Error assessing decision outcomes: ${error.message}`);
    }
  }

  async determineDecisionOutcome(decisionData) {
    try {
      // Get current position status
      const currentStatus = await this.getCurrentPositionStatus(decisionData.symbol);
      
      if (!currentStatus) {
        return {
          result: 'POSITION_CLOSED',
          pnlImpact: 0,
          context: { reason: 'Position no longer exists' }
        };
      }

      // Compare current situation with when decision was made
      const originalDistance = decisionData.distanceFromSL;
      const currentDistance = currentStatus.distanceFromSL;
      const pnlChange = currentStatus.unrealizedPnl - (decisionData.monitor.position?.unrealizedPnl || 0);

      // Determine if decision was beneficial
      if (decisionData.decision === 'EMERGENCY_EXIT' && currentDistance < 0.5) {
        return {
          result: 'AVOIDED_MAJOR_LOSS',
          pnlImpact: Math.abs(pnlChange), // Positive impact
          context: { originalDistance, currentDistance }
        };
      }

      if (decisionData.decision === 'TIGHTEN_STOP_LOSS' && pnlChange > 0) {
        return {
          result: 'IMPROVED_PROFIT',
          pnlImpact: pnlChange,
          context: { originalDistance, currentDistance }
        };
      }

      if (decisionData.decision === 'HOLD' && currentDistance > originalDistance) {
        return {
          result: 'CORRECT_HOLD',
          pnlImpact: pnlChange,
          context: { distanceImproved: currentDistance - originalDistance }
        };
      }

      // Default assessment
      return {
        result: pnlChange >= 0 ? 'NEUTRAL_POSITIVE' : 'NEUTRAL_NEGATIVE',
        pnlImpact: pnlChange,
        context: { originalDistance, currentDistance }
      };
    } catch (error) {
      await this.log(`❌ Error determining decision outcome: ${error.message}`);
      return null;
    }
  }

  async getCurrentPositionStatus(symbol) {
    try {
      const { stdout } = await execAsync('curl -s http://localhost:9001/api/automation/position-monitor');
      const data = JSON.parse(stdout);
      
      if (data.success && data.monitor?.hasPosition) {
        return {
          distanceFromSL: parseFloat(data.monitor.stopLossProximity?.distancePercent || 0),
          unrealizedPnl: data.monitor.position?.unrealizedPnl || 0
        };
      }
      
      return null;
    } catch (error) {
      return null;
    }
  }

  async updateThresholdsFromLearning() {
    try {
      // Get learned optimal thresholds
      const patterns = await this.learner.analyzeDecisionPatterns();
      
      if (patterns?.distanceOptimization) {
        const optimization = patterns.distanceOptimization;
        
        if (optimization.emergencyRange?.optimalThreshold) {
          this.emergencyThreshold = optimization.emergencyRange.optimalThreshold;
        }
        if (optimization.highRiskRange?.optimalThreshold) {
          this.riskThreshold = optimization.highRiskRange.optimalThreshold;
        }
        if (optimization.mediumRiskRange?.optimalThreshold) {
          this.mediumRiskThreshold = optimization.mediumRiskRange.optimalThreshold;
        }

        await this.log(`🔄 Updated thresholds from learning: Emergency=${this.emergencyThreshold.toFixed(2)}%, Risk=${this.riskThreshold.toFixed(2)}%, Medium=${this.mediumRiskThreshold.toFixed(2)}%`);
      }
    } catch (error) {
      await this.log(`❌ Error updating thresholds from learning: ${error.message}`);
    }
  }

  predictOutcome(action, distance) {
    // Predict what we expect to happen based on the action
    const predictions = {
      'EMERGENCY_EXIT': 'AVOID_MAJOR_LOSS',
      'PARTIAL_EXIT': 'REDUCE_RISK',
      'TIGHTEN_STOP_LOSS': 'BETTER_RISK_REWARD',
      'SCALE_POSITION': 'INCREASED_PROFIT',
      'HOLD': 'MAINTAIN_POSITION',
      'ENHANCED_MONITORING': 'EARLY_WARNING'
    };

    return predictions[action] || 'UNKNOWN_OUTCOME';
  }

  async analyzeMarketConditions(symbol) {
    // Enhanced market analysis for better decision making
    try {
      const { stdout } = await execAsync('curl -s http://localhost:9001/api/automation/position-monitor');
      const data = JSON.parse(stdout);
      
      if (data.success && data.monitor?.position) {
        const pnl = data.monitor.position.unrealizedPnl;
        const trend = pnl > 0 ? 'BULLISH' : pnl < -1 ? 'BEARISH' : 'SIDEWAYS';
        
        return {
          trend,
          strength: Math.abs(pnl),
          timeOfDay: new Date().getHours(),
          volatility: Math.random() * 0.1 // Mock volatility
        };
      }
    } catch (error) {
      // Fallback analysis
    }
    
    return {
      trend: 'UNKNOWN',
      strength: 0,
      timeOfDay: new Date().getHours(),
      volatility: 0.05
    };
  }

  async getCurrentMarketConditions(symbol) {
    const conditions = await this.analyzeMarketConditions(symbol);
    return {
      ...conditions,
      dayOfWeek: new Date().getDay(),
      timestamp: new Date().toISOString()
    };
  }

  /**
   * Enhanced Beach Mode with learning integration
   */
  async beachMode() {
    await this.log('🏖️ ENHANCED BEACH MODE: Autonomous operation with AI learning');
    this.isActive = true;

    // Main monitoring loop
    const monitoringLoop = async () => {
      if (!this.isActive) return;

      try {
        // Check current positions
        const { stdout } = await execAsync('curl -s http://localhost:9001/api/automation/position-monitor');
        const data = JSON.parse(stdout);

        if (data.success) {
          const decision = await this.analyzePosition(data.monitor);
          await this.executeDecision(decision);
        }

        // Assess outcomes of previous decisions
        await this.assessDecisionOutcomes();

      } catch (error) {
        await this.log(`Error in beach mode cycle: ${error.message}`);
      }

      // Schedule next check
      if (this.isActive) {
        setTimeout(monitoringLoop, 60000); // Check every minute
      }
    };

    // Start monitoring
    monitoringLoop();

    // Generate learning reports periodically
    setInterval(async () => {
      if (this.isActive) {
        const report = await this.learner.generateLearningReport();
        if (report) {
          await this.log(`📊 Learning Update: ${report.summary.totalDecisions} decisions, ${(report.summary.systemConfidence * 100).toFixed(1)}% confidence`);
        }
      }
    }, 15 * 60 * 1000); // Every 15 minutes
  }

  async executeDecision(decision) {
    await this.log(`🎯 Executing decision: ${decision.action} - ${decision.reasoning} (Confidence: ${(decision.confidence * 100).toFixed(1)}%)`);
    
    // Add learning enhancement indicators
    if (decision.learningEnhanced) {
      await this.log(`🧠 Decision enhanced by AI learning system`);
    }

    // Implementation would depend on your trading API
    switch (decision.action) {
      case 'EMERGENCY_EXIT':
        await this.log('🚨 Implementing emergency exit protocol');
        break;
      case 'PARTIAL_EXIT':
        await this.log('📉 Executing partial position closure');
        break;
      case 'TIGHTEN_STOP_LOSS':
        await this.log('🎯 Adjusting stop loss parameters');
        break;
      case 'SCALE_POSITION':
        await this.log('📈 Scaling position size');
        break;
      case 'ENHANCED_MONITORING':
        await this.log('👁️ Activating enhanced monitoring');
        break;
      default:
        await this.log(`ℹ️ Monitoring: ${decision.reasoning}`);
    }
  }

  stop() {
    this.isActive = false;
    this.log('🛑 Enhanced autonomous risk management stopped');
  }

  /**
   * Get learning system status and insights
   */
  async getLearningStatus() {
    try {
      const report = await this.learner.generateLearningReport();
      return {
        isLearning: true,
        totalDecisions: this.pendingDecisions.size + (report?.summary?.totalDecisions || 0),
        systemConfidence: report?.summary?.systemConfidence || 0.3,
        currentThresholds: {
          emergency: this.emergencyThreshold,
          risk: this.riskThreshold,
          mediumRisk: this.mediumRiskThreshold
        },
        pendingAssessments: this.pendingDecisions.size,
        lastAnalysis: this.lastAnalysis,
        insights: report?.insights
      };
    } catch (error) {
      return {
        isLearning: false,
        error: error.message
      };
    }
  }
}

// Export for use in other modules
module.exports = EnhancedAutonomousRiskManager;

// Direct execution for testing
if (require.main === module) {
  const riskManager = new EnhancedAutonomousRiskManager();
  
  console.log('🤖 Enhanced Autonomous Risk Manager with AI Learning');
  console.log('🧠 Now learning from every decision to become smarter!');
  console.log('🏖️ Perfect for beach mode - gets better while you relax!');
  
  riskManager.beachMode();
  
  process.on('SIGINT', () => {
    riskManager.stop();
    process.exit(0);
  });
}