#!/usr/bin/env node

/**
 * Global Market Sentiment Analysis System
 * Integrates Fear & Greed Index and other macro indicators
 */

const { exec } = require('child_process');
const { promisify } = require('util');
const execAsync = promisify(exec);

class GlobalMarketSentiment {
  constructor() {
    this.sentimentSources = {
      // Crypto Fear & Greed Index
      cryptoFearGreed: 'https://api.alternative.me/fng/',
      
      // Traditional Market Indicators
      vix: 'VIX',  // Volatility Index
      dxy: 'DXY',  // Dollar Index
      
      // Alternative Data Sources
      bitcoinDominance: 'BTC.D',
      goldPrice: 'GOLD',
      bondYields: 'TNX', // 10-year Treasury
      
      // Social Sentiment (if available)
      redditSentiment: null,
      twitterSentiment: null
    };
    
    this.marketRegimes = {
      EXTREME_FEAR: { min: 0, max: 25, description: 'Maximum fear - potential buying opportunity' },
      FEAR: { min: 25, max: 45, description: 'Fear dominant - cautious optimism' },
      NEUTRAL: { min: 45, max: 55, description: 'Balanced sentiment' },
      GREED: { min: 55, max: 75, description: 'Greed emerging - caution advised' },
      EXTREME_GREED: { min: 75, max: 100, description: 'Maximum greed - potential selling opportunity' }
    };
  }

  async getCryptoFearGreedIndex() {
    try {
      const { stdout } = await execAsync('curl -s "https://api.alternative.me/fng/"');
      const data = JSON.parse(stdout);
      
      if (data.data && data.data[0]) {
        const fng = data.data[0];
        return {
          value: parseInt(fng.value),
          classification: fng.value_classification,
          timestamp: fng.timestamp,
          regime: this.classifyMarketRegime(parseInt(fng.value)),
          tradingImplication: this.getFearGreedTradingSignal(parseInt(fng.value))
        };
      }
      return null;
    } catch (error) {
      console.log('❌ Fear & Greed Index unavailable:', error.message);
      return null;
    }
  }

  classifyMarketRegime(fearGreedValue) {
    for (const [regime, range] of Object.entries(this.marketRegimes)) {
      if (fearGreedValue >= range.min && fearGreedValue <= range.max) {
        return {
          regime,
          description: range.description,
          value: fearGreedValue
        };
      }
    }
    return { regime: 'UNKNOWN', description: 'Unable to classify', value: fearGreedValue };
  }

  getFearGreedTradingSignal(fearGreedValue) {
    if (fearGreedValue <= 25) {
      return {
        signal: 'BUY_OPPORTUNITY',
        confidence: 85,
        reasoning: 'Extreme fear often marks market bottoms - contrarian buying opportunity',
        positionSizing: 'Aggressive',
        timeframe: 'Medium to long-term'
      };
    } else if (fearGreedValue <= 45) {
      return {
        signal: 'CAUTIOUS_BUY',
        confidence: 65,
        reasoning: 'Fear still dominant but reducing - gradual accumulation',
        positionSizing: 'Conservative',
        timeframe: 'Medium-term'
      };
    } else if (fearGreedValue <= 55) {
      return {
        signal: 'NEUTRAL',
        confidence: 50,
        reasoning: 'Balanced sentiment - technical analysis primary',
        positionSizing: 'Normal',
        timeframe: 'Short to medium-term'
      };
    } else if (fearGreedValue <= 75) {
      return {
        signal: 'CAUTIOUS_SELL',
        confidence: 65,
        reasoning: 'Greed emerging - consider profit taking',
        positionSizing: 'Reduced',
        timeframe: 'Short to medium-term'
      };
    } else {
      return {
        signal: 'SELL_OPPORTUNITY',
        confidence: 85,
        reasoning: 'Extreme greed often marks market tops - contrarian selling opportunity',
        positionSizing: 'Defensive',
        timeframe: 'Short-term'
      };
    }
  }

  async getGlobalMarketMetrics() {
    const metrics = {
      cryptoFearGreed: await this.getCryptoFearGreedIndex(),
      traditionalMarkets: await this.getTraditionalMarketMetrics(),
      macroIndicators: await this.getMacroIndicators(),
      marketCorrelations: await this.getMarketCorrelations()
    };

    return {
      ...metrics,
      overallSentiment: this.calculateOverallSentiment(metrics),
      tradingRecommendations: this.generateTradingRecommendations(metrics),
      riskAssessment: this.assessGlobalRisk(metrics)
    };
  }

  async getTraditionalMarketMetrics() {
    // Mock implementation - in production, use real APIs
    return {
      vix: { value: 18.5, interpretation: 'Low volatility - complacency risk' },
      dxy: { value: 103.2, interpretation: 'Strong dollar - crypto headwind' },
      spx: { value: 4350, change: '+0.8%', interpretation: 'Risk-on sentiment' },
      bonds: { yield: 4.2, interpretation: 'Rising yields - risk asset pressure' }
    };
  }

  async getMacroIndicators() {
    return {
      bitcoinDominance: { value: 52.3, interpretation: 'BTC strength vs altcoins' },
      goldRatio: { value: 28.5, interpretation: 'Crypto vs traditional safe haven' },
      correlations: {
        btcSpx: 0.65,
        btcGold: -0.23,
        btcDxy: -0.78
      }
    };
  }

  async getMarketCorrelations() {
    // Calculate asset correlations for risk assessment
    return {
      cryptoEquity: 0.72, // High correlation = higher systemic risk
      cryptoBonds: -0.45,
      cryptoCommodities: 0.31,
      riskOnOff: 'RISK_ON' // Current market regime
    };
  }

  calculateOverallSentiment(metrics) {
    let sentimentScore = 50; // Neutral baseline
    let confidence = 0;
    const factors = [];

    // Fear & Greed Index (40% weight)
    if (metrics.cryptoFearGreed) {
      const fngWeight = 0.4;
      const fngContribution = metrics.cryptoFearGreed.value * fngWeight;
      sentimentScore += (fngContribution - 50 * fngWeight);
      confidence += 40;
      factors.push(`Fear & Greed: ${metrics.cryptoFearGreed.value} (${metrics.cryptoFearGreed.classification})`);
    }

    // Traditional markets (30% weight)
    if (metrics.traditionalMarkets) {
      const vixScore = Math.max(0, Math.min(100, 100 - metrics.traditionalMarkets.vix.value * 3));
      const tradWeight = 0.3;
      sentimentScore += (vixScore - 50) * tradWeight;
      confidence += 30;
      factors.push(`VIX: ${metrics.traditionalMarkets.vix.value} (${vixScore.toFixed(0)} sentiment)`);
    }

    // Macro indicators (30% weight)
    if (metrics.macroIndicators) {
      const btcDomScore = metrics.macroIndicators.bitcoinDominance.value > 50 ? 60 : 40;
      const macroWeight = 0.3;
      sentimentScore += (btcDomScore - 50) * macroWeight;
      confidence += 30;
      factors.push(`BTC Dominance: ${metrics.macroIndicators.bitcoinDominance.value}%`);
    }

    const finalSentiment = Math.max(0, Math.min(100, sentimentScore));
    const regime = this.classifyMarketRegime(finalSentiment);

    return {
      score: Math.round(finalSentiment),
      regime: regime.regime,
      confidence: Math.round(confidence),
      description: regime.description,
      factors,
      interpretation: this.interpretSentimentScore(finalSentiment)
    };
  }

  interpretSentimentScore(score) {
    if (score <= 25) return 'EXTREMELY_BEARISH';
    if (score <= 40) return 'BEARISH';
    if (score <= 60) return 'NEUTRAL';
    if (score <= 75) return 'BULLISH';
    return 'EXTREMELY_BULLISH';
  }

  generateTradingRecommendations(metrics) {
    const sentiment = this.calculateOverallSentiment(metrics);
    const recommendations = [];

    // Base recommendation from overall sentiment
    if (sentiment.score <= 25) {
      recommendations.push({
        action: 'AGGRESSIVE_BUY',
        confidence: 85,
        reasoning: 'Extreme fear presents strong contrarian opportunity',
        positionSize: 'Large',
        timeHorizon: 'Medium to Long-term',
        assets: ['BTC', 'ETH', 'SOL'],
        strategy: 'Dollar Cost Average on extreme dips'
      });
    } else if (sentiment.score <= 45) {
      recommendations.push({
        action: 'CAUTIOUS_BUY',
        confidence: 65,
        reasoning: 'Fear dominant but markets may have further to fall',
        positionSize: 'Moderate',
        timeHorizon: 'Medium-term',
        assets: ['BTC', 'ETH'],
        strategy: 'Gradual accumulation with tight risk management'
      });
    } else if (sentiment.score >= 75) {
      recommendations.push({
        action: 'PROFIT_TAKING',
        confidence: 80,
        reasoning: 'Extreme greed suggests potential market top',
        positionSize: 'Reduce',
        timeHorizon: 'Short-term',
        assets: ['Altcoins', 'High Beta'],
        strategy: 'Take profits on extended positions'
      });
    }

    // Add specific recommendations based on Fear & Greed
    if (metrics.cryptoFearGreed) {
      const fngSignal = this.getFearGreedTradingSignal(metrics.cryptoFearGreed.value);
      recommendations.push({
        action: fngSignal.signal,
        confidence: fngSignal.confidence,
        reasoning: fngSignal.reasoning,
        positionSize: fngSignal.positionSizing,
        timeHorizon: fngSignal.timeframe,
        source: 'Crypto Fear & Greed Index'
      });
    }

    return recommendations;
  }

  assessGlobalRisk(metrics) {
    let riskScore = 50; // Neutral baseline
    const riskFactors = [];

    // High correlations increase systemic risk
    if (metrics.marketCorrelations?.cryptoEquity > 0.7) {
      riskScore += 15;
      riskFactors.push('High crypto-equity correlation increases systemic risk');
    }

    // VIX assessment
    if (metrics.traditionalMarkets?.vix?.value < 15) {
      riskScore += 10;
      riskFactors.push('Low VIX suggests complacency - volatility spike risk');
    } else if (metrics.traditionalMarkets?.vix?.value > 30) {
      riskScore += 20;
      riskFactors.push('High VIX indicates elevated market stress');
    }

    // Dollar strength
    if (metrics.traditionalMarkets?.dxy?.value > 105) {
      riskScore += 10;
      riskFactors.push('Strong dollar creates headwinds for risk assets');
    }

    return {
      score: Math.min(100, riskScore),
      level: riskScore <= 40 ? 'LOW' : riskScore <= 70 ? 'MODERATE' : 'HIGH',
      factors: riskFactors,
      recommendations: this.getRiskMitigationRecommendations(riskScore)
    };
  }

  getRiskMitigationRecommendations(riskScore) {
    if (riskScore <= 40) {
      return ['Normal position sizing acceptable', 'Consider increasing exposure to quality assets'];
    } else if (riskScore <= 70) {
      return ['Reduce position sizes', 'Maintain tighter stop losses', 'Focus on high-conviction trades'];
    } else {
      return ['Significantly reduce exposure', 'Consider cash/stablecoin allocation', 'Wait for better risk/reward setup'];
    }
  }

  async generateMarketReport() {
    console.log('📊 GLOBAL MARKET SENTIMENT ANALYSIS\n');
    
    try {
      const metrics = await this.getGlobalMarketMetrics();
      
      // Overall Sentiment
      console.log('🌍 OVERALL MARKET SENTIMENT:');
      console.log(`   Score: ${metrics.overallSentiment.score}/100 (${metrics.overallSentiment.regime})`);
      console.log(`   Interpretation: ${metrics.overallSentiment.interpretation}`);
      console.log(`   Confidence: ${metrics.overallSentiment.confidence}%`);
      console.log(`   Description: ${metrics.overallSentiment.description}\n`);
      
      // Fear & Greed Index
      if (metrics.cryptoFearGreed) {
        console.log('😱 CRYPTO FEAR & GREED INDEX:');
        console.log(`   Value: ${metrics.cryptoFearGreed.value}/100 (${metrics.cryptoFearGreed.classification})`);
        console.log(`   Regime: ${metrics.cryptoFearGreed.regime.regime}`);
        console.log(`   Trading Signal: ${metrics.cryptoFearGreed.tradingImplication.signal}`);
        console.log(`   Confidence: ${metrics.cryptoFearGreed.tradingImplication.confidence}%`);
        console.log(`   Reasoning: ${metrics.cryptoFearGreed.tradingImplication.reasoning}\n`);
      }
      
      // Trading Recommendations
      console.log('🎯 TRADING RECOMMENDATIONS:');
      metrics.tradingRecommendations.forEach((rec, index) => {
        console.log(`   ${index + 1}. ${rec.action} (${rec.confidence}% confidence)`);
        console.log(`      Reasoning: ${rec.reasoning}`);
        console.log(`      Position Size: ${rec.positionSize}`);
        console.log(`      Time Horizon: ${rec.timeHorizon}`);
        if (rec.assets) console.log(`      Assets: ${rec.assets.join(', ')}`);
        console.log('');
      });
      
      // Risk Assessment
      console.log('⚠️ GLOBAL RISK ASSESSMENT:');
      console.log(`   Risk Level: ${metrics.riskAssessment.level} (${metrics.riskAssessment.score}/100)`);
      console.log('   Risk Factors:');
      metrics.riskAssessment.factors.forEach(factor => {
        console.log(`     • ${factor}`);
      });
      console.log('   Risk Mitigation:');
      metrics.riskAssessment.recommendations.forEach(rec => {
        console.log(`     • ${rec}`);
      });
      
      return metrics;
      
    } catch (error) {
      console.error('❌ Error generating market report:', error.message);
      return null;
    }
  }
}

// CLI interface
if (require.main === module) {
  const sentiment = new GlobalMarketSentiment();
  sentiment.generateMarketReport();
}

// Export for use in automation system
module.exports = { GlobalMarketSentiment };