/**
 * Position-Aware Smart Automation
 * 
 * This addresses the user concerns:
 * 1. Clear visibility of what's happening
 * 2. Specific stop loss monitoring
 * 3. Transparent decision making
 * 4. No black box behavior
 */

// Enhanced simple automation with position awareness
class PositionAwareAutomation {
  constructor() {
    this.isRunning = false;
    this.config = null;
    this.intervalId = null;
    this.positionCheckInterval = null;
    this.stats = {
      totalCycles: 0,
      totalTrades: 0,
      startTime: null,
      lastActivity: null,
      status: 'Stopped',
      networkErrors: 0,
      consecutiveErrors: 0,
      lastPositionCheck: null,
      positionMonitoringActive: false
    };
  }

  async start(config) {
    try {
      if (this.isRunning) {
        return { success: false, message: 'Automation already running' };
      }

      this.config = config;
      this.isRunning = true;
      this.stats.startTime = new Date().toISOString();
      this.stats.status = 'Running';
      
      console.log('🚀 POSITION-AWARE AUTOMATION STARTING...');
      console.log('✅ AUTOMATION STATUS: isRunning =', this.isRunning);
      
      // Check for existing positions first
      const positionMonitor = await this.checkPositions();
      
      if (positionMonitor.hasPosition) {
        console.log('📊 EXISTING POSITION DETECTED:', positionMonitor.position.symbol, positionMonitor.position.side);
        console.log('🎯 RISK LEVEL:', positionMonitor.riskLevel);
        console.log('📍 NEXT ACTION:', positionMonitor.nextAction);
        
        // Start position monitoring
        await this.startPositionMonitoring(positionMonitor);
      } else {
        console.log('💰 NO POSITIONS - Starting opportunity scanning...');
        
        // Start opportunity scanning
        await this.startOpportunityScanning();
      }

      return { 
        success: true, 
        message: 'Position-aware automation started',
        hasPosition: positionMonitor.hasPosition,
        positionDetails: positionMonitor.position,
        riskLevel: positionMonitor.riskLevel,
        nextAction: positionMonitor.nextAction
      };

    } catch (error) {
      console.error('Failed to start position-aware automation:', error);
      return { success: false, message: 'Failed to start automation: ' + error.message };
    }
  }

  async checkPositions() {
    try {
      const baseUrl = process.env.INTERNAL_API_URL || 'http://localhost:3000';
      const response = await fetch(`${baseUrl}/api/automation/position-monitor`);
      const data = await response.json();
      
      if (data.success) {
        this.stats.lastPositionCheck = new Date().toISOString();
        return data.monitor;
      } else {
        throw new Error('Failed to get position data');
      }
    } catch (error) {
      console.error('❌ Position check failed:', error);
      return {
        hasPosition: false,
        position: null,
        riskLevel: 'UNKNOWN',
        nextAction: 'Retry position check',
        recommendation: 'ERROR'
      };
    }
  }

  async startPositionMonitoring(positionData) {
    console.log('🛡️ STARTING POSITION MONITORING MODE');
    console.log(`⏰ Risk Level: ${positionData.riskLevel}`);
    
    this.stats.positionMonitoringActive = true;
    
    // Set monitoring frequency based on risk
    let checkInterval;
    switch (positionData.riskLevel) {
      case 'CRITICAL':
        checkInterval = 30 * 1000; // 30 seconds
        break;
      case 'HIGH':
        checkInterval = 2 * 60 * 1000; // 2 minutes
        break;
      case 'MEDIUM':
        checkInterval = 5 * 60 * 1000; // 5 minutes
        break;
      default:
        checkInterval = 10 * 60 * 1000; // 10 minutes
    }
    
    console.log(`⏰ Position monitoring every ${checkInterval/1000} seconds`);
    
    // Start position monitoring loop
    this.positionCheckInterval = setInterval(async () => {
      await this.runPositionCheck();
    }, checkInterval);
    
    // Run first check immediately
    setTimeout(() => this.runPositionCheck(), 5000);
  }

  async startOpportunityScanning() {
    console.log('🔍 STARTING OPPORTUNITY SCANNING MODE');
    console.log('⏰ Scanning for entries every 10 minutes');
    
    this.stats.positionMonitoringActive = false;
    
    // Start opportunity scanning (less frequent when no position)
    this.intervalId = setInterval(async () => {
      await this.runOpportunityCheck();
    }, 10 * 60 * 1000); // 10 minutes
    
    // Run first check after 30 seconds
    setTimeout(() => this.runOpportunityCheck(), 30000);
  }

  async runPositionCheck() {
    try {
      if (!this.isRunning) {
        console.log('⏹️ POSITION CHECK STOPPED: Automation not running');
        return;
      }
      
      console.log('🔍 POSITION CHECK: Monitoring stop loss proximity...');
      
      const positionData = await this.checkPositions();
      
      if (!positionData.hasPosition) {
        console.log('📤 POSITION CLOSED: Switching to opportunity scanning...');
        
        // Clear position monitoring
        if (this.positionCheckInterval) {
          clearInterval(this.positionCheckInterval);
          this.positionCheckInterval = null;
        }
        
        // Start opportunity scanning
        await this.startOpportunityScanning();
        return;
      }
      
      console.log(`📊 Position Status: ${positionData.position.symbol} ${positionData.position.side}`);
      console.log(`⚠️ Risk Level: ${positionData.riskLevel}`);
      console.log(`📍 Distance to SL: ${positionData.stopLossProximity?.distancePercent}%`);
      
      // Take action based on proximity
      if (positionData.riskLevel === 'CRITICAL' || positionData.riskLevel === 'HIGH') {
        console.log('🚨 RUNNING EMERGENCY ANALYSIS...');
        await this.runEmergencyAnalysis(positionData);
      }
      
      this.stats.totalCycles++;
      this.stats.lastActivity = new Date().toISOString();
      
    } catch (error) {
      console.error('❌ Position check error:', error);
      this.stats.consecutiveErrors++;
    }
  }

  async runOpportunityCheck() {
    try {
      if (!this.isRunning) {
        console.log('⏹️ OPPORTUNITY CHECK STOPPED: Automation not running');
        return;
      }
      
      console.log('💰 OPPORTUNITY CHECK: Scanning for entry signals...');
      
      // Check if position was opened while we were scanning
      const positionData = await this.checkPositions();
      
      if (positionData.hasPosition) {
        console.log('📈 NEW POSITION DETECTED: Switching to position monitoring...');
        
        // Clear opportunity scanning
        if (this.intervalId) {
          clearInterval(this.intervalId);
          this.intervalId = null;
        }
        
        // Start position monitoring
        await this.startPositionMonitoring(positionData);
        return;
      }
      
      // Run normal analysis for entry opportunities
      console.log('🔄 Running entry analysis...');
      // TODO: Add your normal analysis logic here
      
      this.stats.totalCycles++;
      this.stats.lastActivity = new Date().toISOString();
      
    } catch (error) {
      console.error('❌ Opportunity check error:', error);
      this.stats.consecutiveErrors++;
    }
  }

  async runEmergencyAnalysis(positionData) {
    console.log('🚨 EMERGENCY ANALYSIS: Price approaching stop loss!');
    console.log(`📊 Position: ${positionData.position.side} ${positionData.position.size} at $${positionData.position.entryPrice}`);
    console.log(`💰 Current PnL: $${positionData.position.unrealizedPnl}`);
    console.log(`🎯 Distance to SL: ${positionData.stopLossProximity.distancePercent}%`);
    
    // Here you would run your analysis to decide:
    // 1. Close position early
    // 2. Move stop loss
    // 3. Double down
    // 4. Do nothing
    
    console.log('🤖 ANALYSIS DECISION: [Would run AI analysis here]');
    console.log('⏰ Next check in 30 seconds due to high risk');
  }

  async stop() {
    try {
      console.log('🛑 STOPPING POSITION-AWARE AUTOMATION...');
      this.isRunning = false;
      this.stats.status = 'Stopped';
      this.stats.positionMonitoringActive = false;
      console.log('✅ AUTOMATION STATUS: isRunning =', this.isRunning);

      if (this.intervalId) {
        clearInterval(this.intervalId);
        this.intervalId = null;
        console.log('⏹️ Opportunity scanning stopped');
      }

      if (this.positionCheckInterval) {
        clearInterval(this.positionCheckInterval);
        this.positionCheckInterval = null;
        console.log('⏹️ Position monitoring stopped');
      }

      return { success: true, message: 'Position-aware automation stopped successfully' };
    } catch (error) {
      console.error('Failed to stop position-aware automation:', error);
      return { success: false, message: 'Failed to stop automation: ' + error.message };
    }
  }

  getStatus() {
    const baseStatus = {
      isActive: this.isRunning,
      mode: this.config?.mode || 'SIMULATION',
      enableTrading: this.config?.enableTrading || false,
      tradingStatus: this.config?.enableTrading ? 'REAL TRADES' : 'SIMULATED ONLY',
      symbol: this.config?.symbol || 'SOLUSD',
      timeframes: this.config?.selectedTimeframes || [],
      automationType: 'POSITION_AWARE',
      ...this.stats
    };
    
    // Add descriptive status based on current mode
    if (this.isRunning) {
      if (this.stats.positionMonitoringActive) {
        baseStatus.detailedStatus = 'Monitoring active position for stop loss proximity';
        baseStatus.nextAction = 'Position risk assessment and monitoring';
      } else {
        baseStatus.detailedStatus = 'Scanning for trading opportunities';
        baseStatus.nextAction = 'Entry signal analysis';
      }
    } else {
      baseStatus.detailedStatus = 'Stopped - No monitoring active';
      baseStatus.nextAction = 'Start automation to begin monitoring';
    }
    
    return baseStatus;
  }
}

// Export singleton instance
const positionAwareAutomation = new PositionAwareAutomation();
export { positionAwareAutomation };