Convert pinescript to mq5

//@version=5
indicator("JLC Trend Indicator", overlay=true)

// Define input parameters
DosVelas = input(true, title="Dos Velas")
Bullish_Momentum = input(true, title="Bullish Momentum")
Bearish_Momentum = input(true, title="Bearish Momentum")
Bull_Threshold = input(60, title="Bull Threshold")
End_Bull_Threshold = input(60, title="End of Bull Threshold")
Bear_Threshold = input(40, title="Bear Threshold")
End_Bear_Threshold = input(40, title="End of Bear Threshold")

// Variables for Bullish Momentum
var float BULLlll = na
var float BULLhhh = na
var int BULLTJLC = na
var int BULLRISKUPJLC = na
var int BULLRISKDNJLC = na

// Variables for Bearish Momentum
var float BEARlll = na
var float BEARhhh = na
var int BEARTJLC = na
var int BEARRISKUPJLC = na
var int BEARRISKDNJLC = na

RSIHA = ta.rsi(close, 14)

// Logic for Bearish Momentum condition
if Bearish_Momentum
    if DosVelas
        if not na(RSIHA[2]) and RSIHA[2] > Bear_Threshold and RSIHA[1] < Bear_Threshold and RSIHA < Bear_Threshold
            BEARlll := math.min(low[1], low)
            BEARRISKUPJLC := 1
        if BEARRISKUPJLC == 1 and close < BEARlll
            BEARRISKUPJLC := 0
            BEARTJLC := 1
    else
        if not na(RSIHA[2]) and RSIHA[1] > Bear_Threshold and RSIHA < Bear_Threshold
            BEARTJLC := 1

    if not na(RSIHA[2]) and RSIHA[2] < End_Bear_Threshold and RSIHA[1] > End_Bear_Threshold and RSIHA > End_Bear_Threshold
        BEARhhh := math.max(high[1], high)
        BEARRISKDNJLC := 1
    if BEARRISKDNJLC == 1 and close > BEARhhh
        BEARRISKDNJLC := 0
        BEARTJLC := 0

// Logic for Bullish Momentum condition
if Bullish_Momentum
    if DosVelas
        if not na(RSIHA[2]) and RSIHA[2] < Bull_Threshold and RSIHA[1] > Bull_Threshold and RSIHA > Bull_Threshold
            BULLhhh := math.max(high[1], high)
            BULLRISKUPJLC := 1
        if BULLRISKUPJLC == 1 and close < BULLhhh
            BULLRISKUPJLC := 0
            BULLTJLC := 1
    else
        if not na(RSIHA[2]) and RSIHA[1] < Bull_Threshold and RSIHA > Bull_Threshold
            BULLTJLC := 1

    if not na(RSIHA[2]) and RSIHA[2] > End_Bull_Threshold and RSIHA[1] < End_Bull_Threshold and RSIHA < End_Bull_Threshold
        BULLlll := math.min(low[1], low)
        BULLRISKDNJLC := 1
    if BULLRISKDNJLC == 1 and close > BULLlll
        BULLRISKDNJLC := 0
        BULLTJLC := 0

// Plot TJLC as a red or green histogram
barcolor(BEARTJLC == 1 ? color.new(color.red, 80) : na)
barcolor(BULLTJLC == 1 ? color.new(color.lime, 80) : na)

// Output TJLC to show in the data window
plot(BEARTJLC, title="JLC Bear Trend Indicator", color=color.new(color.red, 0), style=plot.style_histogram)
plot(BULLTJLC, title="JLC Bull Trend Indicator", color=color.new(color.lime, 0), style=plot.style_histogram)

My attempt at MQ5:

//+------------------------------------------------------------------+
//|                                         JLC Trend Indicator.mq5   |
//|                                            https://www.mql5.com |
//+------------------------------------------------------------------+


#property version   "1.00"
#property indicator_separate_window

#property indicator_buffers 4
#property indicator_plots 4

#property indicator_type1 DRAW_HISTOGRAM
#property indicator_style1 STYLE_SOLID
#property indicator_width1 1
#property indicator_color1 clrRed
#property indicator_label1 "Bear Trend"

#property indicator_type2 DRAW_HISTOGRAM
#property indicator_style2 STYLE_SOLID
#property indicator_width2 1
#property indicator_color2 clrLime
#property indicator_label2 "Bull Trend"

#property indicator_type3 DRAW_NONE
#property indicator_label3 "BEARTJLC"

#property indicator_type4 DRAW_NONE
#property indicator_label4 "BULLTJLC"

double BearTrendBuffer[];
double BullTrendBuffer[];
double BEARTJLCBuffer[];
double BULLTJLCBuffer[];

int RSI_handle;
double RSI[];

input bool DosVelas = true;
input bool Bullish_Momentum = true;
input bool Bearish_Momentum = true;
input int Bull_Threshold = 60;
input int End_Bull_Threshold = 60;
input int Bear_Threshold = 40;
input int End_Bear_Threshold = 40;

// Variables to apply the logic
double BULLlll, BULLhhh;
double BEARlll, BEARhhh;
int BULLTJLC, BULLRISKUPJLC, BULLRISKDNJLC;
int BEARTJLC, BEARRISKUPJLC, BEARRISKDNJLC;

//+------------------------------------------------------------------+
//| Custom indicator initialization function                         |
//+------------------------------------------------------------------+
int OnInit()
  {
// Indicator buffers
   SetIndexBuffer(0, BearTrendBuffer);
   PlotIndexSetDouble(0, PLOT_EMPTY_VALUE, EMPTY_VALUE);
   SetIndexBuffer(1, BullTrendBuffer);
   PlotIndexSetDouble(1, PLOT_EMPTY_VALUE, EMPTY_VALUE);
   SetIndexBuffer(2, BEARTJLCBuffer);
   PlotIndexSetDouble(2, PLOT_EMPTY_VALUE, EMPTY_VALUE);
   SetIndexBuffer(3, BULLTJLCBuffer);
   PlotIndexSetDouble(3, PLOT_EMPTY_VALUE, EMPTY_VALUE);

// Handle for RSI
   RSI_handle = iRSI(NULL, 0, 14, PRICE_CLOSE);
   if(RSI_handle < 0)
     {
      Print("Error creating RSI handle: ", GetLastError());
      return (INIT_FAILED);
     }

   return (INIT_SUCCEEDED);
  }

//+------------------------------------------------------------------+
//| Custom indicator iteration function                              |
//+------------------------------------------------------------------+
int OnCalculate(const int rates_total,
                const int prev_calculated,
                const datetime &time[],
                const double &open[],
                const double &high[],
                const double &low[],
                const double &close[],
                const long &tick_volume[],
                const long &volume[],
                const int &spread[])
  {
// Check if RSI has been calculated
   if(BarsCalculated(RSI_handle) <= 0)
      return (0);

// Copy RSI values
   if(CopyBuffer(RSI_handle, 0, 0, rates_total, RSI) <= 0)
      return (0);

   int limit = rates_total - prev_calculated;
   if(prev_calculated > 0)
      limit++;

// Set series configuration
   ArraySetAsSeries(RSI, true);
   ArraySetAsSeries(BearTrendBuffer, true);
   ArraySetAsSeries(BullTrendBuffer, true);
   ArraySetAsSeries(BEARTJLCBuffer, true);
   ArraySetAsSeries(BULLTJLCBuffer, true);

   for(int i = limit + 1; i >= 2; i++)
     {
      BearTrendBuffer[i] = EMPTY_VALUE;
      BullTrendBuffer[i] = EMPTY_VALUE;
      BEARTJLCBuffer[i] = EMPTY_VALUE;
      BULLTJLCBuffer[i] = EMPTY_VALUE;

      // Reset trend variables
      BEARTJLC = 0;
      BULLTJLC = 0;

      // Bearish Momentum logic
      if(Bearish_Momentum)
        {
         if(DosVelas)
           {
            if(RSI[i+2] > Bear_Threshold && RSI[i+1] < Bear_Threshold && RSI[i] < Bear_Threshold)
              {
               BEARlll = MathMin(low[i+1], low[i]);
               BEARRISKUPJLC = 1;
              }
            if(BEARRISKUPJLC == 1 && close[i] < BEARlll)
              {
               BEARRISKUPJLC = 0;
               BEARTJLC = 1;
              }
           }
         else
           {
            if(RSI[i+1] > Bear_Threshold && RSI[i] < Bear_Threshold)
               BEARTJLC = 1;
           }

         if(RSI[i+2] < End_Bear_Threshold && RSI[i+1] > End_Bear_Threshold && RSI[i] > End_Bear_Threshold)
           {
            BEARhhh = MathMax(high[i+1], high[i]);
            BEARRISKDNJLC = 1;
           }
         if(BEARRISKDNJLC == 1 && close[i] > BEARhhh)
           {
            BEARRISKDNJLC = 0;
            BEARTJLC = 0;
           }
        }

      // Bullish Momentum logic
      if(Bullish_Momentum)
        {
         if(DosVelas)
           {
            if(RSI[i-2] < Bull_Threshold && RSI[i-1] > Bull_Threshold && RSI[i] > Bull_Threshold)
              {
               BULLhhh = MathMax(high[i+1], high[i]);
               BULLRISKUPJLC = 1;
              }
            if(BULLRISKUPJLC == 1 && close[i] < BULLhhh)
              {
               BULLRISKUPJLC = 0;
               BULLTJLC = 1;
              }
           }
         else
           {
            if(RSI[i+1] < Bull_Threshold && RSI[i] > Bull_Threshold)
               BULLTJLC = 1;
           }

         if(RSI[i+2] > End_Bull_Threshold && RSI[i+1] < End_Bull_Threshold && RSI[i] < End_Bull_Threshold)
           {
            BULLlll = MathMin(low[i+1], low[i]);
            BULLRISKDNJLC = 1;
           }
         if(BULLRISKDNJLC == 1 && close[i] > BULLlll)
           {
            BULLRISKDNJLC = 0;
            BULLTJLC = 0;
           }
        }



      // Set buffers
      if(BEARTJLC == 1)
         BearTrendBuffer[i] = 1;
      else
         BearTrendBuffer[i] = 0;

      if(BULLTJLC == 1)
         BullTrendBuffer[i] = 1;
      else
         BullTrendBuffer[i] = 0;

      BEARTJLCBuffer[i] = BEARTJLC;
      BULLTJLCBuffer[i] = BULLTJLC;
     }

   return (rates_total);
  }
//+------------------------------------------------------------------+