//+------------------------------------------------------------------+
//| AssessPromotion.mq5 - DualEA Promotion Gate Evaluator           |
//| Comprehensive evaluation script for PaperEA → LiveEA promotion  |
//+------------------------------------------------------------------+
#property copyright "DualEA Promotion System"
#property version   "1.00"
#property strict

//+------------------------------------------------------------------+
//| INCLUDES                                                         |
//+------------------------------------------------------------------+
#include <Trade\Trade.mqh>
#include <Trade\PositionInfo.mqh>
#include <Trade\HistoryOrderInfo.mqh>
#include <Files\File.mqh>
// Removed ArrayObj since we use native arrays

//+------------------------------------------------------------------+
//| PROMOTION CRITERIA CONFIGURATION                                 |
//+------------------------------------------------------------------+
struct SPromotionCriteria
{
    // Minimum thresholds for promotion
    int    min_trades;           // Minimum number of trades required
    double min_hit_rate;         // Minimum win rate (0.0-1.0)
    double min_expectancy_r;     // Minimum expectancy in R-multiples
    double max_drawdown_pct;     // Maximum drawdown percentage
    double min_sharpe_ratio;     // Minimum Sharpe ratio
    double min_profit_factor;    // Minimum profit factor
    int    min_trading_days;     // Minimum trading days
    double min_avg_trade_r;      // Minimum average trade in R
    double max_consecutive_losses; // Maximum consecutive losses
    
    // Constructor with defaults
    SPromotionCriteria() : 
        min_trades(50),
        min_hit_rate(0.55),
        min_expectancy_r(0.2),
        max_drawdown_pct(15.0),
        min_sharpe_ratio(1.0),
        min_profit_factor(1.3),
        min_trading_days(30),
        min_avg_trade_r(0.1),
        max_consecutive_losses(10)
    {}
};

//+------------------------------------------------------------------+
//| TRADE STATISTICS STRUCTURE                                       |
//+------------------------------------------------------------------+
struct STradeStats
{
    int    total_trades;
    int    winning_trades;
    int    losing_trades;
    double hit_rate;
    double gross_profit;
    double gross_loss;
    double net_profit;
    double max_drawdown;
    double sharpe_ratio;
    double profit_factor;
    double expectancy_r;
    double avg_trade_r;
    int    consecutive_losses;
    int    trading_days;
    datetime first_trade;
    datetime last_trade;
    
    // Constructor
    STradeStats() : 
        total_trades(0), winning_trades(0), losing_trades(0), hit_rate(0.0),
        gross_profit(0.0), gross_loss(0.0), net_profit(0.0),
        max_drawdown(0.0), sharpe_ratio(0.0), profit_factor(0.0),
        expectancy_r(0.0), avg_trade_r(0.0), consecutive_losses(0),
        trading_days(0), first_trade(0), last_trade(0)
    {}
};

//+------------------------------------------------------------------+
//| PROMOTION RESULT STRUCTURE                                       |
//+------------------------------------------------------------------+
struct SPromotionResult
{
    bool   passed;
    string symbol;
    string timeframe;
    string failure_reason;
    STradeStats stats;
    SPromotionCriteria criteria;
    
    // Detailed pass/fail breakdown
    bool   trades_pass;
    bool   hit_rate_pass;
    bool   expectancy_pass;
    bool   drawdown_pass;
    bool   sharpe_pass;
    bool   profit_factor_pass;
    bool   trading_days_pass;
    bool   avg_trade_pass;
    bool   consecutive_losses_pass;
    
    SPromotionResult() : passed(false), trades_pass(false), hit_rate_pass(false),
                        expectancy_pass(false), drawdown_pass(false), sharpe_pass(false),
                        profit_factor_pass(false), trading_days_pass(false),
                        avg_trade_pass(false), consecutive_losses_pass(false) {}
};

//+------------------------------------------------------------------+
//| GLOBAL VARIABLES                                                 |
//+------------------------------------------------------------------+
SPromotionCriteria g_criteria;
string g_report_path = "DualEA\\promotion_report.txt";
string g_telemetry_path = "DualEA\\telemetry";

//+------------------------------------------------------------------+
//| SCRIPT ENTRY POINT                                               |
//+------------------------------------------------------------------+
void OnStart()
{
    Print("=== DualEA Promotion Assessment Starting ===");
    
    // Load criteria from config file if exists
    LoadPromotionCriteria();
    
    // Get all symbols and timeframes from telemetry
    string symbols[];
    int timeframes[];
    GetAvailableSymbolsTimeframes(symbols, timeframes);
    
    if(ArraySize(symbols) == 0)
    {
        Print("No telemetry data found. Ensure PaperEA has been running.");
        return;
    }
    
    // Process each symbol/timeframe combination
    SPromotionResult results[];
    for(int i = 0; i < ArraySize(symbols); i++)
    {
        for(int j = 0; j < ArraySize(timeframes); j++)
        {
            string symbol = symbols[i];
            int timeframe = timeframes[j];
            SPromotionResult r;
            if(EvaluatePromotion(symbol, timeframe, r))
            {
                int n = ArraySize(results);
                ArrayResize(results, n+1);
                results[n] = r;
            }
        }
    }
    
    // Generate comprehensive report
    GenerateReport(results);
    
    // No dynamic allocations used; nothing to cleanup
    
    Print("=== Promotion Assessment Complete ===");
}

//+------------------------------------------------------------------+
//| LOAD PROMOTION CRITERIA FROM CONFIG                              |
//+------------------------------------------------------------------+
void LoadPromotionCriteria()
{
    string config_path = "DualEA\\promotion_criteria.json";
    int handle = FileOpen(config_path, FILE_READ | FILE_COMMON | FILE_TXT | FILE_ANSI);
    
    if(handle != INVALID_HANDLE)
    {
        string content = "";
        while(!FileIsEnding(handle))
        {
            content += FileReadString(handle) + "\n";
        }
        FileClose(handle);
        
        // Parse JSON (basic implementation)
        ParseCriteriaFromJSON(content);
        Print("Loaded promotion criteria from config file");
    }
    else
    {
        Print("Using default promotion criteria");
    }
}

//+------------------------------------------------------------------+
//| PARSE CRITERIA FROM JSON                                         |
//+------------------------------------------------------------------+
void ParseCriteriaFromJSON(const string& json)
{
    // Basic JSON parsing - extract key values
    string key;
    
    key = "\"min_trades\":";
    int pos = StringFind(json, key);
    if(pos >= 0) g_criteria.min_trades = (int)StringToDouble(StringSubstr(json, pos + StringLen(key), 10));
    
    key = "\"min_hit_rate\":";
    pos = StringFind(json, key);
    if(pos >= 0) g_criteria.min_hit_rate = StringToDouble(StringSubstr(json, pos + StringLen(key), 10));
    
    key = "\"min_expectancy_r\":";
    pos = StringFind(json, key);
    if(pos >= 0) g_criteria.min_expectancy_r = StringToDouble(StringSubstr(json, pos + StringLen(key), 10));
    
    key = "\"max_drawdown_pct\":";
    pos = StringFind(json, key);
    if(pos >= 0) g_criteria.max_drawdown_pct = StringToDouble(StringSubstr(json, pos + StringLen(key), 10));
    
    key = "\"min_sharpe_ratio\":";
    pos = StringFind(json, key);
    if(pos >= 0) g_criteria.min_sharpe_ratio = StringToDouble(StringSubstr(json, pos + StringLen(key), 10));
    
    key = "\"min_profit_factor\":";
    pos = StringFind(json, key);
    if(pos >= 0) g_criteria.min_profit_factor = StringToDouble(StringSubstr(json, pos + StringLen(key), 10));
}

//+------------------------------------------------------------------+
//| GET AVAILABLE SYMBOLS AND TIMEFRAMES FROM TELEMETRY              |
//+------------------------------------------------------------------+
// Helper: add unique string to array
bool AddUniqueString(string &arr[], const string value)
{
    for(int i=0;i<ArraySize(arr);++i) if(arr[i]==value) return false;
    int n=ArraySize(arr); ArrayResize(arr,n+1); arr[n]=value; return true;
}

// Helper: add unique int to array
bool AddUniqueInt(int &arr[], const int value)
{
    for(int i=0;i<ArraySize(arr);++i) if(arr[i]==value) return false;
    int n=ArraySize(arr); ArrayResize(arr,n+1); arr[n]=value; return true;
}

void GetAvailableSymbolsTimeframes(string &symbols[], int &timeframes[])
  {
    string search_path = g_telemetry_path + "\\*.csv";
    // iterate files using FileFindFirst/Next
    string file;
    
    // Use Windows API to find files
    string path = TerminalInfoString(TERMINAL_COMMONDATA_PATH) + "\\" + search_path;
    
    // Scan directory for telemetry files
    long search_handle = FileFindFirst(path, file);
    if(search_handle != INVALID_HANDLE)
    {
        do
        {
            // Parse symbol and timeframe from filename format: SYMBOL_TF_YYYYMMDD.csv
            string parts[];
            int part_count = StringSplit(file, '_', parts);
            if(part_count >= 2)
            {
                string symbol = parts[0];
                int timeframe = (int)StringToInteger(parts[1]);
                
                // Add unique symbols and timeframes
                AddUniqueString(symbols, symbol);
                AddUniqueInt(timeframes, timeframe);
            }
        }
        while(FileFindNext(search_handle, file));
        FileFindClose(search_handle);
    }
  }

//+------------------------------------------------------------------+
//| EVALUATE PROMOTION FOR SPECIFIC SYMBOL/TIMEFRAME                 |
//+------------------------------------------------------------------+
bool EvaluatePromotion(const string symbol, const int timeframe, SPromotionResult &result)
  {
    result.symbol = symbol;
    result.timeframe = EnumToString((ENUM_TIMEFRAMES)timeframe);
    result.criteria = g_criteria;
    
    // Load trade history from telemetry
    if(!LoadTradeHistory(symbol, timeframe, result.stats))
    {
        return false;
    }
    
    // Evaluate each criterion
    EvaluateCriteria(result);
    
    // Determine overall pass/fail
    result.passed = result.trades_pass && result.hit_rate_pass && result.expectancy_pass && 
                    result.drawdown_pass && result.sharpe_pass && result.profit_factor_pass &&
                    result.trading_days_pass && result.avg_trade_pass && result.consecutive_losses_pass;
    
    if(!result.passed)
    {
        BuildFailureReason(result);
    }
    
    return true;
  }

//+------------------------------------------------------------------+
//| LOAD TRADE HISTORY FROM TELEMETRY                                |
//+------------------------------------------------------------------+
bool LoadTradeHistory(const string symbol, const int timeframe, STradeStats& stats)
  {
    string filename = StringFormat("%s\\%s_%d_telemetry.csv", g_telemetry_path, symbol, timeframe);
    string filepath = TerminalInfoString(TERMINAL_COMMONDATA_PATH) + "\\" + filename;
    
    int handle = FileOpen(filepath, FILE_READ | FILE_TXT | FILE_ANSI);
    if(handle == INVALID_HANDLE)
    {
        PrintFormat("No telemetry data for %s %s", symbol, EnumToString((ENUM_TIMEFRAMES)timeframe));
        return false;
    }
    
    // Skip header
    FileReadString(handle);
    
    double equity_curve[];
    double daily_returns[];
    int consecutive_losses = 0;
    int max_consecutive_losses = 0;
    
    while(!FileIsEnding(handle))
    {
        string line = FileReadString(handle);
        if(StringLen(line) < 10) continue;
        
        string fields[];
        int field_count = StringSplit(line, ',', fields);
        if(field_count < 10) continue;
        
        // Parse trade data
        string event_type = fields[4];
        if(event_type == "trade_close")
        {
            stats.total_trades++;
            
            double profit = StringToDouble(fields[7]);
            double risk_r = StringToDouble(fields[8]);
            
            if(profit > 0)
            {
                stats.winning_trades++;
                stats.gross_profit += profit;
                consecutive_losses = 0;
            }
            else
            {
                stats.losing_trades++;
                stats.gross_loss += MathAbs(profit);
                consecutive_losses++;
                max_consecutive_losses = MathMax(max_consecutive_losses, consecutive_losses);
            }
            
            // Track first/last trade times
            datetime trade_time = (datetime)StringToInteger(fields[0]);
            if(stats.first_trade == 0 || trade_time < stats.first_trade)
                stats.first_trade = trade_time;
            if(trade_time > stats.last_trade)
                stats.last_trade = trade_time;
            
            // Build equity curve for calculations
            int n = ArraySize(equity_curve);
            ArrayResize(equity_curve, n+1);
            equity_curve[n] = stats.gross_profit - stats.gross_loss;
        }
    }
    FileClose(handle);
    
    // Calculate derived statistics
    stats.net_profit = stats.gross_profit - stats.gross_loss;
    stats.consecutive_losses = max_consecutive_losses;
    
    if(stats.total_trades > 0)
    {
        stats.hit_rate = (double)stats.winning_trades / (double)stats.total_trades;
        stats.profit_factor = stats.gross_loss > 0 ? stats.gross_profit / stats.gross_loss : 999;
        
        // Calculate expectancy in R
        double total_r = 0;
        if(stats.winning_trades > 0 && stats.losing_trades > 0)
        {
            double avg_win = stats.gross_profit / stats.winning_trades;
            double avg_loss = stats.gross_loss / stats.losing_trades;
            stats.expectancy_r = (stats.hit_rate * avg_win) - ((1 - stats.hit_rate) * avg_loss);
            stats.avg_trade_r = stats.net_profit / stats.total_trades;
        }
        
        // Calculate max drawdown from equity curve
        if(ArraySize(equity_curve) > 0)
        {
            double peak = equity_curve[0];
            double max_dd = 0;
            for(int i = 0; i < ArraySize(equity_curve); i++)
            {
                double current = equity_curve[i];
                if(current > peak) peak = current;
                double dd = peak - current;
                if(dd > max_dd) max_dd = dd;
            }
            stats.max_drawdown = max_dd;
        }
        
        // Calculate Sharpe ratio (simplified)
        if(ArraySize(equity_curve) > 1)
        {
            double sum_returns = 0;
            double sum_sq_returns = 0;
            int return_count = 0;
            
            for(int i = 1; i < ArraySize(equity_curve); i++)
            {
                double ret = equity_curve[i] - equity_curve[i-1];
                sum_returns += ret;
                sum_sq_returns += ret * ret;
                return_count++;
            }
            
            if(return_count > 0)
            {
                double avg_return = sum_returns / return_count;
                double variance = (sum_sq_returns / return_count) - (avg_return * avg_return);
                if(variance > 0)
                {
                    stats.sharpe_ratio = avg_return / MathSqrt(variance);
                }
            }
        }
        
        // Calculate trading days
        if(stats.first_trade > 0 && stats.last_trade > 0)
        {
            stats.trading_days = (int)((stats.last_trade - stats.first_trade) / (24 * 3600));
        }
    }
    
    return true;
}

//+------------------------------------------------------------------+
//| EVALUATE PROMOTION CRITERIA                                      |
//+------------------------------------------------------------------+
void EvaluateCriteria(SPromotionResult &result)
  {
    result.trades_pass = result.stats.total_trades >= result.criteria.min_trades;
    result.hit_rate_pass = result.stats.hit_rate >= result.criteria.min_hit_rate;
    result.expectancy_pass = result.stats.expectancy_r >= result.criteria.min_expectancy_r;
    result.drawdown_pass = result.stats.max_drawdown <= result.criteria.max_drawdown_pct;
    result.sharpe_pass = result.stats.sharpe_ratio >= result.criteria.min_sharpe_ratio;
    result.profit_factor_pass = result.stats.profit_factor >= result.criteria.min_profit_factor;
    result.trading_days_pass = result.stats.trading_days >= result.criteria.min_trading_days;
    result.avg_trade_pass = result.stats.avg_trade_r >= result.criteria.min_avg_trade_r;
    result.consecutive_losses_pass = result.stats.consecutive_losses <= result.criteria.max_consecutive_losses;
  }

//+------------------------------------------------------------------+
//| BUILD FAILURE REASON STRING                                      |
//+------------------------------------------------------------------+
void BuildFailureReason(SPromotionResult &result)
  {
    string failures[];
    
    if(!result.trades_pass){int n=ArraySize(failures);ArrayResize(failures,n+1);failures[n]=StringFormat("Min trades: %d < %d", result.stats.total_trades, result.criteria.min_trades);}    
    if(!result.hit_rate_pass){int n=ArraySize(failures);ArrayResize(failures,n+1);failures[n]=StringFormat("Hit rate: %.2f%% < %.2f%%", result.stats.hit_rate * 100, result.criteria.min_hit_rate * 100);} 
    if(!result.expectancy_pass){int n=ArraySize(failures);ArrayResize(failures,n+1);failures[n]=StringFormat("Expectancy: %.2fR < %.2fR", result.stats.expectancy_r, result.criteria.min_expectancy_r);} 
    if(!result.drawdown_pass){int n=ArraySize(failures);ArrayResize(failures,n+1);failures[n]=StringFormat("Max DD: %.2f%% > %.2f%%", result.stats.max_drawdown, result.criteria.max_drawdown_pct);} 
    if(!result.sharpe_pass){int n=ArraySize(failures);ArrayResize(failures,n+1);failures[n]=StringFormat("Sharpe: %.2f < %.2f", result.stats.sharpe_ratio, result.criteria.min_sharpe_ratio);} 
    if(!result.profit_factor_pass){int n=ArraySize(failures);ArrayResize(failures,n+1);failures[n]=StringFormat("PF: %.2f < %.2f", result.stats.profit_factor, result.criteria.min_profit_factor);} 
    if(!result.trading_days_pass){int n=ArraySize(failures);ArrayResize(failures,n+1);failures[n]=StringFormat("Days: %d < %d", result.stats.trading_days, result.criteria.min_trading_days);} 
    if(!result.avg_trade_pass){int n=ArraySize(failures);ArrayResize(failures,n+1);failures[n]=StringFormat("Avg trade: %.2fR < %.2fR", result.stats.avg_trade_r, result.criteria.min_avg_trade_r);} 
    if(!result.consecutive_losses_pass){int n=ArraySize(failures);ArrayResize(failures,n+1);failures[n]=StringFormat("Consecutive losses: %d > %d", result.stats.consecutive_losses, result.criteria.max_consecutive_losses);} 
    
    // Build failure string
    for(int i = 0; i < ArraySize(failures); i++)
    {
        if(i > 0) result.failure_reason += "; ";
        result.failure_reason += failures[i];
    }
  }

//+------------------------------------------------------------------+
//| GENERATE COMPREHENSIVE REPORT                                    |
//+------------------------------------------------------------------+
void GenerateReport(SPromotionResult &results[])
  {
    string report_path = TerminalInfoString(TERMINAL_COMMONDATA_PATH) + "\\" + g_report_path;
    
    int handle = FileOpen(report_path, FILE_WRITE | FILE_TXT | FILE_ANSI);
    if(handle == INVALID_HANDLE)
    {
        Print("Failed to create promotion report");
        return;
    }
    
    FileWriteString(handle, "DUALEA PROMOTION ASSESSMENT REPORT\n");
    FileWriteString(handle, "=================================\n\n");
    FileWriteString(handle, StringFormat("Generated: %s\n", TimeToString(TimeCurrent())));
    FileWriteString(handle, StringFormat("Evaluation Period: %s to %s\n\n", 
        TimeToString(GetOldestTradeDate(results)), TimeToString(TimeCurrent())));
    
    int passed_count = 0;
    int total_count = ArraySize(results);
    
    for(int i = 0; i < total_count; i++)
    {
        SPromotionResult result = results[i];
        
        FileWriteString(handle, StringFormat("=== %s %s ===\n", result.symbol, result.timeframe));
        FileWriteString(handle, StringFormat("Status: %s\n", result.passed ? "PASS" : "FAIL"));
        
        if(result.passed) passed_count++;
        
        FileWriteString(handle, StringFormat("Total Trades: %d\n", result.stats.total_trades));
        FileWriteString(handle, StringFormat("Win Rate: %.2f%%\n", result.stats.hit_rate * 100));
        FileWriteString(handle, StringFormat("Expectancy: %.2fR\n", result.stats.expectancy_r));
        FileWriteString(handle, StringFormat("Max Drawdown: %.2f%%\n", result.stats.max_drawdown));
        FileWriteString(handle, StringFormat("Sharpe Ratio: %.2f\n", result.stats.sharpe_ratio));
        FileWriteString(handle, StringFormat("Profit Factor: %.2f\n", result.stats.profit_factor));
        FileWriteString(handle, StringFormat("Trading Days: %d\n", result.stats.trading_days));
        FileWriteString(handle, StringFormat("Avg Trade: %.2fR\n", result.stats.avg_trade_r));
        FileWriteString(handle, StringFormat("Consecutive Losses: %d\n", result.stats.consecutive_losses));
        
        if(!result.passed)
        {
            FileWriteString(handle, StringFormat("Failure Reasons: %s\n", result.failure_reason));
        }
        
        FileWriteString(handle, "\n");
    }
    
    FileWriteString(handle, StringFormat("\nSUMMARY: %d/%d combinations passed promotion criteria\n", 
        passed_count, total_count));
    FileWriteString(handle, StringFormat("Overall Status: %s\n", 
        passed_count == total_count && total_count > 0 ? "READY FOR LIVE" : "NOT READY"));
    
    FileClose(handle);
    
    Print(StringFormat("Promotion report generated: %s", report_path));
    Print(StringFormat("Summary: %d/%d combinations passed", passed_count, total_count));
}

//+------------------------------------------------------------------+
//| GET OLDEST TRADE DATE FROM RESULTS                               |
//+------------------------------------------------------------------+
datetime GetOldestTradeDate(SPromotionResult &results[])
  {
    datetime oldest = TimeCurrent();
    
    for(int i = 0; i < ArraySize(results); i++)
    {
        SPromotionResult result = results[i];
        if(result.stats.first_trade > 0 && result.stats.first_trade < oldest)
        {
            oldest = result.stats.first_trade;
        }
    }
    
    return oldest;
  }