//+------------------------------------------------------------------+
//|                         Scalping Robot - Neural Network Enhanced |
//+------------------------------------------------------------------+
#property copyright "Copyright 2024, MetaQuotes Ltd."
#property link      "https://www.mql5.com"
#property version   "2.00"

#include <Trade/Trade.mqh>
#include <Matrix.mqh>
#include <Neural Network.mqh>

// Declarar objetos para negociação
CTrade trade;
CPositionInfo pos;
COrderInfo ord;

// Entradas da estratégia original
input group "*** Trading Inputs ***"
input double LotSize             = 0.01;  // Lot size for trading
input int    Tppoints            = 800;   // Take Profit (10 points = 1 pip)
input int    Slpoints            = 800;   // Stoploss Points (10 points = 1 pip)
input int    TslTriggerPoints    = 35;    // Trailing Stop Trigger (10 points = 1 pip)
input int    TslPoints           = 10;    // Trailing Stoploss (10 points = 1 pip)
input ENUM_TIMEFRAMES Timeframe  = PERIOD_CURRENT; // Timeframe to trade
input int    InpMagic            = 891245; // Magic Number
input string TradeComment        = "Wendel Cassiano";
input int    MaxSpread           = 100;   // Maximum spread allowed (in points)
input int    Slippage            = 50;    // Slippage in points
input int    MaxOrders           = 2;     // Maximum simultaneous orders
input int    BarsN               = 5;     // Period to evaluate High/Low
input int    ExpirationBars      = 100;   // Expiration time for pending orders (in bars)
input int    OrderDistPoints     = 100;   // Distance from current price for orders

// Entradas da rede neural
input group "NEURAL NETWORK INPUTS"
input int    UsedBars            = 1000;  // Historical bars used for training
input double LearningRate        = 0.04;
input int    Epochs              = 100;   // Training epochs
input double ProbThreshold        = 0.55;  // Probability threshold for decisions
input int    RandomSeed          = 42;    // Random seed for reproducibility

NeuralNetwork nn; // Objeto da rede neural
vector NeuralPrediction;

// Variáveis de controle
datetime previousBarTime = 0; // Controla se há um novo candle
bool NNTrained = false;       // Rede Neural foi treinada?

//+------------------------------------------------------------------+
//| Expert initialization function                                   |
//+------------------------------------------------------------------+
int OnInit()
{
    trade.SetExpertMagicNumber(InpMagic);
    ChartSetInteger(0, CHART_SHOW_GRID, false);

    // Inicializar a rede neural
    nn.Initialize(_Symbol, Timeframe, UsedBars, LearningRate, Epochs, RandomSeed);
    Print("Rede Neural inicializada com configuração padrão!");

    return(INIT_SUCCEEDED);
}
//+------------------------------------------------------------------+
//| Expert tick function                                             |
//+------------------------------------------------------------------+
void OnTick()
{
    // Garantir que a rede neural foi treinada
    if (!NNTrained)
    {
        TrainNeuralNetwork();
        NNTrained = true;
        Print("Rede Neural treinada com sucesso!");
    }

    // Trailing Stop
    TrailStop();

    // Verificar se é um novo candle
    if (!IsNewBar()) return;

    // Verificar a janela de execução
    if (!IsWithinTradingHours()) { CloseAllOrders(); return; }

    // Verificar spread máximo
    double spread = (SymbolInfoDouble(_Symbol, SYMBOL_ASK) - SymbolInfoDouble(_Symbol, SYMBOL_BID)) / _Point;
    if (spread > MaxSpread) return;

    // Controlar total de ordens abertas
    if (CountOpenOrders() >= MaxOrders) return;

    // Tomar decisão com previsão da rede neural
    NeuralPrediction = nn.PredictCurrentMarket();

    if (NeuralPrediction[0] > ProbThreshold)
    {
        // Rede Neural sugere um sinal de compra
        double high = FindHigh();
        if (high > 0) SendBuyOrder(high);
    }
    else if (NeuralPrediction[1] > ProbThreshold)
    {
        // Rede Neural sugere um sinal de venda
        double low = FindLow();
        if (low > 0) SendSellOrder(low);
    }
}
//+------------------------------------------------------------------+
//| Funções auxiliares para estratégia                               |
//+------------------------------------------------------------------+
double FindHigh()
{
    double highestHigh = 0;
    for (int i = 0; i < BarsN; i++)
    {
        double high = iHigh(_Symbol, Timeframe, i);
        if (high > highestHigh) highestHigh = high;
    }
    return highestHigh;
}

double FindLow()
{
    double lowestLow = DBL_MAX;
    for (int i = 0; i < BarsN; i++)
    {
        double low = iLow(_Symbol, Timeframe, i);
        if (low < lowestLow) lowestLow = low;
    }
    return lowestLow;
}

void SendBuyOrder(double entry)
{
    double tp = entry + Tppoints * _Point;
    double sl = entry - Slpoints * _Point;
    datetime expiration = TimeCurrent() + ExpirationBars * PeriodSeconds(Timeframe);

    trade.BuyStop(LotSize, entry, _Symbol, sl, tp, ORDER_TIME_SPECIFIED, expiration, Slippage);
}

void SendSellOrder(double entry)
{
    double tp = entry - Tppoints * _Point;
    double sl = entry + Slpoints * _Point;
    datetime expiration = TimeCurrent() + ExpirationBars * PeriodSeconds(Timeframe);

    trade.SellStop(LotSize, entry, _Symbol, sl, tp, ORDER_TIME_SPECIFIED, expiration, Slippage);
}

void CloseAllOrders()
{
    for (int i = PositionsTotal() - 1; i >= 0; i--)
    {
        pos.SelectByIndex(i);
        if (pos.Magic() == InpMagic)
        {
            trade.PositionClose(pos.Ticket());
        }
    }
}

int CountOpenOrders()
{
    int count = 0;
    for (int i = PositionsTotal() - 1; i >= 0; i--)
    {
        pos.SelectByIndex(i);
        if (pos.Magic() == InpMagic) count++;
    }
    return count;
}

void TrailStop()
{
    for (int i = PositionsTotal() - 1; i >= 0; i--)
    {
        if (pos.SelectByIndex(i))
        {
            double price = pos.PositionType() == POSITION_TYPE_BUY ? SymbolInfoDouble(_Symbol, SYMBOL_BID) : SymbolInfoDouble(_Symbol, SYMBOL_ASK);
            double newSL = pos.PositionType() == POSITION_TYPE_BUY ? price - TslPoints * _Point : price + TslPoints * _Point;

            if (pos.PositionType() == POSITION_TYPE_BUY && newSL > pos.StopLoss())
                trade.PositionModify(pos.Ticket(), newSL, pos.TakeProfit());
            else if (pos.PositionType() == POSITION_TYPE_SELL && newSL < pos.StopLoss())
                trade.PositionModify(pos.Ticket(), newSL, pos.TakeProfit());
        }
    }
}

bool IsNewBar()
{
    datetime currentBarTime = iTime(_Symbol, Timeframe, 0);
    if (currentBarTime != previousBarTime)
    {
        previousBarTime = currentBarTime;
        return true;
    }
    return false;
}

bool IsWithinTradingHours()
{
    MqlDateTime time;
    TimeToStruct(TimeCurrent(), time);
    return (time.hour >= 10 && time.hour <= 18); // Ajusta os horários conforme necessário
}

//+------------------------------------------------------------------+
//| Funções da Rede Neural                                           |
//+------------------------------------------------------------------+
void TrainNeuralNetwork()
{
    nn.Train();
}

//+------------------------------------------------------------------+


preciso que tenha tambem placed  BUYSTOP

corrija e me entregue o codigo completo