xXx

Hexid M1n1 5h3ll MobiLe

home/zoocado/public_html/other2.zoocado.com/backup/_[ Writable ]

File:/home/zoocado/public_html/other2.zoocado.com/backup/ema5989.php

<?php
ini_set('display_errors', 1);
error_reporting(E_ALL);
ini_set('output_buffering', 4096); // Enable output buffering
ini_set('implicit_flush', true);

require 'vendor/autoload.php';
require 'KiteConnect.php';
use KiteConnect\KiteConnect;

// Database connection
$conn = new mysqli('p:localhost','zoocado_other','other!@#$1234','zoocado_other1');
if ($conn->connect_error) die("DB connection failed");

// Get access token
$token = $conn->query("SELECT token_number FROM share_token LIMIT 1");
if (!$token || $token->num_rows === 0) die("No access token");
$accessToken = $token->fetch_assoc()['token_number'];

// Initialize KiteConnect
$kite = new KiteConnect('zwxrcar7qia8af5y');
$kite->setAccessToken($accessToken);

// Configuration
$config = [
    'sleep_interval' => 2, // Check every 2 seconds
    'test_mode' => true,   // Set to true for testing without real orders
    'flush_interval' => 10  // Flush output every 10 cycles to manage memory
];

date_default_timezone_set('Asia/Kolkata');

// INDICES ENABLED CONFIGURATION
$indicesEnabled = [
    "NIFTY"     => true,
    "BANKNIFTY" => true, 
    "MIDCAP"=> true,
    "SENSEX"    => true,
    "FINNIFTY"  => false
];

// ----------------- MAPPINGS -----------------
$lotSizes = [
    "NIFTY"      => 65,
    "BANKNIFTY"  => 30,
    "MIDCPNIFTY" => 120,
    "SENSEX"     => 20,
    "FINNIFTY"   => 65
];

$spotTokenMap = [
    "NIFTY"     => 256265,
    "BANKNIFTY" => 260105,
    "SENSEX"    => 265,
    "MIDCAP"    => 288009,
    "FINNIFTY"  => 257801
];

$stepMap = [
    "NIFTY"     => 50,
    "BANKNIFTY" => 100,
    "SENSEX"    => 100,
    "MIDCAP"    => 50,
    "FINNIFTY"  => 50
];

$exchangeMap = [
    "SENSEX"    => "BFO",
    "NIFTY"     => "NFO",
    "BANKNIFTY" => "NFO",
    "MIDCAP"    => "NFO",
    "FINNIFTY"  => "NFO"
];

$instTableMap = [
    "NIFTY"     => "niftyce1",
    "BANKNIFTY" => "bankniftyce1",
    "SENSEX"    => "midcapce1",
    "MIDCAP"    => "midcapce12",
    "FINNIFTY"  => "finniftyce1"
];

$expiryTableMap = [
    "NIFTY"     => "niftyinfo",
    "BANKNIFTY" => "bankinfo",
    "SENSEX"    => "seninfo",
    "MIDCAP"    => "midinfo",
    "FINNIFTY"  => "fininfo"
];

// Indices configuration
$indices = [
    ["name" => "NIFTY", "instrument_id" => "256265"],
    ["name" => "BANKNIFTY", "instrument_id" => "260105"],
    ["name" => "SENSEX", "instrument_id" => "265"],
    ["name" => "MIDCAP", "instrument_id" => "288009"],
    ["name" => "FINNIFTY", "instrument_id" => "257801"]
];

// Timeframes to process
$timeframes = ['5minute', 'minute'];

// ----------------- NEW: Output buffer management -----------------
$cycleCount = 0;
function manageOutputBuffer($forceFlush = false) {
    global $cycleCount, $config;
    
    $cycleCount++;
    if ($forceFlush || $cycleCount % $config['flush_interval'] === 0) {
        ob_flush();
        flush();
        $cycleCount = 0;
        logMsg("--- OUTPUT BUFFER FLUSHED ---", "SYSTEM");
    }
}



// ----------------- DEBUG FUNCTION: Show active positions -----------------
function debugActivePositions($conn, $indexName): void {
    $stmt = $conn->prepare("SELECT id, share_symbol, directiontype, buy_price, status, sellnow, 
                           DATE_FORMAT(buydatetime, '%H:%i:%s') as buy_time
                           FROM ema5989sell 
                           WHERE indices_name = ? 
                           AND status = 'buy'
                           ORDER BY id DESC");
    
    if ($stmt) {
        $stmt->bind_param('s', $indexName);
        $stmt->execute();
        $result = $stmt->get_result();
        
        logMsg("🔍 DEBUG: Active positions for $indexName:");
        $count = 0;
        while ($row = $result->fetch_assoc()) {
            $count++;
            logMsg("   Position #{$row['id']}: {$row['share_symbol']} ({$row['directiontype']})");
            logMsg("     Bought: ₹{$row['buy_price']} at {$row['buy_time']}");
            logMsg("     Status: {$row['status']}, SellNow: {$row['sellnow']}");
        }
        
        if ($count === 0) {
            logMsg("   No active positions found");
        }
        $stmt->close();
    }
}

// ----------------- NEW FUNCTION: Check EMA reversal and update sellnow flag -----------------
// ----------------- CORRECTED FUNCTION: Check EMA reversal only for active buy positions of that index -----------------
// ----------------- CORRECTED FUNCTION: Check EMA reversal for all active buy positions -----------------
// ----------------- COMPLETE REVERSAL CHECK FUNCTION -----------------
// ----------------- ULTRA SIMPLE REVERSAL CHECK FUNCTION -----------------
// ----------------- ENHANCED FUNCTION: Check EMA reversal and trigger opposite trade -----------------
function checkEMAReversalAndUpdateSellNow($conn, $kite, $indexName, $emaCrossover, $testMode, &$crossoverEvents, $now): void {
    /*
    ENHANCED: Checks for EMA reversal and triggers opposite direction trade
    */
    
    // Skip if no valid EMA data
    if (!$emaCrossover['valid'] || $emaCrossover['current_ema9'] === null || $emaCrossover['current_ema89'] === null) {
        return;
    }
    
    $ema9 = $emaCrossover['current_ema9'];
    $ema89 = $emaCrossover['current_ema89'];
    
    logMsg("🔄 Checking reversal for $indexName: EMA9=$ema9, EMA89=$ema89");
    
    // Track if we need to trigger opposite trade
    $triggerOppositeTrade = false;
    $oppositeDirection = '';
    
    // Direct update based on EMA position
    if ($ema9 < $ema89) {
        // EMA9 is BELOW EMA89 - Sell all CE positions AND trigger PE buy
        logMsg("📉 EMA9 < EMA89 - Selling all CE positions for $indexName");
        
        $updateCE = $conn->prepare("UPDATE ema5989sell 
                                   SET sellnow = 1, 
                                       reversal_reason = 'EMA9 crossed below EMA89',
                                       reversal_time = NOW()
                                   WHERE indices_name = ? 
                                   AND status = 'buy' 
                                   AND directiontype = 'CE' 
                                   AND sellnow = 0");
        
        if ($updateCE) {
            $updateCE->bind_param('s', $indexName);
            if ($updateCE->execute()) {
                $ceCount = $updateCE->affected_rows;
                logMsg("✅ Marked $ceCount CE positions for selling");
                
                // If we sold CE positions, we should trigger PE buy
                if ($ceCount > 0) {
                    $triggerOppositeTrade = true;
                    $oppositeDirection = 'PE';
                }
            }
            $updateCE->close();
        }
        
    } elseif ($ema9 > $ema89) {
        // EMA9 is ABOVE EMA89 - Sell all PE positions AND trigger CE buy
        logMsg("📈 EMA9 > EMA89 - Selling all PE positions for $indexName");
        
        $updatePE = $conn->prepare("UPDATE ema5989sell 
                                   SET sellnow = 1, 
                                       reversal_reason = 'EMA9 crossed above EMA89',
                                       reversal_time = NOW()
                                   WHERE indices_name = ? 
                                   AND status = 'buy' 
                                   AND directiontype = 'PE' 
                                   AND sellnow = 0");
        
        if ($updatePE) {
            $updatePE->bind_param('s', $indexName);
            if ($updatePE->execute()) {
                $peCount = $updatePE->affected_rows;
                logMsg("✅ Marked $peCount PE positions for selling");
                
                // If we sold PE positions, we should trigger CE buy
                if ($peCount > 0) {
                    $triggerOppositeTrade = true;
                    $oppositeDirection = 'CE';
                }
            }
            $updatePE->close();
        }
    }
    
    // ========== TRIGGER OPPOSITE DIRECTION TRADE ==========
    if ($triggerOppositeTrade && !empty($oppositeDirection)) {
        logMsg("🔄 REVERSAL DETECTED: Triggering $oppositeDirection trade for $indexName");
        
        // Check if opposite direction already has an active event
        $oppositeKey = $indexName . '_' . $oppositeDirection;
        
        // Only create new event if one doesn't exist or if existing one is completed
        if (!isset($crossoverEvents[$oppositeKey]) || 
            (isset($crossoverEvents[$oppositeKey]) && $crossoverEvents[$oppositeKey]['completed'])) {
            
            $candleCompletionTime = getCurrent1MinCandleCompletionTime($now);
            
            $crossoverEvents[$oppositeKey] = [
                'direction' => $oppositeDirection,
                'crossover_time' => clone $now,
                'candle_completion_time' => $candleCompletionTime,
                'completed' => false,
                'high_low_checked' => false,
                'symbol_created' => false,
                'symbol' => null,
                'instrument_id' => null,
                'breakout_level' => null,
                'high_low_retry_count' => 0,
                'max_high_low_retries' => 10,
                'breakout_checked' => false,
                'breakout_timeout' => null,
                'candle_high' => null,
                'candle_low' => null,
                'success' => false,
                'failure_reason' => null,
                'is_reversal_trade' => true // Mark as reversal trade
            ];
            
            logMsg("🎯 REVERSAL TRADE TRIGGERED: $indexName $oppositeDirection at " . 
                  $now->format('H:i:s') . " - Waiting for 1-min candle completion at " . 
                  $candleCompletionTime->format('H:i:s'));
        } else {
            logMsg("ℹ️ Opposite direction trade already in progress for $indexName $oppositeDirection");
        }
    }
    
    logMsg("🔄 Reversal check complete for $indexName");
}


// ----------------- ENHANCED LOGGING FUNCTION -----------------
function logMsg($message, $level = "INFO") {
    $timestamp = date('Y-m-d H:i:s');
    echo "[$timestamp] [$level] $message<br>\n";
    manageOutputBuffer();
}

// ----------------- NEW FUNCTION: Check if current time is in special time window -----------------
function isSpecialTimeWindow(): bool {
    $current_time = date('H:i');
    $current_hour = (int)date('H');
    $current_minute = (int)date('i');
    
    // Morning window: 9:20 AM to 10:30 AM IST
    $morning_start = '09:20';
    $morning_end = '14:30';
    
    // Evening window: 2:30 PM to 3:30 PM IST  
    $evening_start = '14:30';
    $evening_end = '15:30';
    
    return ($current_time >= $morning_start && $current_time <= $morning_end) ||
           ($current_time >= $evening_start && $current_time <= $evening_end);
}

// ----------------- NEW FUNCTION: Get last 5-minute candle for indices -----------------
function getLast5MinCandleForIndices($conn, $kite, $indexInstrumentId, DateTime $currentTime): ?array {
    try {
        // Calculate the 5-minute candle boundaries
        $current_minute = (int)$currentTime->format('i');
        $current_hour = (int)$currentTime->format('H');
        
        // Find the previous 5-minute candle end time
        $candle_minute = floor(($current_minute - 1) / 5) * 5;
        $candle_end_time = clone $currentTime;
        $candle_end_time->setTime($current_hour, $candle_minute, 0);
        
        $candle_start_time = clone $candle_end_time;
        $candle_start_time->modify('-5 minutes');
        
        logMsg("Looking for 5-min candle: " . $candle_start_time->format('H:i:s') . " to " . $candle_end_time->format('H:i:s'));
        
        // Try to get from database first
        $sql = "SELECT high, low, open, close, volume 
                FROM candle_data_allindices 
                WHERE instrument_token = ? 
                AND timeframe = '5minute' 
                AND timestamp >= ? 
                AND timestamp <= ?
                ORDER BY timestamp DESC 
                LIMIT 1";
        
        $stmt = $conn->prepare($sql);
        if (!$stmt) {
            logMsg("Prepare failed for 5-min candle query: " . $conn->error, "ERROR");
            return null;
        }
        
        $start_str = $candle_start_time->format('Y-m-d H:i:s');
        $end_str = $candle_end_time->format('Y-m-d H:i:s');
        
        $stmt->bind_param('sss', $indexInstrumentId, $start_str, $end_str);
        
        if (!$stmt->execute()) {
            logMsg("Execute failed for 5-min candle query: " . $stmt->error, "ERROR");
            $stmt->close();
            return null;
        }
        
        $result = $stmt->get_result();
        $row = $result->fetch_assoc();
        $stmt->close();
        
        if ($row) {
            logMsg("Found 5-min candle in DB - High: " . $row['high'] . ", Low: " . $row['low']);
            return [
                'high' => (float)$row['high'],
                'low' => (float)$row['low'],
                'open' => (float)$row['open'],
                'close' => (float)$row['close'],
                'volume' => (int)$row['volume']
            ];
        }
        
        // If not in database, try to fetch from API
        logMsg("5-min candle not found in DB, trying API...");
        $apiCandles = fetchCandles($kite, $indexInstrumentId, $candle_start_time, $candle_end_time, '5minute');
        
        if (!empty($apiCandles)) {
            $lastCandle = end($apiCandles);
            logMsg("Found 5-min candle via API - High: " . $lastCandle->high . ", Low: " . $lastCandle->low);
            return [
                'high' => $lastCandle->high,
                'low' => $lastCandle->low,
                'open' => $lastCandle->open,
                'close' => $lastCandle->close,
                'volume' => $lastCandle->volume
            ];
        }
        
        logMsg("No 5-min candle data found for timeframe " . $start_str . " to " . $end_str);
        return null;
        
    } catch (Exception $e) {
        logMsg("Error getting 5-min candle: " . $e->getMessage(), "ERROR");
        return null;
    }
}

// ----------------- NEW FUNCTION: Calculate and save stoploss value -----------------
function calculateAndSaveStoploss($conn, $indexName, $direction, $stoplossValue, $orderId): bool {
    try {
        $updateStmt = $conn->prepare("UPDATE ema5989sell 
                                     SET stoplossvalue = ? 
                                     WHERE order_id = ? AND indices_name = ? AND directiontype = ?");
        
        if (!$updateStmt) {
            logMsg("Prepare failed for stoploss update: " . $conn->error, "ERROR");
            return false;
        }
        
        $updateStmt->bind_param('diss', $stoplossValue, $orderId, $indexName, $direction);
        
        if ($updateStmt->execute()) {
            logMsg("SUCCESS: Saved stoploss value $stoplossValue for $indexName $direction (Order: $orderId)");
            $updateStmt->close();
            return true;
        } else {
            logMsg("Execute failed for stoploss update: " . $updateStmt->error, "ERROR");
            $updateStmt->close();
            return false;
        }
        
    } catch (Exception $e) {
        logMsg("Error saving stoploss: " . $e->getMessage(), "ERROR");
        return false;
    }
}

// ----------------- ENHANCED FUNCTION: Process single crossover event with detailed tracking -----------------
// ----------------- ENHANCED FUNCTION: Process single crossover event with reversal support -----------------
function processSingleCrossoverEvent($conn, $kite, $index, $direction, &$event, $lotSizes, $exchangeMap, $instTableMap, $config, $now) {
    $indexName = $index['name'];
    $crossoverKey = $indexName . '_' . $direction;
    
    logMsg("🔄 Processing crossover event: $crossoverKey - Stage: " . getCrossoverStage($event));
    
    // ========== CHECK IF THIS IS A REVERSAL TRADE ==========
    // If this is a reversal trade, skip 1-minute candle wait and go directly to order placement
    if (isset($event['is_reversal_trade']) && $event['is_reversal_trade'] === true) {
        logMsg("⚡ PROCESSING REVERSAL TRADE - Skipping 1-min candle wait for $indexName $direction");
        
        // Skip directly to symbol creation
        if (!$event['symbol_created']) {
            logMsg("🔧 Generating symbol for reversal trade $indexName $direction...");
            $symbol = generateSymbol($conn, $kite, $now, $direction, $indexName);
            if ($symbol !== null) {
                $event['symbol'] = $symbol;
                
                $instTable = $instTableMap[$indexName] ?? null;
                $instrumentId = getSymbolInstrumentIdFromDB($conn, $instTable, $symbol);
                
                if ($instrumentId) {
                    $event['instrument_id'] = $instrumentId;
                    $event['symbol_created'] = true;
                    $event['breakout_checked'] = true; // Skip breakout check for reversal
                    $event['high_low_checked'] = true; // Skip high/low check
                    logMsg("✅ Reversal symbol created: $symbol (Instrument ID: $instrumentId)");
                } else {
                    logMsg("❌ Failed to get instrument ID for reversal symbol: $symbol");
                    $event['completed'] = true;
                    $event['failure_reason'] = "Instrument ID not found for reversal symbol";
                    return false;
                }
            } else {
                logMsg("❌ Symbol generation failed for reversal trade $indexName $direction");
                $event['completed'] = true;
                $event['failure_reason'] = "Symbol generation failed for reversal trade";
                return false;
            }
        }
        
        // Skip to final order placement stage for reversal trades
        goto reversal_order_placement;
    }
    
    // ========== NORMAL TRADE PROCESSING ==========
    
    // ========== STAGE 1: CHECK 1-MIN CANDLE COMPLETION AND GET HIGH/LOW ==========
    
    // Add 5-second buffer after candle completion to ensure data is available
    $checkTime = clone $event['candle_completion_time'];
    $checkTime->modify('+5 seconds');
    
    // Check if candle completion time + 5 seconds has passed
    if ($now >= $checkTime && !$event['high_low_checked']) {
        logMsg("1-min candle completed + 5 sec buffer passed for $indexName $direction EMA crossover");
        
        // Get the high/low of the 1-minute candle after crossover
        $candleHighLow = get1MinCandleHighLow($conn, $index['instrument_id'], $event['crossover_time']);
        
        if ($candleHighLow['high'] !== null && $candleHighLow['low'] !== null) {
            $event['candle_high'] = $candleHighLow['high'];
            $event['candle_low'] = $candleHighLow['low'];
            $event['high_low_checked'] = true;
            
            logMsg("✅ 1-min Candle High: " . $event['candle_high'] . " | Low: " . $event['candle_low']);
            
            // For CE (EMA9 above EMA89), we take high as breakout level
            // For PE (EMA9 below EMA89), we take low as breakout level
            if ($direction === 'CE') {
                $event['breakout_level'] = $event['candle_high'];
                logMsg("📈 CE Breakout level (High): " . $event['breakout_level']);
            } else {
                $event['breakout_level'] = $event['candle_low'];
                logMsg("📉 PE Breakout level (Low): " . $event['breakout_level']);
            }
            
            // Set breakout timeout (current time + 2 minutes)
            $event['breakout_timeout'] = clone $now;
            $event['breakout_timeout']->modify('+2 minutes');
            
            logMsg("⏰ Breakout timeout set: " . $event['breakout_timeout']->format('H:i:s'));
            
            return true;
            
        } else {
            $event['high_low_retry_count']++;
            logMsg("❌ Failed to get 1-min candle high/low for $indexName (attempt " . $event['high_low_retry_count'] . "/" . $event['max_high_low_retries'] . ")");
            
            if ($event['high_low_retry_count'] >= $event['max_high_low_retries']) {
                logMsg("🚫 Max retries reached for 1-min high/low data - aborting trade");
                $event['completed'] = true;
                $event['failure_reason'] = "High/Low data not available after max retries";
            }
            
            return false;
        }
    }
    
    // ========== STAGE 2: CHECK FOR PRICE BREAKOUT ==========
    
    // Check for price breakout after high/low is available
    if ($event['high_low_checked'] && !$event['breakout_checked'] && !$event['symbol_created']) {
        $currentPrice = getCurrentPrice($kite, $index['instrument_id']);
        
        if ($currentPrice !== null) {
            $breakoutConditionMet = false;
            
            if ($direction === 'CE' && $currentPrice > $event['breakout_level']) {
                $breakoutConditionMet = true;
                logMsg("✅ PRICE BROKE ABOVE HIGH for CE: $currentPrice > " . $event['breakout_level']);
            } elseif ($direction === 'PE' && $currentPrice < $event['breakout_level']) {
                $breakoutConditionMet = true;
                logMsg("✅ PRICE BROKE BELOW LOW for PE: $currentPrice < " . $event['breakout_level']);
            }
            
            // Check if breakout timeout reached
            if ($now >= $event['breakout_timeout']) {
                logMsg("⏰ Breakout timeout reached (2 minutes) - no breakout detected, skipping trade");
                $event['breakout_checked'] = true;
                $event['completed'] = true;
                $event['failure_reason'] = "Breakout timeout - price didn't break level within 2 minutes";
                return false;
            }
            
            if ($breakoutConditionMet) {
                $event['breakout_checked'] = true;
                
                // Generate the symbol
                logMsg("🔧 Generating symbol for $indexName $direction...");
                $symbol = generateSymbol($conn, $kite, $now, $direction, $indexName);
                if ($symbol !== null) {
                    $event['symbol'] = $symbol;
                    
                    $instTable = $instTableMap[$indexName] ?? null;
                    $instrumentId = getSymbolInstrumentIdFromDB($conn, $instTable, $symbol);
                    
                    if ($instrumentId) {
                        $event['instrument_id'] = $instrumentId;
                        $event['symbol_created'] = true;
                        logMsg("✅ Symbol created: $symbol (Instrument ID: $instrumentId)");
                        return true;
                    } else {
                        logMsg("❌ Failed to get instrument ID for symbol: $symbol");
                        $event['completed'] = true;
                        $event['failure_reason'] = "Instrument ID not found for symbol";
                    }
                } else {
                    logMsg("❌ Symbol generation failed for $indexName $direction");
                    $event['completed'] = true;
                    $event['failure_reason'] = "Symbol generation failed";
                }
            } else {
                $timeRemaining = $event['breakout_timeout']->getTimestamp() - $now->getTimestamp();
                logMsg("⏳ Waiting for price breakout - Current: $currentPrice, Breakout Level: " . $event['breakout_level'] . 
                      " (" . ($direction === 'CE' ? "need >" : "need <") . "), Time remaining: " . $timeRemaining . "s");
            }
        } else {
            logMsg("❌ Failed to get current price for breakout check");
        }
        
        return false;
    }
    
    // ========== STAGE 3: FINAL ORDER PLACEMENT WITH STOPLOSS LOGIC ==========
    
    reversal_order_placement:
    
    // Process crossover events that are ready for order placement
    if ($event['symbol_created'] && !$event['completed']) {
        
        // All conditions satisfied - proceed with buy
        logMsg("✅ All conditions met for $indexName $direction - Proceeding with buy validation");
        logMsg("📊 Symbol: " . $event['symbol'] . " | Direction: $direction");
        
        // ========== CONDITION 1: CHECK IF CAN BUY SAME DIRECTION ==========
        logMsg("🔍 Checking if we can buy $direction for $indexName...");
        if (!canBuyDirection($conn, $indexName, $direction)) {
            logMsg("🚫 SKIPPING BUY: Last entry was same direction - avoiding consecutive $direction trade", "WARNING");
            $event['completed'] = true;
            $event['failure_reason'] = "Same direction as last trade - avoiding consecutive trades";
            return false;
        }
        logMsg("✅ Direction validation passed for $indexName $direction");
        
        // ========== CONDITION 2: CHECK TRADING HOURS ==========
        $current_time = $now->format('H:i');
        $start_time = '09:15';
        $end_time = '15:00';
        
        if ($current_time < $start_time || $current_time > $end_time) {
            logMsg("🚫 Outside trading hours (09:15-15:00), skipping buy. Current time: $current_time");
            $event['completed'] = true;
            $event['failure_reason'] = "Outside trading hours";
            return false;
        }
        logMsg("✅ Trading hours validation passed: $current_time");
        
        // ========== CONDITION 3: CLOSE EXISTING POSITIONS ==========
        logMsg("🔄 Closing existing positions before new buy...");
        closeExistingPositionsBeforeBuy($conn, $kite, $indexName, $config['test_mode']);
        logMsg("✅ Position closure completed");
        
        // ========== CONDITION 4: CALCULATE QUANTITY ==========
        logMsg("🧮 Calculating quantity for investment...");
        $optionCurrentPrice = getCurrentPrice($kite, $event['instrument_id']);
        if ($optionCurrentPrice === null) {
            logMsg("❌ Failed to get current option price for quantity calculation", "ERROR");
            $event['failure_reason'] = "Failed to get option price";
            return false;
        }
        
        $qty = calculateInvestmentQuantity($indexName, $optionCurrentPrice, $lotSizes);
        $exchange = $exchangeMap[$indexName] ?? 'NFO';
        logMsg("✅ Quantity calculated: $qty at price: $optionCurrentPrice");
        
        // ========== CONDITION 5: CHECK SPECIAL STOPLOSS CONDITIONS ==========
        $stoplossValue = null;
        
        if (isSpecialTimeWindow()) {
            logMsg("⏰ SPECIAL TIME WINDOW DETECTED: Calculating stoploss from last 5-min candle");
            
            // Get last 5-minute candle for the indices (not the option symbol)
            $last5MinCandle = getLast5MinCandleForIndices($conn, $kite, $index['instrument_id'], $now);
            
            if ($last5MinCandle !== null) {
                // For CE: use low of last 5-min candle as stoploss
                // For PE: use high of last 5-min candle as stoploss
                if ($direction === 'CE') {
                    $stoplossValue = $last5MinCandle['low'];
                    logMsg("📈 CE STOPLOSS: Using low of last 5-min candle: $stoplossValue");
                } else {
                    $stoplossValue = $last5MinCandle['high'];
                    logMsg("📉 PE STOPLOSS: Using high of last 5-min candle: $stoplossValue");
                }
            } else {
                logMsg("⚠️ WARNING: Could not get 5-min candle data for stoploss calculation", "WARNING");
            }
        } else {
            logMsg("ℹ️ Normal time window - No special stoploss calculation");
        }
        
        // ========== FINAL: PLACE BUY ORDER ==========
        logMsg("🚀 PLACING BUY ORDER for " . $event['symbol'] . " Qty: $qty");
        
        // Use test mode if configured
        $orderId = null;
        if ($config['test_mode']) {
            $orderId = "TEST_" . time() . "_" . rand(1000, 9999);
            logMsg("TEST MODE: Simulated order ID: $orderId");
        } else {
            $orderId = placeBuyOrder($kite, $event['symbol'], $qty, $exchange, $config['test_mode']);
        }
        
        if ($orderId !== null) {
            $buyPrice = getCurrentPrice($kite, $event['instrument_id']);
            if ($buyPrice === null) {
                logMsg("❌ Failed to get current price for " . $event['symbol'], "ERROR");
                $event['failure_reason'] = "Failed to get buy price";
                return false;
            }
            logMsg("💰 Current price: $buyPrice");

            // Prepare the insert statement
            $isReversalTrade = isset($event['is_reversal_trade']) ? 1 : 0;
            
            $insert = $conn->prepare("INSERT INTO ema5989sell 
                (share_symbol, share_instrumentid, total_shares, buy_price, order_id, buydatetime, buy_orderid, buy_status, directiontype, indices_name, status, direction_changed, stoplossvalue, is_reversal_trade)
                VALUES (?, ?, ?, ?, ?, NOW(), ?, 0, ?, ?, 'buy', 0, ?, ?)");
            
            if ($insert) {
                $insert->bind_param(
                    "siidssssdi",
                    $event['symbol'],
                    $event['instrument_id'],
                    $qty,
                    $buyPrice,
                    $orderId,
                    $orderId,
                    $direction,
                    $indexName,
                    $stoplossValue,
                    $isReversalTrade
                );
                
                if ($insert->execute()) {
                    logMsg("🎉 SUCCESS: Buy order placed for " . $event['symbol'] . " @ $buyPrice, Qty: $qty");
                    
                    // If we have a stoploss value from special time window, save it
                    if ($stoplossValue !== null) {
                        calculateAndSaveStoploss($conn, $indexName, $direction, $stoplossValue, $orderId);
                    }
                    
                    $event['completed'] = true;
                    $event['success'] = true;
                    
                    // Log if this was a reversal trade
                    if ($isReversalTrade) {
                        logMsg("🔄 REVERSAL TRADE COMPLETED: Successfully entered $direction after EMA reversal");
                    }
                    
                    return true;
                } else {
                    logMsg("❌ Insert failed: " . $insert->error, "ERROR");
                    $event['failure_reason'] = "Database insert failed: " . $insert->error;
                }
                $insert->close();
            } else {
                logMsg("❌ Prepare failed for insert", "ERROR");
                $event['failure_reason'] = "Database prepare failed";
            }
        } else {
            logMsg("❌ Order placement failed - order ID is null", "ERROR");
            $event['failure_reason'] = "Order placement failed";
        }
        
        return false;
    }
    
    return false;
}

// ----------------- INVESTMENT CALCULATION FUNCTION -----------------
function calculateInvestmentQuantity($index, $currentPrice, $lotSizes) {
    $maxInvestment = 50000; // 1 lakh INR
    $minSlotSize = $lotSizes[$index] ?? 25;
    
    if ($currentPrice <= 0) {
        logMsg("❌ $index: Invalid current price: $currentPrice", "ERROR");
        return $minSlotSize; // Return minimum slot as fallback
    }
    
    // Calculate maximum quantity we can buy within 1 lakh
    $maxQuantity = floor($maxInvestment / $currentPrice);
    
    // Ensure quantity is a multiple of slot size
    $finalQuantity = floor($maxQuantity / $minSlotSize) * $minSlotSize;
    
    // Ensure at least 1 slot
    $finalQuantity = max($minSlotSize, $finalQuantity);
    
    // Calculate actual slots and investment
    $finalSlots = $finalQuantity / $minSlotSize;
    $actualInvestment = $finalQuantity * $currentPrice;
    
    logMsg("💰 $index: Investment Calculation - Price: ₹$currentPrice, Min Slot: $minSlotSize, " .
           "Max Qty Possible: $maxQuantity, Final Qty: $finalQuantity, Final Slots: $finalSlots, " .
           "Investment: ₹" . number_format($actualInvestment, 2));
    
    // Warning if investment exceeds 1 lakh significantly
    if ($actualInvestment > $maxInvestment * 1.05) { // 5% tolerance
        logMsg("⚠️ $index: Investment exceeds 1 lakh significantly: ₹" . number_format($actualInvestment, 2), "WARNING");
    }
    
    // Additional validation to ensure quantity is multiple of slot size
    if ($finalQuantity % $minSlotSize !== 0) {
        logMsg("❌ $index: Quantity calculation error - $finalQuantity is not multiple of $minSlotSize", "ERROR");
        // Force to nearest multiple
        $finalQuantity = floor($finalQuantity / $minSlotSize) * $minSlotSize;
        $finalQuantity = max($minSlotSize, $finalQuantity);
        logMsg("🔄 $index: Corrected quantity to: $finalQuantity");
    }
    
    return (int)$finalQuantity;
}

// ----------------- HELPER FUNCTIONS -----------------
function getCurrentPrice(KiteConnect $kite, ?int $instrument_token): ?float {
    if (!$instrument_token) return null;
    
    try {
        $quote = $kite->getQuote([$instrument_token]);
        return $quote[$instrument_token]->last_price ?? null;
    } catch (Exception $e) {
        logMsg("Failed to get price for token $instrument_token: " . $e->getMessage(), "ERROR");
        return null;
    }
}


// FIXED FUNCTION: Get last entry side for index WITH TODAY'S DATE FILTER
function getLastEntrySide($conn, $indexName): ?string {
    // Get today's date
    $today = date('Y-m-d');
    
    $sql = "SELECT directiontype FROM ema5989sell 
            WHERE indices_name = ? 
            AND DATE(buydatetime) = ? 
            ORDER BY id DESC 
            LIMIT 1";
    
    $stmt = $conn->prepare($sql);
    if ($stmt) {
        $stmt->bind_param('ss', $indexName, $today);
        $stmt->execute();
        $result = $stmt->get_result();
        
        if ($result && $result->num_rows > 0) {
            $row = $result->fetch_assoc();
            $stmt->close();
            return $row['directiontype'];
        }
        $stmt->close();
    }
    
    return null;
}




// ENHANCED FUNCTION: Don't buy same side as last entry with detailed logging
function canBuyDirection($conn, $indexName, $newDirection): bool {
    $lastSide = getLastEntrySide($conn, $indexName);
    
    // If no previous trades, always allow
    if ($lastSide === null) {
        logMsg("✅ CAN BUY $newDirection: No previous trades for $indexName");
        return true;
    }
    
    // If last entry is same side, don't allow
    if ($lastSide === $newDirection) {
        logMsg("🚫 CANNOT BUY $newDirection: Last entry for $indexName was $lastSide - avoiding same direction trade", "WARNING");
        return false;
    }
    
    // Allow if last entry was opposite side
    logMsg("✅ CAN BUY $newDirection: Last entry for $indexName was $lastSide - opposite direction allowed");
    return true;
}

// NEW FUNCTION: Execute sell order for reversal with CORRECT column names
function executeSellOrderForReversal($conn, $kite, $positionId, $testMode): bool {
    // Get position details
    $stmt = $conn->prepare("SELECT share_symbol, share_instrumentid, total_shares, buy_price, indices_name, directiontype 
                           FROM ema5989sell 
                           WHERE id = ?");
    if (!$stmt) {
        logMsg("Failed to prepare statement for position details", "ERROR");
        return false;
    }
    
    $stmt->bind_param('i', $positionId);
    $stmt->execute();
    $result = $stmt->get_result();
    
    if (!$result || $result->num_rows === 0) {
        logMsg("Position not found for ID: $positionId", "ERROR");
        $stmt->close();
        return false;
    }
    
    $position = $result->fetch_assoc();
    $stmt->close();
    
    $symbol = $position['share_symbol'];
    $instrumentId = $position['share_instrumentid'];
    $quantity = $position['total_shares'];
    $indexName = $position['indices_name'];
    $direction = $position['directiontype'];
    $exchange = 'NFO'; // Default exchange
    
    // Get current price for sell
    $currentPrice = getCurrentPrice($kite, $instrumentId);
    if ($currentPrice === null) {
        logMsg("Failed to get current price for $symbol", "ERROR");
        return false;
    }
    

    
    // FIXED: Update the position in database with CORRECT column names
    $updateStmt = $conn->prepare("UPDATE ema5989sell 
                                 SET status = 'sell', 
                                     sell_price = ?,
                                     selldatetime = NOW(),
                                     sell_orderid = ?,
                                     sell_status = 1,
                                     sellnow = 1,
                                     reversal_reason = 'EMA Crossover Reversal'
                                 WHERE id = ?");
    if ($updateStmt) {
        $updateStmt->bind_param('dsi', $currentPrice, $orderId, $positionId);
        if ($updateStmt->execute()) {
            logMsg("SUCCESS: Position #$positionId ($symbol $direction) sold for reversal @ $currentPrice");
            $updateStmt->close();
            return true;
        } else {
            logMsg("Failed to update position after sell: " . $updateStmt->error, "ERROR");
            $updateStmt->close();
            return false;
        }
    } else {
        logMsg("Failed to prepare update statement for sell", "ERROR");
        return false;
    }
}

// FIXED FUNCTION: Enhanced historical data fetching with sufficient periods
function fetchHistoricalDataForIndex(KiteConnect $kite, mysqli $conn, array $index, DateTime $now, array $timeframes): array {
    $marketHolidays = getMarketHolidays();
    
    $isTradingDay = function(DateTime $date) use ($marketHolidays): bool {
        $weekday = (int)$date->format('N');
        $dateStr = $date->format('Y-m-d');
        return ($weekday <= 5) && !in_array($dateStr, $marketHolidays);
    };

    $candleData = [];
    $token = $index['instrument_id'];
    $shareName = $index['name'];

    foreach ($timeframes as $timeframe) {
        $candleData[$timeframe] = [];
        
        // ENHANCED: Fetch more historical data (EMA 89 needs at least 89 periods)
        $historicalStartDate = clone $now;
        $historicalStartDate->modify('-30 days')->setTime(9, 15, 0);
        
        $historicalEndDate = clone $now;
        $historicalEndDate->modify('-1 day')->setTime(15, 30, 0);

        logMsg("Fetching historical data for $shareName from " . 
               $historicalStartDate->format('Y-m-d H:i:s') . " to " . 
               $historicalEndDate->format('Y-m-d H:i:s'));

        try {
            $historicalCandles = getCandleData($conn, $token, $timeframe, $historicalStartDate, $historicalEndDate);
            logMsg("Historical $timeframe data for $shareName: " . count($historicalCandles) . " candles");
        } catch (Exception $e) {
            logMsg("Error fetching historical data: " . $e->getMessage(), "ERROR");
            $historicalCandles = [];
        }

        // Today's data
        $todayStart = clone $now;
        $todayStart->setTime(9, 15, 0);

        $todayEnd = clone $now;
        $todayEnd->setTime(15, 30, 0);

        try {
            $todayCandles = getCandleData($conn, $token, $timeframe, $todayStart, $todayEnd);
        } catch (Exception $e) {
            logMsg("Error fetching today's data: " . $e->getMessage(), "ERROR");
            $todayCandles = [];
        }

        if (empty($todayCandles) && $isTradingDay($now)) {
            logMsg("No today's data in DB, fetching from API for $shareName");
            try {
                $todayCandles = fetchCandles($kite, $token, $todayStart, $todayEnd, $timeframe);
                
                if ($todayCandles === null) {
                    logMsg("API fetch returned null for $shareName, using empty array", "WARNING");
                    $todayCandles = [];
                } else {
                    logMsg("API fetch successful: " . count($todayCandles) . " candles for $shareName");
                }
            } catch (Exception $e) {
                logMsg("API fetch failed: " . $e->getMessage(), "ERROR");
                $todayCandles = [];
            }
        } else {
            logMsg("Using today's $timeframe data from DB for $shareName: " . count($todayCandles) . " candles");
        }

        // Merge and validate data
        $historicalCandles = is_array($historicalCandles) ? $historicalCandles : [];
        $todayCandles = is_array($todayCandles) ? $todayCandles : [];
        
        $allCandles = array_merge($historicalCandles, $todayCandles);
        
        // Remove duplicates and sort by timestamp
        $uniqueCandles = [];
        $seenTimestamps = [];
        
        foreach ($allCandles as $candle) {
            $timestamp = is_string($candle->date) ? $candle->date : 
                        (property_exists($candle, 'date') ? $candle->date->format('Y-m-d H:i:s') : 'unknown');
            if (!in_array($timestamp, $seenTimestamps)) {
                $uniqueCandles[] = $candle;
                $seenTimestamps[] = $timestamp;
            }
        }
        
        // Sort by timestamp
        usort($uniqueCandles, function($a, $b) {
            $timeA = is_string($a->date) ? strtotime($a->date) : 
                    (property_exists($a, 'date') ? $a->date->getTimestamp() : 0);
            $timeB = is_string($b->date) ? strtotime($b->date) : 
                    (property_exists($b, 'date') ? $b->date->getTimestamp() : 0);
            return $timeA <=> $timeB;
        });

        $candleData[$timeframe] = $uniqueCandles;
        logMsg("Final $timeframe data for $shareName: " . count($candleData[$timeframe]) . " candles (after deduplication)");
        
        // Debug: Show data range
        if (!empty($candleData[$timeframe])) {
            $first = reset($candleData[$timeframe]);
            $last = end($candleData[$timeframe]);
            $firstTime = is_string($first->date) ? $first->date : 
                        (property_exists($first, 'date') ? $first->date->format('Y-m-d H:i:s') : 'unknown');
            $lastTime = is_string($last->date) ? $last->date : 
                       (property_exists($last, 'date') ? $last->date->format('Y-m-d H:i:s') : 'unknown');
            logMsg("Data range: $firstTime to $lastTime");
        }
    }

    return $candleData;
}

function generateSymbol($conn, $kite, $date, $type, $index) {
    global $spotTokenMap, $stepMap, $expiryTableMap;
    
    $spotToken = $spotTokenMap[$index] ?? null;
    if (!$spotToken) return null;

    $spotPrice = getCurrentPrice($kite, $spotToken);
    if ($spotPrice === null) return null;

    $step = $stepMap[$index] ?? 50;
    $strike = round($spotPrice / $step) * $step;
    
    // Adjust strike based on option type
    if ($type == 'CE') {
        $strike += $step; // CE: strike + step
    } elseif ($type == 'PE') {
        $strike -= $step; // PE: strike - step
    }

    $expiryStr = null;
    $expTable = $expiryTableMap[$index] ?? null;
    if ($expTable) {
        $res = $conn->query("SELECT exp_date FROM {$expTable} ORDER BY id DESC LIMIT 1");
        if ($res && $res->num_rows > 0) {
            $r = $res->fetch_assoc();
            $expiryStr = strtoupper(trim($r['exp_date']));
        }
    }
    if (!$expiryStr) {
        $expiry = clone $date;
        $expiry->modify('this Thursday');
        $expiryStr = strtoupper($expiry->format('yM'));
    }
    
    if($index == 'MIDCAP') {
        $index = 'MIDCPNIFTY';
    }

    return $index . $expiryStr . $strike . $type;
}

function getSymbolInstrumentIdFromDB($conn, $table, $symbol) {
    if (!$table) return null;
    $stmt = $conn->prepare("SELECT symbol1_token FROM {$table} WHERE symbol1 = ? LIMIT 1");
    if (!$stmt) return null;
    $stmt->bind_param('s', $symbol);
    $stmt->execute();
    $res = $stmt->get_result();
    if ($res && $res->num_rows > 0) {
        $row = $res->fetch_assoc();
        return (int)$row['symbol1_token'];
    }
    return null;
}

function placeBuyOrder($kite, string $tradingsymbol, int $quantity, string $exchange, bool $testMode): ?string {
    if ($testMode) {
        logMsg("TEST MODE: Simulating buy for $tradingsymbol qty $quantity");
        return "1";
    }
    try {
        $order = $kite->placeOrder("regular", [
            "exchange" => $exchange,
            "tradingsymbol" => $tradingsymbol,
            "transaction_type" => "BUY",
            "quantity" => $quantity,
            "order_type" => "MARKET",
            "product" => "MIS"
        ]);
        
        // FIX: Check if $order is an object and access properties correctly
        if (is_object($order) && property_exists($order, 'order_id')) {
            logMsg("Live order placed successfully: " . $order->order_id);
            return (string)$order->order_id;
        } elseif (is_array($order) && isset($order['order_id'])) {
            logMsg("Live order placed successfully: " . $order['order_id']);
            return (string)$order['order_id'];
        } else {
            logMsg("Order placement failed - no order ID returned", "ERROR");
            return null;
        }
    } catch (Exception $e) {
        logMsg("Buy order failed: " . $e->getMessage(), "ERROR");
        return null;
    }
}

function getMarketHolidays(): array {
    return [
        '2025-01-01', '2025-01-26', '2025-03-10', '2025-04-14', '2025-05-01',
        '2025-08-15', '2025-10-02', '2025-10-22','2025-10-21', '2025-11-12', '2025-12-25','2026-01-15','2026-01-26',
    ];
}

function isMarketHolidayOrWeekend(DateTime $date): bool {
    static $holidays = null;
    
    if ($holidays === null) {
        $holidays = getMarketHolidays();
    }
    
    $weekday = (int)$date->format('N');
    $dateStr = $date->format('Y-m-d');
    
    return $weekday >= 6 || in_array($dateStr, $holidays);
}

function getPreviousTradingDay(DateTime $date): DateTime {
    $prev = clone $date;
    do {
        $prev->modify('-1 day');
    } while (isMarketHolidayOrWeekend($prev));
    return $prev;
}

// NEW FUNCTION: Check EMA crossover and close opposite positions
function checkEMACrossoverAndClosePositions($conn, $kite, $indexName, $crossoverDirection, $testMode): void {
    /*
    $crossoverDirection values:
    - 'above': EMA 9 crossed above EMA 89 (bullish) - close all active PE positions
    - 'below': EMA 9 crossed below EMA 89 (bearish) - close all active CE positions
    */
    
    $oppositeDirection = ($crossoverDirection === 'above') ? 'PE' : 'CE';
    
    logMsg("EMA CROSSOVER REVERSAL: Checking for $indexName - $crossoverDirection crossover, closing $oppositeDirection positions");
    
    // Additional safety: Check if market is open
    $current_time = date('H:i');
    $start_time = '09:15';
    $end_time = '15:00';
    
    if ($current_time < $start_time || $current_time > $end_time) {
        logMsg("Market closed - skipping EMA crossover reversal check for $indexName");
        return;
    }
    
    // Find all active buy positions for this index with opposite direction
    $stmt = $conn->prepare("SELECT id, share_symbol, total_shares, directiontype, buy_price 
                           FROM ema5989sell 
                           WHERE indices_name = ? 
                           AND status = 'buy' 
                           AND directiontype = ? 
                           AND sellnow = 0"); // Only positions that haven't been marked for selling
    
    if (!$stmt) {
        logMsg("Failed to prepare statement for finding active positions", "ERROR");
        return;
    }
    
    $stmt->bind_param('ss', $indexName, $oppositeDirection);
    $stmt->execute();
    $result = $stmt->get_result();
    $stmt->close();
    
    if (!$result || $result->num_rows === 0) {
        logMsg("No active $oppositeDirection positions found for $indexName to close on EMA crossover");
        return;
    }
    
    $positionsToClose = [];
    while ($row = $result->fetch_assoc()) {
        $positionsToClose[] = $row;
    }
    
    logMsg("EMA CROSSOVER REVERSAL: Found " . count($positionsToClose) . " active $oppositeDirection positions for $indexName");
    
    // Close each position
    foreach ($positionsToClose as $position) {
        $positionId = $position['id'];
        $symbol = $position['share_symbol'];
        $direction = $position['directiontype'];
        $buyPrice = $position['buy_price'];
        
        logMsg("EMA CROSSOVER REVERSAL: Closing position #$positionId ($symbol $direction) bought @ $buyPrice");
        
        // Use existing function to execute sell order
        $success = executeSellOrderForReversal($conn, $kite, $positionId, $testMode);
        
        if ($success) {
            logMsg("SUCCESS: Position #$positionId closed due to EMA $crossoverDirection crossover");
            
            // Additional update to ensure sellnow is set to 1
            $updateStmt = $conn->prepare("UPDATE ema5989sell SET sellnow = 1 WHERE id = ?");
            if ($updateStmt) {
                $updateStmt->bind_param('i', $positionId);
                $updateStmt->execute();
                $updateStmt->close();
                logMsg("Confirmed: sellnow = 1 for position #$positionId");
            }
        } else {
            logMsg("FAILED: Could not close position #$positionId due to EMA crossover", "ERROR");
        }
    }
}

// FIXED FUNCTION: fetchCandles with proper DateTime handling
function fetchCandles(KiteConnect $kite, string $token, DateTime $from, DateTime $to, string $interval = '5minute', int $maxRetries = 3): ?array {
    $retryCount = 0;
    
    while ($retryCount < $maxRetries) {
        try {
            // FIX: Convert DateTime objects to strings for API call
            $response = $kite->getHistoricalData(
                $token,
                $interval,
                $from->format('Y-m-d H:i:s'),  // Convert to string
                $to->format('Y-m-d H:i:s'),    // Convert to string
                false,
                false
            );
            
            if ($response === null || !is_array($response) || empty($response)) {
                throw new Exception("Invalid or empty response from API");
            }
            
            $validCandles = [];
            foreach ($response as $candle) {
                if (is_object($candle) && 
                    property_exists($candle, 'close') && 
                    property_exists($candle, 'date') &&
                    is_numeric($candle->close) && 
                    $candle->close > 0) {
                    $validCandles[] = $candle;
                }
            }
            
            if (empty($validCandles)) {
                throw new Exception("No valid candles found in response");
            }
            
            return $validCandles;
            
        } catch (Exception $e) {
            $retryCount++;
            if ($retryCount < $maxRetries) {
                sleep(pow(2, $retryCount));
            } else {
                error_log("Failed to fetch $interval candles after $maxRetries attempts: " . $e->getMessage());
                return null;
            }
        }
    }
    
    return null;
}

// FIXED FUNCTION: getCandleData with proper DateTime handling
function getCandleData(mysqli $conn, string $instrumentToken, string $timeframe, DateTime $from, DateTime $to): array {
    if ($from > $to) {
        logMsg("Invalid timeframe: from (" . $from->format('Y-m-d H:i:s') . ") after to (" . $to->format('Y-m-d H:i:s') . ")");
        return [];
    }
    
    $now = new DateTime();
    if ($from > $now) {
        logMsg("Cannot query future timeframe: from (" . $from->format('Y-m-d H:i:s') . ") is in future");
        return [];
    }
    
    $sql = "SELECT timestamp, open, high, low, close, volume 
            FROM candle_data_allindices 
            WHERE instrument_token = ? 
            AND timeframe = ? 
            AND timestamp BETWEEN ? AND ?
            ORDER BY timestamp ASC";
    
    $stmt = $conn->prepare($sql);
    if (!$stmt) {
        error_log("Prepare failed: " . $conn->error);
        return [];
    }
    
    // FIX: Convert DateTime objects to strings
    $fromStr = $from->format('Y-m-d H:i:s');
    $toStr = $to->format('Y-m-d H:i:s');
    
    $stmt->bind_param('ssss', $instrumentToken, $timeframe, $fromStr, $toStr);
    
    if (!$stmt->execute()) {
        error_log("Execute failed: " . $stmt->error);
        $stmt->close();
        return [];
    }
    
    $result = $stmt->get_result();
    $candles = [];
    
    while ($row = $result->fetch_assoc()) {
        $candle = new stdClass();
        $candle->date = $row['timestamp'];
        $candle->open = (float)$row['open'];
        $candle->high = (float)$row['high'];
        $candle->low = (float)$row['low'];
        $candle->close = (float)$row['close'];
        $candle->volume = (int)$row['volume'];
        $candles[] = $candle;
    }
    
    $stmt->close();
    
    logMsg("Database query for $instrumentToken $timeframe: " . 
           $fromStr . " to " . $toStr . " -> " . count($candles) . " candles");
    
    return $candles;
}

// NEW FUNCTION: Close all existing positions before placing new buy order
function closeExistingPositionsBeforeBuy($conn, $kite, $indexName, $testMode): void {
    logMsg("CLOSING EXISTING POSITIONS: Checking for active positions to close before new buy for $indexName");
    
    // Find all active buy positions for this index
    $stmt = $conn->prepare("SELECT id, share_symbol, share_instrumentid, total_shares, buy_price, directiontype 
                           FROM ema5989sell 
                           WHERE indices_name = ? 
                           AND status = 'buy' 
                           AND sellnow = 0"); // Only positions that haven't been marked for selling
    
    if (!$stmt) {
        logMsg("Failed to prepare statement for finding active positions", "ERROR");
        return;
    }
    
    $stmt->bind_param('s', $indexName);
    $stmt->execute();
    $result = $stmt->get_result();
    $stmt->close();
    
    if (!$result || $result->num_rows === 0) {
        logMsg("No active positions found for $indexName to close before new buy");
        return;
    }
    
    $positionsToClose = [];
    while ($row = $result->fetch_assoc()) {
        $positionsToClose[] = $row;
    }
    
    logMsg("Found " . count($positionsToClose) . " active positions for $indexName to close before new buy");
    
    // Close each position using the existing reversal function
    foreach ($positionsToClose as $position) {
        $positionId = $position['id'];
        $symbol = $position['share_symbol'];
        $direction = $position['directiontype'];
        $buyPrice = $position['buy_price'];
        
        logMsg("Closing position before new buy: #$positionId ($symbol $direction) bought @ $buyPrice");
        
        // Use existing function to execute sell order
        $success = executeSellOrderForReversal($conn, $kite, $positionId, $testMode);
        
        if ($success) {
            logMsg("SUCCESS: Position #$positionId closed before new buy");
            
            // Additional update to ensure sellnow is set to 1
            $updateStmt = $conn->prepare("UPDATE ema5989sell SET sellnow = 1 WHERE id = ?");
            if ($updateStmt) {
                $updateStmt->bind_param('i', $positionId);
                $updateStmt->execute();
                $updateStmt->close();
                logMsg("Confirmed: sellnow = 1 for position #$positionId");
            }
        } else {
            logMsg("FAILED: Could not close position #$positionId before new buy", "ERROR");
        }
    }
    
    // Execute the UPDATE query as mentioned in your requirement
    $updateSql = "UPDATE ema5989sell SET sellnow = 1 WHERE status = 'buy' AND indices_name = ?";
    $updateStmt = $conn->prepare($updateSql);
    
    if ($updateStmt) {
        $updateStmt->bind_param('s', $indexName);
        if ($updateStmt->execute()) {
            $affectedRows = $updateStmt->affected_rows;
            logMsg("SUCCESS: Updated $affectedRows records - set sellnow = 1 for all active $indexName positions");
        } else {
            logMsg("Failed to update sellnow flag: " . $updateStmt->error, "ERROR");
        }
        $updateStmt->close();
    } else {
        logMsg("Failed to prepare update statement for sellnow flag", "ERROR");
    }
}

// NEW FUNCTION: Get 1-minute candle high/low after completion
function get1MinCandleHighLow($conn, $instrumentToken, DateTime $crossoverTime): array {
    // Calculate the exact 1-minute candle timeframe
    $candleStartTime = clone $crossoverTime;
    $candleStartTime->setTime(
        (int)$crossoverTime->format('H'),
        (int)$crossoverTime->format('i'),
        0
    );
    
    $candleEndTime = clone $candleStartTime;
    $candleEndTime->modify('+1 minute');
    
    logMsg("Looking for 1-min candle: " . $candleStartTime->format('H:i:s') . " to " . $candleEndTime->format('H:i:s'));
    
    // If the candle end time is in the future, we can't get the data yet
    $now = new DateTime();
    if ($candleEndTime > $now) {
        logMsg("1-min candle is still forming (ends at " . $candleEndTime->format('H:i:s') . "), cannot get high/low yet");
        return ['high' => null, 'low' => null];
    }
    
    // Query for the exact 1-minute candle
    $sql = "SELECT high, low 
            FROM candle_data_allindices 
            WHERE instrument_token = ? 
            AND timeframe = 'minute' 
            AND timestamp >= ? 
            AND timestamp < ?
            ORDER BY timestamp ASC
            LIMIT 1";
    
    $stmt = $conn->prepare($sql);
    if (!$stmt) {
        error_log("Prepare failed: " . $conn->error);
        return ['high' => null, 'low' => null];
    }
    
    // FIX: Convert DateTime objects to strings
    $startStr = $candleStartTime->format('Y-m-d H:i:s');
    $endStr = $candleEndTime->format('Y-m-d H:i:s');
    
    $stmt->bind_param('sss', $instrumentToken, $startStr, $endStr);
    
    if (!$stmt->execute()) {
        error_log("Execute failed: " . $stmt->error);
        $stmt->close();
        return ['high' => null, 'low' => null];
    }
    
    $result = $stmt->get_result();
    $row = $result->fetch_assoc();
    $stmt->close();
    
    $high = $row['high'] ?? null;
    $low = $row['low'] ?? null;
    
    if ($high !== null && $low !== null) {
        logMsg("Found 1-min candle high/low: High=$high, Low=$low for timeframe $startStr to $endStr");
    } else {
        logMsg("No 1-min candle data found for timeframe $startStr to $endStr");
        
        // Alternative: Try to fetch from API if not in database
        try {
            global $kite;
            // Only fetch from API if the candle is complete
            if ($candleEndTime <= $now) {
                $apiCandles = fetchCandles($kite, $instrumentToken, $candleStartTime, $candleEndTime, 'minute');
                if (!empty($apiCandles)) {
                    $lastCandle = end($apiCandles);
                    $high = $lastCandle->high ?? null;
                    $low = $lastCandle->low ?? null;
                    logMsg("API fetch successful for 1-min: High=$high, Low=$low");
                }
            } else {
                logMsg("1-min candle not complete yet, cannot fetch from API");
            }
        } catch (Exception $e) {
            logMsg("API fetch failed for 1-min: " . $e->getMessage(), "ERROR");
        }
    }
    
    return ['high' => $high, 'low' => $low];
}

// ----------------- NEW FUNCTION: Execute immediate reversal trade -----------------
function executeImmediateReversalTrade($conn, $kite, $indexName, $direction, $lotSizes, $exchangeMap, $instTableMap, $config, $now): bool {
    /*
    Execute immediate reversal trade without waiting for candle completion
    This is used when EMA reversal is detected and we need to enter opposite trade
    */
    
    logMsg("⚡ EXECUTING IMMEDIATE REVERSAL TRADE for $indexName $direction");
    
    // ========== CONDITION 1: CHECK IF CAN BUY SAME DIRECTION ==========
    logMsg("🔍 Checking if we can buy $direction for $indexName...");
    if (!canBuyDirection($conn, $indexName, $direction)) {
        logMsg("🚫 SKIPPING REVERSAL BUY: Last entry was same direction - avoiding consecutive $direction trade", "WARNING");
        return false;
    }
    logMsg("✅ Direction validation passed for $indexName $direction");
    
    // ========== CONDITION 2: CHECK TRADING HOURS ==========
    $current_time = $now->format('H:i');
    $start_time = '09:15';
    $end_time = '15:00';
    
    if ($current_time < $start_time || $current_time > $end_time) {
        logMsg("🚫 Outside trading hours (09:15-15:00), skipping reversal buy. Current time: $current_time");
        return false;
    }
    logMsg("✅ Trading hours validation passed: $current_time");
    
    // ========== CONDITION 3: CLOSE EXISTING POSITIONS ==========
    logMsg("🔄 Closing existing positions before reversal buy...");
    closeExistingPositionsBeforeBuy($conn, $kite, $indexName, $config['test_mode']);
    logMsg("✅ Position closure completed");
    
    // ========== CONDITION 4: GENERATE SYMBOL ==========
    logMsg("🔧 Generating symbol for $indexName $direction...");
    $symbol = generateSymbol($conn, $kite, $now, $direction, $indexName);
    if ($symbol === null) {
        logMsg("❌ Failed to generate symbol for reversal trade", "ERROR");
        return false;
    }
    
    $instTable = $instTableMap[$indexName] ?? null;
    $instrumentId = getSymbolInstrumentIdFromDB($conn, $instTable, $symbol);
    
    if (!$instrumentId) {
        logMsg("❌ Failed to get instrument ID for symbol: $symbol");
        return false;
    }
    
    logMsg("✅ Symbol created: $symbol (Instrument ID: $instrumentId)");
    
    // ========== CONDITION 5: CALCULATE QUANTITY ==========
    logMsg("🧮 Calculating quantity for reversal investment...");
    $optionCurrentPrice = getCurrentPrice($kite, $instrumentId);
    if ($optionCurrentPrice === null) {
        logMsg("❌ Failed to get current option price for quantity calculation", "ERROR");
        return false;
    }
    
    $qty = calculateInvestmentQuantity($indexName, $optionCurrentPrice, $lotSizes);
    $exchange = $exchangeMap[$indexName] ?? 'NFO';
    logMsg("✅ Quantity calculated: $qty at price: $optionCurrentPrice");
    
    // ========== CONDITION 6: CHECK SPECIAL STOPLOSS CONDITIONS ==========
    $stoplossValue = null;
    
    if (isSpecialTimeWindow()) {
        logMsg("⏰ SPECIAL TIME WINDOW DETECTED: Calculating stoploss from last 5-min candle");
        
        // Get the index instrument ID for stoploss calculation
        $indexInstrumentId = null;
        global $spotTokenMap;
        if (isset($spotTokenMap[$indexName])) {
            $indexInstrumentId = $spotTokenMap[$indexName];
        }
        
        if ($indexInstrumentId) {
            $last5MinCandle = getLast5MinCandleForIndices($conn, $kite, $indexInstrumentId, $now);
            
            if ($last5MinCandle !== null) {
                // For CE: use low of last 5-min candle as stoploss
                // For PE: use high of last 5-min candle as stoploss
                if ($direction === 'CE') {
                    $stoplossValue = $last5MinCandle['low'];
                    logMsg("📈 CE STOPLOSS: Using low of last 5-min candle: $stoplossValue");
                } else {
                    $stoplossValue = $last5MinCandle['high'];
                    logMsg("📉 PE STOPLOSS: Using high of last 5-min candle: $stoplossValue");
                }
            } else {
                logMsg("⚠️ WARNING: Could not get 5-min candle data for stoploss calculation", "WARNING");
            }
        }
    } else {
        logMsg("ℹ️ Normal time window - No special stoploss calculation");
    }
    
    // ========== FINAL: PLACE REVERSAL BUY ORDER ==========
    logMsg("🚀 PLACING REVERSAL BUY ORDER for " . $symbol . " Qty: $qty");
    
    $orderId = placeBuyOrder($kite, $symbol, $qty, $exchange, $config['test_mode']);
    
    //$orderId =  1;
    
    if ($orderId !== null) {
        $buyPrice = getCurrentPrice($kite, $instrumentId);
        if ($buyPrice === null) {
            logMsg("❌ Failed to get current price for " . $symbol, "ERROR");
            return false;
        }
        logMsg("💰 Current price: $buyPrice");

        $insert = $conn->prepare("INSERT INTO ema5989sell 
            (share_symbol, share_instrumentid, total_shares, buy_price, order_id, buydatetime, buy_orderid, buy_status, directiontype, indices_name, status, direction_changed, stoplossvalue, is_reversal_trade)
            VALUES (?, ?, ?, ?, ?, NOW(), ?, 0, ?, ?, 'buy', 0, ?, 1)");
        if ($insert) {
            $insert->bind_param(
                "siidssssd",
                $symbol,
                $instrumentId,
                $qty,
                $buyPrice,
                $orderId,
                $orderId,
                $direction,
                $indexName,
                $stoplossValue
            );
            if ($insert->execute()) {
                logMsg("🎉 SUCCESS: Reversal buy order placed for " . $symbol . " @ $buyPrice, Qty: $qty");
                
                // If we have a stoploss value from special time window, save it
                if ($stoplossValue !== null) {
                    calculateAndSaveStoploss($conn, $indexName, $direction, $stoplossValue, $orderId);
                }
                
                return true;
            } else {
                logMsg("❌ Insert failed: " . $insert->error, "ERROR");
            }
            $insert->close();
        } else {
            logMsg("❌ Prepare failed for insert", "ERROR");
        }
    } else {
        logMsg("❌ Order placement failed - order ID is null", "ERROR");
    }
    
    return false;
}

// NEW FUNCTION: Get completion time of current 1-minute candle
function getCurrent1MinCandleCompletionTime(DateTime $now): DateTime {
    $completionTime = clone $now;
    
    // Round up to next minute
    $completionTime->setTime(
        (int)$now->format('H'),
        (int)$now->format('i') + 1,
        0
    );
    
    return $completionTime;
}

// NEW FUNCTION: Check price breakout for CE/PE
function checkPriceBreakout($kite, $instrumentToken, $breakoutLevel, $direction, $maxWaitTime = 120): array {
    $startTime = time();
    $breakoutFound = false;
    $currentPrice = null;
    
    logMsg("Starting price breakout check for $direction - Breakout Level: $breakoutLevel, Max Wait: {$maxWaitTime}s");
    
    while ((time() - $startTime) < $maxWaitTime) {
        $currentPrice = getCurrentPrice($kite, $instrumentToken);
        
        if ($currentPrice !== null) {
            if ($direction === 'CE' && $currentPrice > $breakoutLevel) {
                $breakoutFound = true;
                logMsg("CE BREAKOUT CONFIRMED: $currentPrice > $breakoutLevel");
                break;
            } elseif ($direction === 'PE' && $currentPrice < $breakoutLevel) {
                $breakoutFound = true;
                logMsg("PE BREAKOUT CONFIRMED: $currentPrice < $breakoutLevel");
                break;
            } else {
                $remainingTime = $maxWaitTime - (time() - $startTime);
                logMsg("Waiting for $direction breakout - Current: $currentPrice, Need: " . 
                      ($direction === 'CE' ? ">$breakoutLevel" : "<$breakoutLevel") . 
                      " (Remaining: {$remainingTime}s)");
            }
        }
        
        sleep(2); // Check every 2 seconds
    }
    
    return [
        'breakout_found' => $breakoutFound,
        'current_price' => $currentPrice,
        'breakout_level' => $breakoutLevel,
        'time_elapsed' => time() - $startTime
    ];
}

// FIXED FUNCTION: Calculate EMA with proper smoothing factor and initial SMA
function calculateEMA(array $closes, int $period): array {
    $ema = [];
    $multiplier = 2 / ($period + 1);
    
    // Start with SMA for the first EMA value
    $sma = array_sum(array_slice($closes, 0, $period)) / $period;
    $ema[$period - 1] = $sma;
    
    // Calculate EMA for subsequent values
    for ($i = $period; $i < count($closes); $i++) {
        $ema[$i] = ($closes[$i] * $multiplier) + ($ema[$i - 1] * (1 - $multiplier));
    }
    
    // Fill beginning with null (insufficient data)
    for ($i = 0; $i < $period - 1; $i++) {
        $ema[$i] = null;
    }
    
    return $ema;
}

// UPDATED FUNCTION: Calculate EMA 9 and EMA 89 (changed from EMA 5 and EMA 50 to EMA 9 and EMA 89)
function calculateEMA9EMA89(array $candleData): array {
    $results = [
        'ema9' => null,
        'ema89' => null,
        'last_ema9' => null,
        'last_ema89' => null,
        'debug_info' => []
    ];

    try {
        if (empty($candleData)) {
            throw new Exception("No candle data available");
        }

        // Extract and validate closing prices
        $closes = [];
        $timestamps = [];
        
        foreach ($candleData as $candle) {
            if (is_object($candle) && 
                property_exists($candle, 'close') && 
                $candle->close !== null && 
                is_numeric($candle->close) && 
                $candle->close > 0) {
                
                $closes[] = (float)$candle->close;
                $timestamps[] = is_string($candle->date) ? $candle->date : $candle->date->format('Y-m-d H:i:s');
            }
        }

        $results['debug_info']['total_candles'] = count($candleData);
        $results['debug_info']['valid_closes'] = count($closes);
        $results['debug_info']['first_timestamp'] = !empty($timestamps) ? $timestamps[0] : 'none';
        $results['debug_info']['last_timestamp'] = !empty($timestamps) ? end($timestamps) : 'none';

        // Check if we have enough data
        if (count($closes) < 89) {
            throw new Exception(sprintf(
                "Insufficient valid data for EMA 89: %d valid closes (need %d), total candles: %d",
                count($closes),
                89,
                count($candleData)
            ));
        }

        // Calculate EMAs
        logMsg("Calculating EMA 9 with " . count($closes) . " closing prices");
        $ema9Data = calculateEMA($closes, 9);
        
        logMsg("Calculating EMA 89 with " . count($closes) . " closing prices");
        $ema89Data = calculateEMA($closes, 89);

        // Get the last valid values
        $lastEma9 = null;
        $lastEma89 = null;
        
        for ($i = count($ema9Data) - 1; $i >= 0; $i--) {
            if ($ema9Data[$i] !== null && $lastEma9 === null) {
                $lastEma9 = $ema9Data[$i];
            }
            if ($ema89Data[$i] !== null && $lastEma89 === null) {
                $lastEma89 = $ema89Data[$i];
            }
            if ($lastEma9 !== null && $lastEma89 !== null) {
                break;
            }
        }
        
        $results['ema9'] = $ema9Data;
        $results['ema89'] = $ema89Data;
        $results['last_ema9'] = $lastEma9;
        $results['last_ema89'] = $lastEma89;
        
        // Store some sample values for debugging
        $results['debug_info']['last_10_closes'] = array_slice($closes, -10);
        $results['debug_info']['last_5_ema9'] = array_slice(array_filter($ema9Data, function($v) { return $v !== null; }), -5);
        $results['debug_info']['last_5_ema89'] = array_slice(array_filter($ema89Data, function($v) { return $v !== null; }), -5);
        
        logMsg(sprintf("EMA Calculation Complete - EMA9: %.2f, EMA89: %.2f", $lastEma9, $lastEma89));
        
    } catch (Exception $e) {
        logMsg("EMA 9/89 Calculation Error: " . $e->getMessage(), "ERROR");
        $results['error'] = $e->getMessage();
    }

    return $results;
}

// UPDATED FUNCTION: EMA 9 and EMA 89 crossover detection (changed from EMA 5 and EMA 50 to EMA 9 and EMA 89)
function checkEMA9EMA89Crossover(array $ema9Data, array $ema89Data): array {
    $result = [
        'crossed_above' => false,
        'crossed_below' => false,
        'current_ema9' => null,
        'current_ema89' => null,
        'previous_ema9' => null,
        'previous_ema89' => null,
        'valid' => false,
        'debug' => []
    ];
    
    if (empty($ema9Data) || empty($ema89Data)) {
        return $result;
    }

    // Find the last two valid EMA pairs (non-null values)
    $lastValid = [];
    
    for ($i = count($ema9Data) - 1; $i >= 0; $i--) {
        if ($ema9Data[$i] !== null && $ema89Data[$i] !== null) {
            $lastValid[] = [
                'ema9' => $ema9Data[$i],
                'ema89' => $ema89Data[$i],
                'index' => $i
            ];
            
            if (count($lastValid) >= 2) {
                break;
            }
        }
    }
    
    if (count($lastValid) < 2) {
        $result['debug']['error'] = "Insufficient valid EMA pairs found: " . count($lastValid);
        return $result;
    }
    
    $current = $lastValid[0];
    $previous = $lastValid[1];
    
    $result['current_ema9'] = $current['ema9'];
    $result['current_ema89'] = $current['ema89'];
    $result['previous_ema9'] = $previous['ema9'];
    $result['previous_ema89'] = $previous['ema89'];
    $result['valid'] = true;
    
    // Calculate differences
    $currentDiff = $current['ema9'] - $current['ema89'];
    $previousDiff = $previous['ema9'] - $previous['ema89'];
    
    // Calculate percentage changes
    $ema9_change = 0;
    $ema89_change = 0;
    
    if ($previous['ema9'] != 0) {
        $ema9_change = (($current['ema9'] - $previous['ema9']) / $previous['ema9']) * 100;
    }
    
    if ($previous['ema89'] != 0) {
        $ema89_change = (($current['ema89'] - $previous['ema89']) / $previous['ema89']) * 100;
    }
    
    // Check for crossover with tolerance
    $tolerance = 0.0001; // Small tolerance to avoid floating point issues
    
    $result['crossed_above'] = ($previousDiff <= $tolerance) && ($currentDiff > $tolerance);
    $result['crossed_below'] = ($previousDiff >= -$tolerance) && ($currentDiff < -$tolerance);
    
    $result['debug'] = [
        'current_diff' => $currentDiff,
        'previous_diff' => $previousDiff,
        'ema9_change' => $ema9_change,
        'ema89_change' => $ema89_change,
        'current_index' => $current['index'],
        'previous_index' => $previous['index'],
        'tolerance' => $tolerance
    ];
    
    return $result;
}

// UPDATED FUNCTION: Print EMA 9 and EMA 89 values (changed from EMA 5 and EMA 50 to EMA 9 and EMA 89)
function printEMAValues($indexName, $emaCrossover, $emaResults = null) {
    if (!$emaCrossover['valid']) {
        logMsg("$indexName: No valid EMA 9/89 crossover data available");
        return;
    }
    
    $ema9 = $emaCrossover['current_ema9'];
    $ema89 = $emaCrossover['current_ema89'];
    $prevEma9 = $emaCrossover['previous_ema9'];
    $prevEma89 = $emaCrossover['previous_ema89'];
    
    $position = $ema9 > $ema89 ? "ABOVE" : "BELOW";
    $difference = abs($ema9 - $ema89);
    $percentageDiff = ($difference / $ema89) * 100;
    
    logMsg("$indexName: EMA9=$ema9, EMA89=$ema89");
    logMsg("$indexName: Previous - EMA9=$prevEma9, EMA89=$prevEma89");
    logMsg("$indexName: EMA9 is $position EMA89 (Diff: $difference, " . number_format($percentageDiff, 2) . "%)");
    logMsg("$indexName: Crossed Above: " . ($emaCrossover['crossed_above'] ? "YES" : "NO") . 
          ", Crossed Below: " . ($emaCrossover['crossed_below'] ? "YES" : "NO"));
    
    // FIX: Calculate EMA changes safely and add to debug info
    $ema9_change = 0;
    $ema89_change = 0;
    
    if ($prevEma9 !== null && $ema9 !== null && $prevEma9 != 0) {
        $ema9_change = (($ema9 - $prevEma9) / $prevEma9) * 100;
    }
    
    if ($prevEma89 !== null && $ema89 !== null && $prevEma89 != 0) {
        $ema89_change = (($ema89 - $prevEma89) / $prevEma89) * 100;
    }
    
    // FIX: Use number_format only with valid numbers
    logMsg("$indexName: Debug - EMA9 Change: " . number_format($ema9_change, 4) . 
          "%, EMA89 Change: " . number_format($ema89_change, 4) . "%");
    
    // Print EMA calculation debug info if available
    if ($emaResults && isset($emaResults['debug_info'])) {
        $debugInfo = $emaResults['debug_info'];
        logMsg("$indexName: EMA Calc - Total: {$debugInfo['total_candles']}, Valid: {$debugInfo['valid_closes']}");
    }
}

// FIXED FUNCTION: Enhanced performDataQualityCheck with DateTime safety
function performDataQualityCheck(array $candleData, string $indexName): array {
    $check = [
        'total_candles' => count($candleData),
        'valid_candles' => 0,
        'invalid_candles' => 0,
        'date_range' => [],
        'close_prices' => [],
        'issues' => []
    ];
    
    if (empty($candleData)) {
        $check['issues'][] = 'No candle data available';
        return $check;
    }
    
    $timestamps = [];
    $closes = [];
    
    foreach ($candleData as $i => $candle) {
        if (!is_object($candle)) {
            $check['invalid_candles']++;
            $check['issues'][] = "Candle $i is not an object";
            continue;
        }
        
        // Safe timestamp extraction
        $timestamp = '';
        if (is_string($candle->date)) {
            $timestamp = $candle->date;
        } elseif (property_exists($candle, 'date') && $candle->date instanceof DateTime) {
            $timestamp = $candle->date->format('Y-m-d H:i:s');
        } else {
            $timestamp = 'unknown';
        }
        
        if (!property_exists($candle, 'close') || $candle->close === null) {
            $check['invalid_candles']++;
            $check['issues'][] = "Candle $i ($timestamp) has null close";
            continue;
        }
        
        if (!is_numeric($candle->close) || $candle->close <= 0) {
            $check['invalid_candles']++;
            $check['issues'][] = "Candle $i ($timestamp) has invalid close: " . $candle->close;
            continue;
        }
        
        $check['valid_candles']++;
        $timestamps[] = $timestamp;
        $closes[] = $candle->close;
    }
    
    if (!empty($timestamps)) {
        $check['date_range'] = [
            'first' => $timestamps[0],
            'last' => end($timestamps)
        ];
    }
    
    if (!empty($closes)) {
        $check['close_prices'] = [
            'min' => min($closes),
            'max' => max($closes),
            'current' => end($closes)
        ];
    }
    
    // Check for sufficient data
    if ($check['valid_candles'] < 89) {
        $check['issues'][] = "Insufficient valid candles for EMA 89: {$check['valid_candles']} (need 89)";
    }
    
    // Check for data gaps
    if (count($timestamps) > 1) {
        $expectedInterval = 300; // 5 minutes in seconds
        $gapCount = 0;
        
        for ($i = 1; $i < count($timestamps); $i++) {
            $time1 = strtotime($timestamps[$i-1]);
            $time2 = strtotime($timestamps[$i]);
            
            if ($time1 !== false && $time2 !== false) {
                $diff = $time2 - $time1;
                if ($diff > $expectedInterval * 2) { // Allow some tolerance
                    $gapCount++;
                }
            }
        }
        
        if ($gapCount > 0) {
            $check['issues'][] = "Found $gapCount potential data gaps in timeline";
        }
    }
    
    return $check;
}

// ----------------- NEW FUNCTION: Get readable stage for debugging -----------------
function getCrossoverStage($event): string {
    if (!$event['high_low_checked']) {
        return "WAITING_FOR_1MIN_CANDLE";
    } elseif (!$event['breakout_checked']) {
        return "WAITING_FOR_BREAKOUT";
    } elseif (!$event['symbol_created']) {
        return "CREATING_SYMBOL";
    } else {
        return "READY_FOR_ORDER";
    }
}

// ----------------- NEW FUNCTION: Enhanced crossover event processing with proper tracking and enabled check -----------------
function processCrossoverEvents($conn, $kite, $indices, $lotSizes, $exchangeMap, $instTableMap, $config, &$crossoverEvents, $indicesEnabled) {
    $now = new DateTime();
    $processedAny = false;
    
    foreach ($indices as $index) {
        $indexName = $index['name'];
        
        // CHECK IF TRADING IS ENABLED FOR THIS INDEX
        if (!isset($indicesEnabled[$indexName]) || !$indicesEnabled[$indexName]) {
            // Skip processing events for disabled indices
            foreach (['CE', 'PE'] as $dir) {
                $crossoverKey = $indexName . '_' . $dir;
                if (isset($crossoverEvents[$crossoverKey])) {
                    unset($crossoverEvents[$crossoverKey]);
                    logMsg("Removed crossover event for disabled index: $crossoverKey");
                }
            }
            continue;
        }
        
        // Process existing crossover events for this index
        foreach (['CE', 'PE'] as $dir) {
            $crossoverKey = $indexName . '_' . $dir;
            
            if (isset($crossoverEvents[$crossoverKey]) && 
                !$crossoverEvents[$crossoverKey]['completed']) {
                
                $event = &$crossoverEvents[$crossoverKey];
                $processed = processSingleCrossoverEvent($conn, $kite, $index, $dir, $event, $lotSizes, $exchangeMap, $instTableMap, $config, $now);
                
                if ($processed) {
                    $processedAny = true;
                }
                
                // Log failure reason if event completed with failure
                if ($event['completed'] && !$event['success'] && isset($event['failure_reason'])) {
                    logMsg("❌ CROSSOVER EVENT FAILED: $crossoverKey - Reason: " . $event['failure_reason'], "WARNING");
                }
            }
        }
    }
    
    return $processedAny;
}

// ----------------- FIXED MAIN LOGIC -----------------
logMsg("🚀 Starting EMA 9/89 crossover trading system");
ob_start(); // Start output buffering

// Track crossover events for each index
$crossoverEvents = [];
$mainCycleCount = 0;

while (true) {
    try {
        $mainCycleCount++;
        $now = new DateTime();
        logMsg("=== CYCLE $mainCycleCount STARTED ===");
        
        // Process each index for EMA crossover detection
        foreach ($indices as $index) {
            $indexName = $index['name'];
            
            // CHECK IF TRADING IS ENABLED FOR THIS INDEX
            if (!isset($indicesEnabled[$indexName]) || !$indicesEnabled[$indexName]) {
                logMsg("⏭️ SKIPPED: Trading disabled for $indexName");
                continue;
            }
            
            logMsg("🔍 Processing $indexName for EMA crossover detection");
            
            // Fetch historical data for 5-minute timeframe
            logMsg("📊 Fetching 5-min candle data for $indexName...");
            $candleData = fetchHistoricalDataForIndex($kite, $conn, $index, $now, ['5minute']);
            
            if (!isset($candleData['5minute']) || empty($candleData['5minute'])) {
                logMsg("❌ No 5min candle data available for $indexName", "ERROR");
                continue;
            }
            
            // Calculate EMA 9 and EMA 89 for 5-min timeframe
            logMsg("📈 Calculating EMA 9 and EMA 89 for $indexName...");

            // Perform data quality check first
            $dataQuality = performDataQualityCheck($candleData['5minute'], $indexName);
            logMsg("📋 Data Quality Check - Total: {$dataQuality['total_candles']}, Valid: {$dataQuality['valid_candles']}, Invalid: {$dataQuality['invalid_candles']}");

            if (!empty($dataQuality['issues'])) {
                foreach ($dataQuality['issues'] as $issue) {
                    logMsg("⚠️ Data Issue: $issue", "WARNING");
                }
            }

            if ($dataQuality['valid_candles'] < 89) {
                logMsg("❌ Insufficient valid candles for EMA calculation: {$dataQuality['valid_candles']} (need 89)", "ERROR");
                continue;
            }

            $emaResults = calculateEMA9EMA89($candleData['5minute']);

            if ($emaResults['ema9'] === null || $emaResults['ema89'] === null) {
                logMsg("❌ Failed to calculate EMA 9/89 for $indexName", "ERROR");
                if (isset($emaResults['error'])) {
                    logMsg("Error details: " . $emaResults['error'], "ERROR");
                }
                continue;
            }

            // Check EMA 9 and EMA 89 crossover
            $emaCrossover = checkEMA9EMA89Crossover($emaResults['ema9'], $emaResults['ema89']);

    // Print EMA values for monitoring with enhanced details
printEMAValues($indexName, $emaCrossover, $emaResults);

// ========== ALWAYS CHECK FOR REVERSAL ON EXISTING POSITIONS ==========
// This should run EVERY CYCLE, not just when there's a new crossover
logMsg("🔄 ========== STARTING REVERSAL CHECK for $indexName ==========");

// Debug: Show current active positions before checking
debugActivePositions($conn, $indexName);

// Check if EMA calculation is valid before proceeding
if ($emaCrossover['valid']) {
    logMsg("✅ EMA data valid for reversal check - Current EMA9: {$emaCrossover['current_ema9']}, EMA89: {$emaCrossover['current_ema89']}");
    
    // Always check reversal for existing positions
    // Always check reversal for existing positions AND trigger opposite trades
checkEMAReversalAndUpdateSellNow($conn, $kite, $indexName, $emaCrossover, $config['test_mode'], $crossoverEvents, $now);
} else {
    logMsg("⚠️ EMA data not valid for reversal check - skipping this cycle");
}

logMsg("🔄 ========== REVERSAL CHECK COMPLETE for $indexName ==========");
            
            // Check for new EMA crossover events
            if ($emaCrossover['crossed_above'] || $emaCrossover['crossed_below']) {
                $direction = $emaCrossover['crossed_above'] ? 'CE' : 'PE';
                $crossoverKey = $indexName . '_' . $direction;
                
                // If this is a new crossover event, record it
                if (!isset($crossoverEvents[$crossoverKey]) || 
                    $crossoverEvents[$crossoverKey]['completed'] === true) {
                    
                    $candleCompletionTime = getCurrent1MinCandleCompletionTime($now);
                    
                    $crossoverEvents[$crossoverKey] = [
                        'direction' => $direction,
                        'crossover_time' => clone $now,
                        'candle_completion_time' => $candleCompletionTime,
                        'completed' => false,
                        'high_low_checked' => false,
                        'symbol_created' => false,
                        'symbol' => null,
                        'instrument_id' => null,
                        'breakout_level' => null,
                        'high_low_retry_count' => 0,
                        'max_high_low_retries' => 10,
                        'breakout_checked' => false,
                        'breakout_timeout' => null,
                        'candle_high' => null,
                        'candle_low' => null,
                        'success' => false,
                        'failure_reason' => null
                    ];
                    
                    logMsg("🎯 NEW EMA 9/89 CROSSOVER DETECTED: $indexName $direction at " . 
                          $now->format('H:i:s') . " - Waiting for 1-min candle completion at " . 
                          $candleCompletionTime->format('H:i:s'));
                }
            }
        }
        
        // ========== PROCESS ALL CROSSOVER EVENTS INDEPENDENTLY ==========
        logMsg("🔄 Processing all crossover events...");
        $eventsProcessed = processCrossoverEvents($conn, $kite, $indices, $lotSizes, $exchangeMap, $instTableMap, $config, $crossoverEvents, $indicesEnabled);
        
        if ($eventsProcessed) {
            logMsg("✅ Successfully processed crossover events in this cycle");
        }
        
        // Clean up old completed events (older than 30 minutes)
        foreach ($crossoverEvents as $key => $event) {
            if ($event['completed'] && ($now->getTimestamp() - $event['crossover_time']->getTimestamp() > 1800)) {
                unset($crossoverEvents[$key]);
                logMsg("🧹 Cleaned up completed crossover event: $key");
            }
        }
        
        logMsg("=== CYCLE $mainCycleCount COMPLETE ===");
        logMsg("📊 Active crossover events: " . count(array_filter($crossoverEvents, function($e) { return !$e['completed']; })));
        logMsg("💤 Sleeping for " . $config['sleep_interval'] . " seconds");
        
        // Force flush every 5 cycles to manage memory
        if ($mainCycleCount % 5 === 0) {
            manageOutputBuffer(true);
        }
        
        sleep($config['sleep_interval']);
        
    } catch (Exception $e) {
        logMsg("❌ Error in main loop: " . $e->getMessage(), "ERROR");
        logMsg("Stack trace: " . $e->getTraceAsString(), "ERROR");
        sleep($config['sleep_interval']);
    }
}

Your Access Expired	Date. in : 10-02-2026
Regist : 09-12-2024	Expired : 01-12-2027