//+------------------------------------------------------------------+
//|                                               FuncionesBases.mqh |
//|                                  Copyright 2025, Niquel Mendoza. |
//|                                             https://www.mql5.com |
//+------------------------------------------------------------------+
#property copyright "Copyright 2025, Niquel Mendoza."
#property link      "https://www.mql5.com"
#property strict

#ifndef FUNCTIONS_MQH
#define FUNCTIONS_MQH

#include <Generic\HashMap.mqh>
#include "StringToArray.mqh"

#define INVALID_INDEX -1
//+------------------------------------------------------------------+
//| Definiciones                                                     |
//+------------------------------------------------------------------+
const datetime wrong_datetime = 0;
double DOUBLE_ARRAY_EMPTY[];
string EMPTY_STRING = "";
vector EMPTY_VECTOR = {};

#define NOT_DEFINED_STRING "Not Defined"
#define UNDEFINED_REPLACE 1

enum idiomas
 {
  English,
  Spanish
 };

//+------------------------------------------------------------------+
//|                    Trabajo Con Arrays                            |
//+------------------------------------------------------------------+
template <typename T>
int ArrayCopyCts(T&        dst_array[],            // array de destino
                 const T&  src_array[],         // array de origen
                 int          dst_start = 0,       // índice inicial para copiar desde el array de origen
                 int          src_start = 0,       // primer índice del array de destino
                 int          count = WHOLE_ARRAY)  // número de elementos )
 {
  int src_size = ArraySize(src_array);
  int dst_size = ArraySize(dst_array);

//---
  if(src_start < 0 || src_start >= src_size)
    return 0;
  if(dst_start < 0)
    return 0;

//---
  int elements_to_copy = count;
  if(count == WHOLE_ARRAY || count < 0)
    elements_to_copy = src_size - src_start;

//---
  if(src_start + elements_to_copy > src_size)
    elements_to_copy = src_size - src_start;

//---
  if(elements_to_copy <= 0)
    return 0;

//---
  int required_size = dst_start + elements_to_copy;
  if(dst_size < required_size)
    ArrayResize(dst_array, required_size);

//---
  for(int i = 0; i < elements_to_copy; i++)
    dst_array[dst_start + i] = src_array[src_start + i];

  return elements_to_copy;
 }


template <typename S>
int ExpandArray(S &arr[], int spaces, S fillValue, ENUM_ALIGN_MODE align)
 {
  if(align == ALIGN_CENTER)
    return -1;

  int oldSize = ArraySize(arr);
  int newSize = oldSize + spaces;

//---
  if(spaces <= 0)
    return -1;

//---
  S temp[];
  ArrayResize(temp, newSize);

//---
  for(int i = 0; i < newSize; i++)
   {
    temp[i] = fillValue;
   }

//---
  if(align == ALIGN_RIGHT)
   {
    for(int i = 0; i < oldSize; i++)
     {
      temp[i] = arr[i];
     }
   }
  else     // ALIGN_LEFT
   {
    for(int i = 0; i < oldSize; i++)
     {
      temp[i + spaces] = arr[i];
     }
   }

//---
  ArrayResize(arr, newSize);
  for(int i = 0; i < newSize; i++)
    arr[i] = temp[i];


  return newSize;
 }

//+------------------------------------------------------------------+
template <typename S>
void AddArraySeries(S &Array[], const S &value)
 {
  ArrayResize(Array, ArraySize(Array) + 1);
  if(ArraySize(Array) > 1)
    for(int x = ArraySize(Array) - 1 ; x > 0 ; x--)
      Array[x] =  Array[x - 1];
  Array[0] = value;
 }
//+------------------------------------------------------------------+
template<typename T>
bool DeleteArrayBiName(T &array[], const string &targetName, int capacity)
 {
  int size = ArraySize(array);
  for(int i = 0; i < size; i++)
   {
    if(array[i].name == targetName)
     {
      // Desplazar elementos hacia atrás
      for(int j = i; j < size - 1; j++)
       {
        array[j] = array[j + 1];
       }
      ArrayResize(array, size - 1, capacity);
      return true;
     }
   }
  return false;
 }

//+------------------------------------------------------------------+
template<typename T>
bool DeleteArrayBiName(T &array[], const string &targetName, T &out, int capacity)
 {
  int size = ArraySize(array);
  for(int i = 0; i < size; i++)
   {
    if(array[i].name == targetName)
     {
      out = array[i];
      // Desplazar elementos hacia atrás
      for(int j = i; j < size - 1; j++)
       {
        array[j] = array[j + 1];
       }
      ArrayResize(array, size - 1, capacity);
      return true;
     }
   }
  return false;
 }

//+------------------------------------------------------------------+
template <typename T>
bool DeleteArrayByIndex(T &array[], const int index)
 {
  const int size = ArraySize(array);
  if(size == 0)
    return false;
  for(int j = index; j < size - 1; j++)
    array[j] = array[j + 1];
  ArrayResize(array, size - 1);
  return true;
 }

//+------------------------------------------------------------------+
template<typename T>
void RemoveMultipleIndexes(T &arr[], int &indexes_to_remove[], int capacity)
 {
  const int old_size = ArraySize(arr);
  const int remove_size = ArraySize(indexes_to_remove);
  if(old_size == 0 || remove_size == 0)
    return;

  int write_index = 0;

  for(int read_index = 0; read_index < old_size; read_index++)
   {
    bool is_removed = false;

    for(int k = 0; k < remove_size; k++)
     {
      if(indexes_to_remove[k] == read_index)
       {
        is_removed = true;
        break;
       }
     }

    if(!is_removed)
     {
      arr[write_index++] = arr[read_index];
     }
   }

  ArrayResize(arr, write_index, capacity);
 }

//+------------------------------------------------------------------+
template<typename T>
void RemoveMultipleIndexes(T &arr[], int16_t &indexes_to_remove[], int capacity)
 {
  int16_t old_size = (int16_t)ArraySize(arr);
  int16_t remove_size = (int16_t)ArraySize(indexes_to_remove);
  if(old_size == 0 || remove_size == 0)
    return;

  int16_t write_index = 0;

  for(int16_t read_index = 0; read_index < old_size; read_index++)
   {
    bool is_removed = false;

    for(int16_t k = 0; k < remove_size; k++)
     {
      if(indexes_to_remove[k] == read_index)
       {
        is_removed = true;
        break;
       }
     }

    if(!is_removed)
     {
      arr[write_index++] = arr[read_index];
     }
   }

  ArrayResize(arr, write_index, capacity);
 }


//+------------------------------------------------------------------+
template <typename T>
bool ArrayCopyAll(T &dst_array[], const T &source_array[])
 {
  if(source_array.Size() < 1)
    return false;

  int total = (int)source_array.Size();

  ArrayResize(dst_array, total);

  if(total == 1)
   {
    dst_array[0] = source_array[0];
    return true;
   }
  else
   {
    for(int i = 0; i < total; i++)
     {
      dst_array[i] = source_array[i];
     }

    return true;
   }
 }


//+------------------------------------------------------------------+
template <typename K>
bool AddArrayVefificationByIndex(K &Array[], const K &Value)
 {
  for(int i = 0 ; i < ArraySize(Array) ; i++)
   {
    if(Array[i].index == Value.index)
      return false;
   }
  ArrayResize(Array, Array.Size() + 1);
  Array[Array.Size() - 1] = Value;
  return true;
 }
//+------------------------------------------------------------------+
template <typename S>
bool AddArrayName(S &Array[], const S &Value)
 {
  for(int i = 0 ; i < ArraySize(Array) ; i++)
    if(Array[i].name == Value.name)
      return false;

  ArrayResize(Array, Array.Size() + 1);
  Array[Array.Size() - 1] = Value;
  return true;
 }
//+------------------------------------------------------------------+
template <typename T>
bool AddArrayVal(T &Array[], const T Value)
 {
  for(int i = 0 ; i < ArraySize(Array) ; i++)
    if(Array[i] == Value)
      return false;


  ArrayResize(Array, Array.Size() + 1);
  Array[Array.Size() - 1] = Value;
  return true;
 }
//+------------------------------------------------------------------+
#define AddArrayNoVerification1(array, value, size, capacity) ArrayResize(array, size + 1, capacity); \
                                                    array[size] = value;  \

#define AddArrayNoVerification2(array, value, capacity) const int size = ArraySize(array); \
                                              ArrayResize(array, size + 1, capacity); \
                                              array[size] = value;  \

template <typename X>
inline void AddArrayNoVerification(X &array[], const X &value, int capacity)
 {
  const int size = ArraySize(array);
  ArrayResize(array, size + 1, capacity);
  array[size] = value;
 }

//+------------------------------------------------------------------+
template <typename X>
inline void AddArrayNoVerification(X* &array[], X* value, int capacity)
 {
  const int size = ArraySize(array);
  ArrayResize(array, size + 1, capacity);
  array[size] = value;
 }

//+------------------------------------------------------------------+
template <typename H>
inline int ArrayFindValue(const H &array[], const H value)
 {
  for(int i = 0 ; i < ArraySize(array) ; i++)
    if(array[i] == value)
      return i;
  return -1;
 }



//+------------------------------------------------------------------+
template <typename S>
bool ExistNameInArray(S &Array[], const S &value)
 {
  for(int i = 0; i < ArraySize(Array) ; i++)
    if(value.name == Array[i].name)
      return true;
  return false;
 }


//+------------------------------------------------------------------+
template<typename T>
string ArrayToString(const T &array[], string separator)
 {
  string val = ""; // Inicializamos la cadena sin espacios extra
  for(int i = 0; i < ArraySize(array); i++)
   {
    if(i == ArraySize(array) - 1)    // Si es el último elemento
      val += (string)array[i];    // No añadimos el separador
    else
      val += (string)array[i] + separator; // Añadimos el separador
   }
  return val; // Devolvemos la cadena construida
 }

//+------------------------------------------------------------------+
template <typename ST>
ST ArraYSumar(ST &array[], int start = 0, int count = WHOLE_ARRAY)
 {
//---
  if(count >= ArraySize(array) && count != WHOLE_ARRAY)
   {
    Print("Invalid count: ", count);
    return 0;
   }
  if(start < 0 || start >= ArraySize(array))
   {
    Print("Invalid start: ", start, " | ArraySize: ", ArraySize(array));
    return 0;
   }
//---
  if(count == WHOLE_ARRAY)
    count = ArraySize(array);
  ST suma = 0;
//---
  for(int i = start; i < count; i++)
   {
    suma += array[i];
   }
  return suma;
 }
/*
template <typename ST>
ST sum(ST &array[], int start = 0, int count = WHOLE_ARRAY)
 {
//---
  if(count >= ArraySize(array) && count != WHOLE_ARRAY)
   {
    Print("Invalid count: ", count);
    return 0;
   }
  if(start < 0 || start >= ArraySize(array))
   {
    Print("Invalid start: ", start, " | ArraySize: ", ArraySize(array));
    return 0;
   }
//---
  if(count == WHOLE_ARRAY)
    count = ArraySize(array);
  ST suma = 0;
//---
  for(int i = start; i < count; i++)
   {
    suma += array[i];
   }
  return suma;
 }
*/
//---
enum MODE_CLOSET_INDEX
 {
  MAYOR_A_TARGET_TIME,
  MENOR_A_TARGET_TIME
 };

//+------------------------------------------------------------------+
template <typename S>
int GetClosestArrayIndexByTime(datetime target_time, S &array[], MODE_CLOSET_INDEX mode)
 {
  if(ArraySize(array) == 0)
    return -1;
  int closest_index = -1;
  int min_diff = INT_MAX;

  for(int i = 0; i < ArraySize(array); i++)
   {
    // Solo comparamos si el tiempo de bos[i] es mayor que target_time
    if((array[i].time > target_time && mode == MAYOR_A_TARGET_TIME) || (array[i].time < target_time && mode == MENOR_A_TARGET_TIME))
     {
      int diff = (int)MathAbs(array[i].time - target_time);  // Calculamos la diferencia actual
      if(diff < min_diff)
       {
        min_diff = diff;  // Actualizamos la diferencia mínima
        closest_index = i;  // Actualizamos el índice más cercano
       }
     }
   }
  return closest_index;  // Retornamos el índice del Bos con el tiempo más cercano, o -1 si no se encontró
 }

//+------------------------------------------------------------------+
template<typename T>
void RemoveDuplicates(T &array[])
 {
  int size = ArraySize(array);
  if(size <= 1)
    return;

  int write_index = 0;

  for(int read_index = 0; read_index < size; read_index++)
   {
    bool is_duplicate = false;

    for(int j = 0; j < write_index; j++)
     {
      if(array[read_index] == array[j])
       {
        is_duplicate = true;
        break;
       }
     }

    if(!is_duplicate)
     {
      array[write_index] = array[read_index];
      write_index++;
     }
   }
  ArrayResize(array, write_index);
 }

//+------------------------------------------------------------------+
template <typename S>
void SortArrayTimeByInitDayTime(S &array[], int left, int right)
 {
  if(left >= right)
    return;
// Elegimos un pivote (el del medio)
  int pivotIndex = (left + right) >> 1;
  int pivotValue = TimeDifferenceByHHMMSS(array[pivotIndex].time);
  int i = left, j = right;
  while(i <= j)
   {
    // Encuentra un elemento mayor que el pivote
    while(TimeDifferenceByHHMMSS(array[i].time) > pivotValue)
      i++;
    // Encuentra un elemento menor que el pivote
    while(TimeDifferenceByHHMMSS(array[j].time) < pivotValue)
      j--;
    if(i <= j)
     {
      // Intercambia eventos si están fuera de lugar
      S temp = array[i];
      array[i] = array[j];
      array[j] = temp;
      i++;
      j--;
     }
   }

// Orden recursivo de las dos mitades
  SortArrayTimeByInitDayTime(array, left, j);
  SortArrayTimeByInitDayTime(array, i, right);
 }
 
//+------------------------------------------------------------------+
template <typename S>
void SortArrayTimeDescendente(S &array[], int left, int right)
 {
  if(left >= right)
    return;

  int pivotIndex = (left + right) >> 1;
  datetime pivotValue = array[pivotIndex].time; // Usar directamente el valor datetime
  int i = left, j = right;
  while(i <= j)
   {
    while(array[i].time > pivotValue)  // Compara directamente los datetime
      i++;
    while(array[j].time < pivotValue)
      j--;
    if(i <= j)
     {
      S temp = array[i];
      array[i] = array[j];
      array[j] = temp;
      i++;
      j--;
     }
   }
  SortArrayTimeDescendente(array, left, j);
  SortArrayTimeDescendente(array, i, right);
 }
 
//+------------------------------------------------------------------+
template <typename S>
void SortArrayTimeAscendente(S &array[], int left, int right)
 {
  if(left >= right)
    return;

  int pivotIndex = (left + right) >> 1;
  datetime pivotValue = array[pivotIndex].time; // Usar directamente el valor datetime
  int i = left, j = right;
  while(i <= j)
   {
    while(array[i].time < pivotValue)  // Compara directamente los datetime
      i++;
    while(array[j].time > pivotValue)
      j--;
    if(i <= j)
     {
      S temp = array[i];
      array[i] = array[j];
      array[j] = temp;
      i++;
      j--;
     }
   }
  SortArrayTimeAscendente(array, left, j);
  SortArrayTimeAscendente(array, i, right);
 } 
 
//+------------------------------------------------------------------+
template <typename S>
void SortArrayPrice2Asendente(S &array[], int left, int right)
 {
  if(left >= right)
    return;

  int pivotIndex = (left + right) >> 1;
  double pivotValue = array[pivotIndex].price2;
  int i = left, j = right;
  while(i <= j)
   {
    while(array[i].price2 < pivotValue)
      i++;
    while(array[j].price2 > pivotValue)
      j--;
    if(i <= j)
     {
      S temp = array[i];
      array[i] = array[j];
      array[j] = temp;
      i++;
      j--;
     }
   }

  SortArrayPrice2Asendente(array, left, j);
  SortArrayPrice2Asendente(array, i, right);
 }

//+------------------------------------------------------------------+
template <typename S>
void SortArrayPrice2Desendente(S &array[], int left, int right)
 {
  if(left >= right)
    return;

  int pivotIndex = (left + right) >> 1;
  double pivotValue = array[pivotIndex].price2;
  int i = left, j = right;
  while(i <= j)
   {
    while(array[i].price2 > pivotValue)
      i++;
    while(array[j].price2 < pivotValue)
      j--;
    if(i <= j)
     {
      S temp = array[i];
      array[i] = array[j];
      array[j] = temp;
      i++;
      j--;
     }
   }

  SortArrayPrice2Desendente(array, left, j);
  SortArrayPrice2Desendente(array, i, right);
 }


//---
template<typename S>
inline bool IdxIsValid(const S &array[], int idx)
 {
  return idx >= 0 && idx < array.Size();
 }


//+------------------------------------------------------------------+
enum ENUM_MODE_SORT_PRICE
 {
  SORT_PRICE_MINOR_A_TARGET_PRICE = 0, // solo menores al target
  SORT_PRICE_MAYOR_A_TARGET_PRICE = 1 // solo mayores al target
 };

//---
template<typename T>
int SortByPrice(const T &arr_src[], T &arr_dest[],
                const double target_price,
                const ENUM_MODE_SORT_PRICE mode)
 {
  int count = 0;
  ArrayResize(arr_dest, ArraySize(arr_src));

//---
  for(int i = 0, j = 0; i < ArraySize(arr_src) * ArraySize(arr_src); i++)
   {
    int row = i / ArraySize(arr_src);
    int col = i % ArraySize(arr_src);

    // Paso 1: Filtrar y copiar una sola vez
    if(i < ArraySize(arr_src))
     {
      double p = arr_src[i].price;
      if((mode == SORT_PRICE_MINOR_A_TARGET_PRICE && p < target_price) ||
         (mode == SORT_PRICE_MAYOR_A_TARGET_PRICE && p > target_price))
       {
        arr_dest[count++] = arr_src[i];
       }
     }

    // Paso 2: Selection sort plano dentro del mismo bucle
    if(count > 1 && row < count - 1 && col > row)
     {
      double diff_row = MathAbs(arr_dest[row].price - target_price);
      double diff_col = MathAbs(arr_dest[col].price - target_price);

      if(diff_col < diff_row)
       {
        T tmp = arr_dest[row];
        arr_dest[row] = arr_dest[col];
        arr_dest[col] = tmp;
       }
     }
   }

  ArrayResize(arr_dest, count);
  return count;
 }
//---
template<typename T>
int SortByPrice2(const T &arr_src[], T &arr_dest[],
                 const double target_price,
                 const ENUM_MODE_SORT_PRICE mode)
 {
  int count = 0;
  ArrayResize(arr_dest, ArraySize(arr_src));

//---
  for(int i = 0, j = 0; i < ArraySize(arr_src) * ArraySize(arr_src); i++)
   {
    int row = i / ArraySize(arr_src);
    int col = i % ArraySize(arr_src);

    // Paso 1: Filtrar y copiar una sola vez
    if(i < ArraySize(arr_src))
     {
      double p = arr_src[i].price2;
      if((mode == SORT_PRICE_MINOR_A_TARGET_PRICE && p < target_price) ||
         (mode == SORT_PRICE_MAYOR_A_TARGET_PRICE && p > target_price))
       {
        arr_dest[count++] = arr_src[i];
       }
     }

    // Paso 2: Selection sort plano dentro del mismo bucle
    if(count > 1 && row < count - 1 && col > row)
     {
      double diff_row = MathAbs(arr_dest[row].price2 - target_price);
      double diff_col = MathAbs(arr_dest[col].price2 - target_price);

      if(diff_col < diff_row)
       {
        T tmp = arr_dest[row];
        arr_dest[row] = arr_dest[col];
        arr_dest[col] = tmp;
       }
     }
   }

  ArrayResize(arr_dest, count);
  return count;
 }
//+------------------------------------------------------------------+
template <typename S>
void SortArrayTime1(S &array[], int left, int right)
 {
  if(left >= right)
    return;

  int pivotIndex = (left + right) / 2;
  datetime pivotValue = array[pivotIndex].time1; // Usar directamente el valor datetime
  int i = left, j = right;

  while(i <= j)
   {
    Print("I: ", i);
    while(array[i].time1 > pivotValue)  // Compara directamente los datetime
      i++;
    while(array[j].time1 < pivotValue)
      j--;
    if(i <= j)
     {
      S temp = array[i];
      array[i] = array[j];
      array[j] = temp;
      i++;
      j--;
     }
   }
  SortArrayTime1(array, left, j);
  SortArrayTime1(array, i, right);
 }


//+------------------------------------------------------------------+
template <typename S>
void SortArrayTimeDiffAscendingTime2(S &array[], int left, int right, datetime currentTime)
 {
  if(left >= right)
    return;


// Elegir un pivote usando el elemento central y calcular la diferencia absoluta
  int pivotIndex = (left + right) / 2;
  long pivotDiff = MathAbs((long)(currentTime - array[pivotIndex].time2));

  int i = left, j = right;
  while(i <= j)
   {
    while(MathAbs((long)(currentTime - array[i].time2)) < pivotDiff)
      i++;

    while(MathAbs((long)(currentTime - array[j].time2)) > pivotDiff)
      j--;

    if(i <= j)
     {
      // Intercambiar elementos
      S temp = array[i];
      array[i] = array[j];
      array[j] = temp;
      i++;
      j--;
     }
   }

//---
  SortArrayTimeDiffAscendingTime2(array, left, j, currentTime);
  SortArrayTimeDiffAscendingTime2(array, i, right, currentTime);
 }

//+------------------------------------------------------------------+
template<typename S>
bool HayNegativosArray(S &array[], int start = 0, int count = WHOLE_ARRAY)
 {
  if(start < 0 || start >= ArraySize(array))
    return false;
  if(count >= ArraySize(array))
    return false;
  if(count == WHOLE_ARRAY)
    count = ArraySize(array);

  for(int i = start; i < count && !IsStopped(); i++)
    if(array[i] <  0)
      return true;
  return (false);
 }
//+------------------------------------------------------------------+
template<typename S>
bool HayPositivosArray(S &array[], int start = 0, int count = WHOLE_ARRAY)
 {
  if(start < 0 || start >= ArraySize(array))
    return false;
  if(count >= ArraySize(array))
    return false;
  if(count == WHOLE_ARRAY)
    count = ArraySize(array);

  for(int i = start; i < count && !IsStopped(); i++)
    if(array[i] > 0)
      return true;
  return (false);
 }


//+------------------------------------------------------------------+
template <typename T>
void FindMaxMinArray(const T &arr[], T &max_val, T &min_val)
 {
  int size = ArraySize(arr);
  if(size == 0)
   {
    max_val = 0.0;
    min_val = 0.0;
    return;
   }

  max_val = arr[0];
  min_val = arr[0];

  for(int i = 1; i < size; i++)
   {
    if(arr[i] > max_val)
      max_val = arr[i];
    if(arr[i] < min_val)
      min_val = arr[i];
   }
 }

//+------------------------------------------------------------------+
template <typename S>
void ObtenerLosUltimosValoresArr(const int max_valores, const int start, const S &data_array[], S & desitno_array[])
 {
  int count = max_valores;
  for(int i = start; i < ArraySize(data_array) && count > 0 ; i++)
   {
    ArrayResize(desitno_array, desitno_array.Size() + 1);
    desitno_array[desitno_array.Size() - 1] = data_array[i];
    count--;
   }
 }



//+------------------------------------------------------------------+
//|                        Strings                                   |
//+------------------------------------------------------------------+
template <typename S>
void StringToType(string token, S &value, ENUM_DATATYPE type)
 {
  if(StringLen(token) == 0)
   {
    Print("Error: String is empty.");
    return;
   }

  switch(type)
   {
    case TYPE_BOOL:
      value = (S)(StringToInteger(token) != 0);  // Convertir a bool
      break;

    case TYPE_CHAR:
      value = (S)((char)StringToInteger(token));  // Convertir a char
      break;

    case TYPE_UCHAR:
      value = (S)((uchar)StringToInteger(token));  // Convertir a uchar
      break;

    case TYPE_SHORT:
      value = (S)((short)StringToInteger(token));  // Convertir a short
      break;

    case TYPE_USHORT:
      value = (S)((ushort)StringToInteger(token));  // Convertir a ushort
      break;

    case TYPE_COLOR:
      value = (S)((color)StringToInteger(token));  // Convertir a color
      break;

    case TYPE_INT:
      value = (S)(StringToColor(token));  // Convertir a int
      break;

    case TYPE_UINT:
      value = (S)((uint)StringToInteger(token));  // Convertir a uint
      break;

    case TYPE_DATETIME:
      value = (S)(StringToTime(token));  // Convertir a datetime
      break;

    case TYPE_LONG:
      value = (S)((long)StringToInteger(token));  // Convertir a long
      break;

    case TYPE_ULONG:
      value = (S)((ulong)StringToInteger(token));  // Convertir a ulong
      break;

    case TYPE_FLOAT:
      value = (S)((float)StringToDouble(token));  // Convertir a float
      break;

    case TYPE_DOUBLE:
      value = (S)(StringToDouble(token));  // Convertir a double
      break;

    case TYPE_STRING:
      value = (S)(token);  // Mantener como string
      break;

    default:
      Print("Error: Unsupported data type in ConvertToType.");
      break;
   }
 }
//+------------------------------------------------------------------+
string AbreviarPeriodo(ENUM_TIMEFRAMES timeframe)
 {
  string  periodo_string = EnumToString(timeframe);
  StringReplace(periodo_string, "PERIOD_", "");
  StringToLower(periodo_string);
  return periodo_string;
 }

//+------------------------------------------------------------------+
string StringRepeat(string cadena_a_repeitr, int numero_repeticiones)
 {
  string result = "";
  for(int i = 0; i < numero_repeticiones; i++)
   {
    result += cadena_a_repeitr;
   }
  return result;
 }

//+------------------------------------------------------------------+
string RemoveMultipleSubStrings(const string original, const string &subStringsToRemove[])
 {
  string modified = original; // Copia de la cadena original para modificar
  int position;               // Posición de la subcadena a remover

// Itera sobre el array de subcadenas a remover
  for(int i = 0; i < ArraySize(subStringsToRemove); i++)
   {
    // Bucle para remover todas las ocurrencias de cada subcadena
    while((position = StringFind(modified, subStringsToRemove[i])) != -1)
     {
      // Remueve la subcadena encontrada
      modified = StringSubstr(modified, 0, position) + StringSubstr(modified, position + StringLen(subStringsToRemove[i]));
     }
   }

  return modified; // Devuelve la cadena modificada
 }
//+------------------------------------------------------------------+
string RemoveSubString(const string original, const string toRemove)
 {
  string modified = original; // Copia de la cadena original para modificar
  int position;               // Posición de la subcadena a remover

// Bucle para remover todas las ocurrencias de la subcadena
  while((position = StringFind(modified, toRemove)) != -1)
   {
    // Remueve la subcadena encontrada
    modified = StringSubstr(modified, 0, position) + StringSubstr(modified, position + StringLen(toRemove));
   }

  return modified; // Devuelve la cadena modificada
 }

//+------------------------------------------------------------------+
//|                    Trabajo Con Datetime                          |
//+------------------------------------------------------------------+
datetime MinTime(datetime time1, datetime time2, datetime time3)
 {
  datetime minTime = time1;
  if(time2 < minTime)
    minTime = time2;
  if(time3 < minTime)
    minTime = time3;
  return minTime;
 }

//+------------------------------------------------------------------+
bool IsValidDay(datetime time, bool symbol_is_cripto)
 {
  MqlDateTime tm;
  TimeToStruct(time, tm);

  if(tm.day_of_year == 0)
    return false; //si es 1 de enero retornamos

  if(symbol_is_cripto == false)
   {
    if(tm.day_of_week == 0 || tm.day_of_week == 6)
      return false;
   }

  if(tm.day == 25 && tm.mon == 12)
    return false;

  return true;
 }

//+------------------------------------------------------------------+
datetime HoraYMinutoADatetime(int hora, int minuto, datetime time_objetivo)
 {
  MqlDateTime tm;
  TimeToStruct(time_objetivo, tm);
  tm.hour = hora;
  tm.min = minuto;
  tm.sec = 0; // Puedes ajustar los segundos si es necesario
  return StructToTime(tm);;
 }
//+------------------------------------------------------------------+
inline string HoraYMinutoAString(int Hora, int minuto)
 {
  return IntegerToString(Hora) + ":" + IntegerToString(minuto);
 }

//+------------------------------------------------------------------+
inline int diffGMT_NY()
 {
  datetime currentTime = TimeTradeServer();
  return TimeIsVerano(currentTime) ? -4 : -5;
 }

//+------------------------------------------------------------------+
datetime GetSecondSundayOfMonth(int month, int year)
 {
  datetime firstSunday = GetFirstSundayOfMonth(month, year);
  return firstSunday + 7 * 86400;
 }
//+------------------------------------------------------------------+
datetime GetFirstSundayOfMonth(int month, int year)
 {
// Validar parámetros de entrada
  if(month < 0 || month > 12 || year < 1970)
    return 0;

// Crear fecha para el primer día del mes
  MqlDateTime dt;
  dt.year = year;
  dt.mon = month;
  dt.day = 1;
  dt.hour = 0;
  dt.min = 0;
  dt.sec = 0;

// Convertir a datetime
  datetime firstDay = StructToTime(dt);

// Obtener el día de la semana del primer día (0=domingo, 1=lunes, ..., 6=sábado)
  MqlDateTime firstDayInfo;
  TimeToStruct(firstDay, firstDayInfo);
  int dayOfWeek = firstDayInfo.day_of_week;

// Calcular cuántos días hay que agregar para llegar al primer domingo
// Si el primer día es domingo (dayOfWeek=0), no sumamos nada
// En caso contrario, sumamos días hasta llegar al domingo (7-dayOfWeek)
  int daysToAdd = (dayOfWeek == 0) ? 0 : (7 - dayOfWeek);

// Retornar la fecha del primer domingo
  return firstDay + daysToAdd * 86400; // 86400 segundos = 1 día
 }

//+------------------------------------------------------------------+
#define  GetTiempoCoeficiente(tiempo_inicio, tiempo_final, coeficiente) tiempo_inicio + int((tiempo_final - tiempo_inicio) * coeficiente)


//+------------------------------------------------------------------+
datetime GetInitMonth(int year, int month)
 {
  MqlDateTime tm;
  tm.year = year;
  tm.mon  = month;
  tm.day  = 1;
  tm.hour = 0;
  tm.min  = 0;
  tm.sec  = 0;
  return StructToTime(tm);
 }
//+------------------------------------------------------------------+
int DaysInMonth(int year, int month)
 {
  datetime start = GetInitMonth(year, month);
  int nextYear  = (month == 12) ? year + 1 : year;
  int nextMonth = (month == 12) ? 1 : month + 1;
  datetime nextStart = GetInitMonth(nextYear, nextMonth);
  int days = int((nextStart - start) / 86400);
  return days;
 }
//+------------------------------------------------------------------+
int SecondsInMonth(int year, int month)
 {
  datetime start = GetInitMonth(year, month);
  int nextYear  = (month == 12) ? year + 1 : year;
  int nextMonth = (month == 12) ? 1 : month + 1;
  datetime nextStart = GetInitMonth(nextYear, nextMonth);
  return int(nextStart - start);
 }
//+------------------------------------------------------------------+
int SecondsInMonth(datetime time)
 {
  MqlDateTime tm;
  TimeToStruct(time, tm);

  datetime start = GetInitMonth(tm.year, tm.mon);
  int nextYear  = (tm.mon == 12) ? tm.year + 1 : tm.year;
  int nextMonth = (tm.mon == 12) ? 1 : tm.mon + 1;
  datetime nextStart = GetInitMonth(nextYear, nextMonth);
  return int(nextStart - start);
 }
//+------------------------------------------------------------------+
datetime GetInitDayTime(datetime time)
 {
  MqlDateTime tm;
  TimeToStruct(time, tm);
  tm.hour = 0;
  tm.min = 0;
  tm.sec = 0;
  return StructToTime(tm);
 }
//+------------------------------------------------------------------+
datetime GetInitWeekTime(datetime time)
 {
  MqlDateTime tm;
  TimeToStruct(time, tm);
  tm.hour = 0;
  tm.min  = 0;
  tm.sec  = 0;

  datetime midnight = StructToTime(tm);
  int dias_a_restar = (tm.day_of_week + 6) % 7;
  return midnight - dias_a_restar * 86400;
 }
//+------------------------------------------------------------------+
datetime ModifiedTime(datetime original, int hour, int min, int sec)
 {
  MqlDateTime time_struct;
  TimeToStruct(original, time_struct);
  time_struct.hour = hour;
  time_struct.min = min;
  time_struct.sec = sec;
  return StructToTime(time_struct);
 }
//+------------------------------------------------------------------+
inline int TimeDifferenceByHHMMSS(datetime event_time)
 {
  return (int)(event_time % 86400); // 86400 segundos en un día
 }

//+------------------------------------------------------------------+
inline bool ContainsRangeTime(datetime time, datetime _init_time, datetime _end_time, bool considerar_igual)
 {
  return !considerar_igual ? (time > _init_time && time < _end_time) : (time >= _init_time && time <= _end_time);
 }
//+------------------------------------------------------------------+
int ExtraerMinutoDatetime(const datetime time)
 {
  MqlDateTime t;
  TimeToStruct(time, t);
  return t.min;
 }
//+------------------------------------------------------------------+
datetime MinTime(datetime time1, datetime time2, datetime target_time, MODE_CLOSET_INDEX mode)
 {
  if(mode == MAYOR_A_TARGET_TIME)
   {
    if(time1 <= target_time)
      return time2 <= target_time ? 0 : time2;
    else
      if(time2 <= target_time)
        return time1 <= target_time ? 0 : time1;

    int diff_time1 = (int)MathAbs(time1 - target_time);
    int diff_time2 = (int)MathAbs(time2 - target_time);
    if(diff_time1 > diff_time2)
      return time2;
    else
      if(diff_time2 >= diff_time1)
        return time1;
   }
  else
   {
    if(time1 >= target_time)
      return time2 >= target_time ? 0 : time2;
    else
      if(time2 >= target_time)
        return time1 >= target_time ? 0 : time1;

    int diff_time1 = (int)MathAbs(target_time - time1);
    int diff_time2 = (int)MathAbs(target_time - time2);

    if(diff_time1 > diff_time2)
      return time2;
    else
      if(diff_time2 >= diff_time1)
        return time1;
   }
  return 0;
 }
//+------------------------------------------------------------------+
inline datetime MaxTime(datetime time1, datetime time2)
 {
  return (time1 > time2) ? time1 : time2;
 }
//+------------------------------------------------------------------+
inline datetime MinTime(datetime time1, datetime time2)
 {
  return (time1 > time2) ? time2 : time1;
 }
//+------------------------------------------------------------------+
bool TimeIsInvierno(datetime time) //GMT - 5 (noviembre_pasado - marzo_actual)
 {
  MqlDateTime t;
  TimeToStruct(time, t);

  if(t.mon >= 11)
   {
    datetime  tiempo = GetFirstSundayOfMonth(11, t.year);
    return (time > tiempo);
   }
  else
    if(t.mon < 11)
     {
      datetime tiempo = GetSecondSundayOfMonth(3, t.year);
      return time < tiempo;
     }

  return false;
 }
//+------------------------------------------------------------------+
bool TimeIsVerano(datetime time) //GMT -4 (marzo - noviembre)
 {
  MqlDateTime t;
  TimeToStruct(time, t);

  if(t.mon >= 11)
   {
    datetime tiempo = GetFirstSundayOfMonth(11, t.year);
    return (time < tiempo); // solo aseguras que ya pasó el primer domingo de noviembre
   }
  else
    if(t.mon < 11)
     {
      datetime tiempo = GetSecondSundayOfMonth(3, t.year);
      return (time >= tiempo);
     }

  return false;
 }

//+------------------------------------------------------------------+
datetime MaxTime(datetime time1, datetime time2, datetime target_time, MODE_CLOSET_INDEX mode)
 {
  if(mode == MAYOR_A_TARGET_TIME)
   {
    if(time1 <= target_time || time2 <= target_time)
      return 0;
    int diff_time1 = (int)MathAbs(time1 - target_time);
    int diff_time2 = (int)MathAbs(time2 - target_time);
    if(diff_time1 > diff_time2)
      return time1;
    else
      if(diff_time2 > diff_time1)
        return time2;
      else
        return time2;
   }
  else
   {
    if(time1 >= target_time || time2 >= target_time)
      return 0;
    int diff_time1 = (int)MathAbs(target_time - time1);
    int diff_time2 = (int)MathAbs(target_time - time2);
    if(diff_time1 > diff_time2)
      return time1;
    else
      if(diff_time2 > diff_time1)
        return time2;
      else
        return time2;
   }
  return 0;
 }
//+------------------------------------------------------------------+
inline bool EstaEnHorario(int _hora_inicio, int _min_inicio, int _hora_fin, int _min_fin, datetime curr_time)
 {
  MqlDateTime tm;
  TimeToStruct(curr_time, tm);
  return (tm.hour < _hora_inicio || tm.hour > _hora_fin || (tm.hour == _hora_inicio && tm.min < _min_inicio) || (tm.hour == _hora_fin && tm.min >= _min_fin)) == true ? false : true;
 }


//+------------------------------------------------------------------+
//|                      Matematicas                                 |
//+------------------------------------------------------------------+
template <typename S>
inline double IntegerToDouble(S valor)
 {
  return (double)valor;
 }
//+------------------------------------------------------------------+
template <typename S>
inline double dividir(S valor1, S valor2)
 {
  return (valor2 == 0) ? 0.0 : IntegerToDouble(valor1) / IntegerToDouble(valor2);
 }
//+------------------------------------------------------------------+
template <typename S>
inline double dividir(S valor1, int valor2)
 {
  return (valor2 == 0) ? 0.0 : IntegerToDouble(valor1) / IntegerToDouble(valor2);
 }
//+------------------------------------------------------------------+
inline long DoubleToInteger(double value)
 {
  double round_value = MathRound(value);
  return (long)round_value;
 }

//+------------------------------------------------------------------+
inline double sigmoid(double x)
 {
  return 1.0 / (1.0 + MathExp(-x)); // función de activación sigmoide
 }

//+------------------------------------------------------------------+
inline double CalcularPorcentaje(double x, double numero_a_comparar)
 {
  if(numero_a_comparar == 0)
    return 0; // Evitar división entre 0
  return (x / numero_a_comparar) * 100.0;
 }
//+------------------------------------------------------------------+
typedef double (*funcion_variacion)(const double valor_actual, const double valor_anterior);

enum ENUM_TYPE_CALCULATION_VARIACION
 {
  CALCULATION_VARIACION_ABSOLUTA,
  CALCULATION_VARIACION_PORCENTUAL,
  CALCULATION_VARIACION_LOGARITMICA,
  CALCULATION_VARIACION_ESCALA_DINAMICA,
  CALCULATION_VARIACION_NORMALIZADA,
  CALCULATION_VARIACION_RANGOS,
  CALCULATION_VARIACION_TANH,
  CALCULATION_VARIACION_RAIZ,
  CALCULATION_VARIACION_MEDIA
 };

// Funciones de variación
double VariacionAbsoluta(const double valor_actual, const double valor_anterior)
 {
  return valor_actual - valor_anterior;
 }
//+------------------------------------------------------------------+
double VariacionPorcentual(const double valor_actual, const double valor_anterior)
 {
  if(valor_anterior == 0.0)
    return valor_actual; // Evitar división por cero
  return (valor_actual - valor_anterior) / (MathAbs(valor_anterior));
 }
//+------------------------------------------------------------------+
double VariacionLogaritmica(const double valor_actual, const double valor_anterior)
 {
  if(valor_anterior <= 0.0 || valor_actual <= 0.0)
    return 0.0; // Evitar log(0) o log(negativo)
  return MathLog(valor_actual / valor_anterior);
 }
//+------------------------------------------------------------------+
double VariacionEscalaDinamica(const double valor_actual, const double valor_anterior)
 {
  double escala = MathMax(MathAbs(valor_actual), MathAbs(valor_anterior));
  if(escala == 0.0)
    return VariacionNormalizada(valor_actual, valor_anterior);
  return (valor_actual - valor_anterior) / escala;
 }
//+------------------------------------------------------------------+
double VariacionNormalizada(const double valor_actual, const double valor_anterior)
 {
  const double variacion = valor_actual - valor_anterior;
  if(MathAbs(variacion) < 1.0)
    return variacion;

  double minimo = MathMin(MathAbs(valor_actual), MathAbs(valor_anterior));
  int factor_normalizacion = (minimo < 1) ? 1 : (int)MathPow(10, IntegerToDouble(GetIntegerDigits(minimo)));

  return variacion / IntegerToDouble(factor_normalizacion);
 }
//+------------------------------------------------------------------+
double VariacionNormalizadaRangos(const double valor_actual, const double valor_anterior)
 {
  if(valor_anterior == 0.0)
    return MathMin(5.0, MathMax(-5.0, valor_actual)); // Evitar división por 0
  double variacion = (valor_actual - valor_anterior) / (1.0 + MathAbs(valor_anterior));
  return MathMin(5.0, MathMax(-5.0, variacion * 5.0)); // Escalar entre -5 y 5
 }
//+------------------------------------------------------------------+
double VariacionTanh(const double valor_actual, const double valor_anterior)
 {
  return MathTanh(valor_actual - valor_anterior);
 }
//+------------------------------------------------------------------+
double VariacionRaiz(const double valor_actual, const double valor_anterior)
 {
  return (valor_actual - valor_anterior) / MathSqrt(MathAbs(valor_anterior) + 1.0);
 }
//+------------------------------------------------------------------+
double VariacionMedia(const double valor_actual, const double valor_anterior)
 {
  return 2.0 * (valor_actual - valor_anterior) / (valor_actual + valor_anterior + 1.0);
 }
//+------------------------------------------------------------------+
funcion_variacion GetVariacionFunction(ENUM_TYPE_CALCULATION_VARIACION tipo)
 {
  switch(tipo)
   {
    case CALCULATION_VARIACION_ABSOLUTA:
      return VariacionAbsoluta;
    case CALCULATION_VARIACION_PORCENTUAL:
      return VariacionPorcentual;
    case CALCULATION_VARIACION_LOGARITMICA:
      return VariacionLogaritmica;
    case CALCULATION_VARIACION_ESCALA_DINAMICA:
      return VariacionEscalaDinamica;
    case CALCULATION_VARIACION_NORMALIZADA:
      return VariacionNormalizada;
    case CALCULATION_VARIACION_RANGOS:
      return VariacionNormalizadaRangos;
    case CALCULATION_VARIACION_TANH:
      return VariacionTanh;
    case CALCULATION_VARIACION_RAIZ:
      return VariacionRaiz;
    case CALCULATION_VARIACION_MEDIA:
      return VariacionMedia;
    default:
      return NULL;
   }
 }
//+------------------------------------------------------------------+
double TrendWeightedDifference(const double &values[], int size)
 {
  if(size < 2)
    return 0.0;

  double num = 0.0, denom = 0.0;
  for(int i = 0; i < size - 1; i++)
   {
    double weight = i + 1;
    num += weight * (values[i + 1] - values[i]);
    denom += weight;
   }

  return tanh(num / (denom + 1e-9)); // Escalado con tanh
 }
//+------------------------------------------------------------------+
double TrendSumNormalized(const double &values[], int size)
 {
  if(size < 2)
    return 0.0;

  double sumDiff = 0.0, sumAbsDiff = 0.0;
  for(int i = 0; i < size - 1; i++)
   {
    double diff = values[i + 1] - values[i];
    sumDiff += diff;
    sumAbsDiff += fabs(diff);
   }

  return (sumAbsDiff == 0) ? 0.0 : sumDiff / sumAbsDiff;
 }
//+------------------------------------------------------------------+
inline double GetVariacion(const double valor_actual, const double valor_anterior, ENUM_TYPE_CALCULATION_VARIACION type_variacion)
 {
  funcion_variacion funcion = GetVariacionFunction(type_variacion);
  return funcion == NULL ? 0.0 : funcion(valor_actual, valor_anterior);
 }
//+------------------------------------------------------------------+
inline int GetIntegerDigits(double number)
 {
  number = MathAbs(number); // Asegurarse de que es positivo
  return (number < 1.0) ? 1 : int(MathFloor(MathLog10(number))) + 1 ; // Tomamos el piso del logaritmo y sumamos 1
 }
//+------------------------------------------------------------------+
inline double GetDist(double price1, double price2)
 {
  return MathMax(price1, price2) - MathMin(price1, price2);
 }
//+------------------------------------------------------------------+
inline double GetPriceCoeficiente(double price1, double price2, double coeficiente)
 {
  return MathMax(price1, price2) - (GetDist(price1, price2) * coeficiente);
 }
//+------------------------------------------------------------------+
inline bool CumpleMinDistancia(const double min_dist, double price1, double price2)
 {
  return GetDist(price1, price2) < min_dist ? false :  true;
 }

//+------------------------------------------------------------------+
inline double RoundToStep(double number, double step)
 {
  if(step <= DBL_EPSILON)
    return number; // Evitar división por cero
  return MathRound((number / step)) * step;
 }

//+------------------------------------------------------------------+
//|                        Vectores                                  |
//+------------------------------------------------------------------+
template <typename T>
void VectorPrint(const vector<T> &v, int digitos, string separator = " | ")
 {
  string p = "";
  for(ulong  i = 0; i < v.Size() ; i++)
   {
    p += DoubleToString(v[i], digitos) + separator;
   }
  Print(p);
 }

template <typename S>
vector ArrayToVector(const S &array[])
 {
  vector v(ArraySize(array));

  for(int i = 0; i < ArraySize(array) ; i++)
    v[i] =  IntegerToDouble(array[i]);

  return v;
 }

//+------------------------------------------------------------------+
void VectorToDoubleArray(const vector &v, double &array[])
 {
  int size = (int)v.Size();
  ArrayResize(array, size);

  for(ulong i = 0; i < v.Size() ; i++)
    array[i] = v[i];
 }

//+------------------------------------------------------------------+
template <typename S>
void SortVector(vector<S>& data)
 {
  if(data.Size() <= 1)
    return;
  QuickSortRecursive(data, 0, (int)data.Size() - 1);
 }
//+------------------------------------------------------------------+
template <typename S>
void QuickSortRecursive(vector<S>& data, int low, int high)
 {
  if(low < high)
   {
    int pivot_index = Partition(data, low, high);
    QuickSortRecursive(data, low, pivot_index - 1);
    QuickSortRecursive(data, pivot_index + 1, high);
   }
 }
//+------------------------------------------------------------------+
template <typename S>
int Partition(vector<S>& data, int low, int high)
 {
  S pivot = data[high];

  int i = low - 1;

  for(int j = low; j < high; j++)
   {
    if(data[j] <= pivot)
     {
      i++;
      SwapVectorValue(data, i, j);
     }
   }

  SwapVectorValue(data, i + 1, high);
  return i + 1;
 }
//+------------------------------------------------------------------+
template <typename S>
void SwapVectorValue(vector<S>& data, int i, int j)
 {
  if(i != j)
   {
    S temp = data[i];
    data[i] = data[j];
    data[j] = temp;
   }
 }

//+------------------------------------------------------------------+
//|                       Funciones Extra                            |
//+------------------------------------------------------------------+
inline bool Tester()
 {
  return (MQLInfoInteger(MQL_TESTER) || MQLInfoInteger(MQL_OPTIMIZATION) || MQLInfoInteger(MQL_DEBUG));
 }
//+------------------------------------------------------------------+
void Remover(string short_name = " ", long chart_id = 0, int subwin = 0)
 {
  if(MQLInfoInteger(MQL_PROGRAM_TYPE) == PROGRAM_INDICATOR)
   {
    if(Tester() == false)
      ChartIndicatorDelete(chart_id, subwin, short_name);
    else
      TesterStop();

    return;
   }

  if(Tester())
    TesterStop();
  else
    ExpertRemove();
 }
//+------------------------------------------------------------------+
bool CreateFolder(string folder_path, bool common_flag)
 {
  int flag = common_flag ? FILE_COMMON : 0;
  string working_folder;
//--- aclaramos la ruta completa dependiendo del parámetro common_flag
  if(common_flag)
    working_folder = TerminalInfoString(TERMINAL_COMMONDATA_PATH) + "\\MQL5\\Files";
  else
    working_folder = TerminalInfoString(TERMINAL_DATA_PATH) + "\\MQL5\\Files";
//--- mensaje de depuración
  PrintFormat("folder_path=%s", folder_path);
//---intentando crear una carpeta relativa a la ruta MQL5\Files
  if(FolderCreate(folder_path, flag))
   {
    //--- mostramos la ruta completa para la carpeta creada
    PrintFormat("Hemos creado la carpeta %s", working_folder + "\\" + folder_path);
    //--- reseteamos el código de error
    ResetLastError();
    //--- ejecutado con éxito
    return true;
   }
  else
    PrintFormat("No se ha logrado crear la carpeta %s. Código de error %d", working_folder + folder_path, GetLastError());
//--- ejecutado sin éxito
  return false;
 }
//+------------------------------------------------------------------+
inline bool PeriodIsBig(ENUM_TIMEFRAMES Period)
 {
  return Period == PERIOD_MN1 || Period == PERIOD_W1 || Period == PERIOD_D1 || Period == PERIOD_H4 || Period == PERIOD_H2
         || Period == PERIOD_H3 || Period == PERIOD_H8 || Period == PERIOD_H12 || Period == PERIOD_H6 || Period == PERIOD_H1 ? true : false ;
 }
//+------------------------------------------------------------------+
long OpenChartAndGetChartID(string symbol, ENUM_TIMEFRAMES timeframe)
 {
  long chart_id = ChartOpen(symbol, timeframe);
  return chart_id > 0 ? chart_id : 0;
 }

//+------------------------------------------------------------------+
inline double ConvertPriceToPoints(const string symbol, double priceDistance)
 {
  return (MathRound(priceDistance / SymbolInfoDouble(symbol, SYMBOL_POINT)));
 }

// Checks if the symbol is categorized under the "Crypto" sector
bool SymbolIsCrypto(const string sym)
 {
  string sector = SymbolInfoString(sym, SYMBOL_SECTOR_NAME);
  if(StringLen(sector) > 0) // Ensuring the string is not empty
   {
    StringToLower(sector); // Convert the sector name to lower case for case-insensitive comparison
    return StringFind(sector, "rypto") >= 0; // Search for "crypto" in the sector name
   }
  return false; // Return false if the sector name is empty
 }
//+------------------------------------------------------------------+
inline ulong GetTickCount64Seconds()
 {
  ulong cof = 1000;
  return (ulong)dividir(GetTickCount64(), cof);
 }
//+------------------------------------------------------------------+
#define GetTickCount64Minutes (uint)(GetTickCount64() * 1.6666666666666666666666666666667e-5)

//+------------------------------------------------------------------+
void SwitchToChart(long target_chart_id)
 {
//---
  if(ChartGetInteger(target_chart_id, CHART_WINDOWS_TOTAL) < 0)
   {
    Print("Error: El gráfico no existe o fue cerrado");
    return;
   }

  ChartSetInteger(target_chart_id, CHART_BRING_TO_TOP, true);
  ChartSetInteger(target_chart_id, CHART_FOREGROUND, true);
 }

//+------------------------------------------------------------------+
inline bool CandleIsBull(const int index, string symbol, ENUM_TIMEFRAMES timeframe)
 {
  return iClose(symbol, timeframe, index) > iOpen(symbol, timeframe, index);
 }
//+------------------------------------------------------------------+
inline bool CandleIsBear(const int index, string symbol, ENUM_TIMEFRAMES timeframe)
 {
  return iClose(symbol, timeframe, index) < iOpen(symbol, timeframe, index);
 }

//+------------------------------------------------------------------+
inline void EMPTY_FUNCTION()
 {
  return;
 }
//+------------------------------------------------------------------+
inline void EMPTY_FUNCTION_TIME(datetime curr_time, bool new_day)
 {
  return;
 }


//+------------------------------------------------------------------+
//| Funiones Comerciales                                             |
//+------------------------------------------------------------------+
double AjustarNivelDeStopArriba(double pPrecioActual, double pPrecioParaAjustar, int pPuntosAdicionales = 10)
 {
  double PrecioAjustado = pPrecioParaAjustar;
  long nivelesStop = SymbolInfoInteger(_Symbol, SYMBOL_TRADE_STOPS_LEVEL);
  if(nivelesStop > 0)
   {
    double nivelesStopPrecio = nivelesStop * _Point;
    nivelesStopPrecio = pPrecioActual + nivelesStopPrecio;
    double PuntosAdicionales = pPuntosAdicionales * _Point;
    if(PrecioAjustado  <= nivelesStopPrecio + PuntosAdicionales)
     {
      PrecioAjustado = nivelesStopPrecio + PuntosAdicionales;
      // Print("precio ajustado por encima de niuvel de stops a  ", string(PrecioAjustado));
     }
   }
  return NormalizeDouble(PrecioAjustado, _Digits);
 }
//+------------------------------------------------------------------+
double AjustarNivelDeStopAbajo(double pPrecioActual, double pPrecioParaAjustar, int pPuntosAdicionales = 10)
 {
  double PrecioAjustado = pPrecioParaAjustar;
  long nivelesStop = SymbolInfoInteger(_Symbol, SYMBOL_TRADE_STOPS_LEVEL);
  if(nivelesStop > 0)
   {
    double nivelesStopPrecio = nivelesStop * _Point;
    nivelesStopPrecio = pPrecioActual - nivelesStopPrecio;
    double PuntosAdicionales = pPuntosAdicionales * _Point;
    if(PrecioAjustado  >= nivelesStopPrecio + PuntosAdicionales)
     {
      PrecioAjustado = nivelesStopPrecio + PuntosAdicionales;
      // Print("precio ajustado por debajo de niuvel de stops a  ", string(PrecioAjustado));
     }
   }
  return NormalizeDouble(PrecioAjustado, _Digits);
 }

//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
struct TickMaxMinResult
 {
  double             high_price;           // Precio máximo
  double             low_price;            // Precio mínimo
  datetime           max_time;             // Momento exacto del máximo
  datetime           min_time;             // Momento exacto del mínimo
  int                max_seconds;          // Segundos desde inicio hasta máximo (0-59)
  int                min_seconds;          // Segundos desde inicio hasta mínimo (0-59)
  int                total_ticks;          // Total de ticks analizados
  bool               success;              // ¿Operación exitosa?

                     TickMaxMinResult()
    :                high_price(0.0), low_price(0.0), max_time(0), min_time(0),
                     max_seconds(0), min_seconds(0), total_ticks(0), success(false) {}

                     TickMaxMinResult(const TickMaxMinResult& other)
   {
    this = other;
   }
 };

//+------------------------------------------------------------------+
TickMaxMinResult GetCandleMaxMinByTicks(datetime candle_start, datetime end_time, string symbol = NULL)
 {
  TickMaxMinResult result;

// Usar símbolo actual si no se especifica
  if(symbol == NULL)
    symbol = Symbol();

// Calcular rango de tiempo (1 minuto)
  ulong from_msc = (ulong)candle_start * 1000;           // Inicio en milisegundos
  ulong to_msc = (ulong)(end_time) * 1000;      // Fin en milisegundos (+60 segundos)

// Array para recibir ticks
  MqlTick ticks[];
  ArrayResize(ticks, 0);

// Obtener ticks del rango
  ResetLastError();
  int tick_count = CopyTicksRange(symbol, ticks, COPY_TICKS_ALL, from_msc, to_msc);

  if(tick_count < 1)
   {
    PrintFormat("Error obteniendo ticks %d, start = %s >> end = %s ", GetLastError(), TimeToString(candle_start), TimeToString(end_time));
    result.success = false;
    return result;
   }

// Inicializar valores
  result.high_price = ticks[0].bid;
  result.low_price = ticks[0].bid;
  result.max_time = (datetime)(ticks[0].time_msc / 1000);
  result.min_time = (datetime)(ticks[0].time_msc / 1000);
  result.total_ticks = tick_count;

// Buscar máximo y mínimo
  for(int i = 0; i < tick_count; i++)
   {
    double price = (ticks[i].bid + ticks[i].ask) / 2.0; // Precio promedio bid/ask
    datetime tick_time = (datetime)(ticks[i].time_msc / 1000);

    // Verificar si es nuevo máximo
    if(price > result.high_price)
     {
      result.high_price = price;
      result.max_time = tick_time;
      result.max_seconds = (int)(tick_time - candle_start);
     }

    // Verificar si es nuevo mínimo
    if(price < result.low_price)
     {
      result.low_price = price;
      result.min_time = tick_time;
      result.min_seconds = (int)(tick_time - candle_start);
     }
   }

  result.success = true;
  return result;
 }

//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
const bool TESTER_FLAG = Tester();

#endif
//+------------------------------------------------------------------+