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

//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
namespace TSN
{
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
#define BIGUINTEGER_BY_LEO_OP_WBITS(OP) \
  ulong v[];\
  const int max = (m_v_s > b.m_v_s ? m_v_s : b.m_v_s);\
  ArrayResize(v, max);\
  if(max == m_v_s)\
   {\
    for(int i = 0; i < b.m_v_s; i++)\
      v[i] = m_v[i] OP b.m_v[i];\
    for(int i = b.m_v_s; i < max; i++)\
      v[i] = m_v[i] OP 0;\
   }\
  else\
   {\
    for(int i = 0; i < m_v_s; i++)\
      v[i] = m_v[i] OP b.m_v[i];\
    for(int i = m_v_s; i < max; i++)\
      v[i] = b.m_v[i] OP 0;\
   }\
  return BigUInteger(v, max);

//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
// maximo numero a represetar = 2^31-1 (INT MAX) elementos * 64bits = 137438953408  este es el maximo numero de bits
// que peude tener un numero dado que un array como maximo tamaño dtiene INT_MAX elementos no peude tener mas
// y como cada elemtnos es un uint64_t entonces se peude repenstart ese numero * 64 bits

//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
struct  BigUInteger
 {
  //---
  ulong              m_v[];
  int                m_v_s;


  //---
                     BigUInteger(const int vs_8);
  // raw se transfiere (swaping)
                     BigUInteger(ulong& v[], const int vs_8);



  //----
  BigUInteger        operator+(const BigUInteger& b);
  BigUInteger        operator-(const BigUInteger& b);
  BigUInteger        operator*(const BigUInteger& b);
  BigUInteger        operator/(const BigUInteger& b);
  BigUInteger        operator%(const BigUInteger& b);

  //---
  BigUInteger        operator&(const BigUInteger& b);
  BigUInteger        operator|(const BigUInteger& b);
  BigUInteger        operator^(const BigUInteger& b);

  // left
  BigUInteger        operator<<(const uchar b);
  BigUInteger        operator<<(const ushort b);
  BigUInteger        operator<<(const uint b);
  BigUInteger        operator<<(const ulong b);
  BigUInteger        operator<<(const char b);
  BigUInteger        operator<<(const short  b);
  BigUInteger        operator<<(const int b);
  BigUInteger        operator<<(const long b);

  // right
  BigUInteger        operator>>(const uint b);

  //---
  BigUInteger        operator~();
 };

//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
BigUInteger BigUInteger::operator&(const BigUInteger& b)
 {
//---
  ulong v[];
  const int l = (m_v_s > b.m_v_s ? b.m_v_s : m_v_s);;
  ArrayResize(v, l);

//--- op
  for(int i = 0; i < l; i++)
    v[i] = m_v[i] & b.m_v[i];
// los bits sobranods serian x & 0 = 0 (no cuentan)

//---
  return BigUInteger(v, l);
 }

//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
BigUInteger BigUInteger::operator|(const BigUInteger& b)
 {
  BIGUINTEGER_BY_LEO_OP_WBITS( |)
 }

//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
BigUInteger BigUInteger::operator^(const BigUInteger& b)
 {
  BIGUINTEGER_BY_LEO_OP_WBITS(^)
 }

//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
// solo para uint bien rexplicamdo
BigUInteger BigUInteger::operator<<(uint b)
 {
//---
// a / 64 = a / (8 * 8) =  a / (2^3 * 2^3)  = a / (2^6)
// cuantas palrbas habra qeu mover extra (osea uqe no caban en un multipll)
  const int els = int(b >> 6); // b / 64
  const int els_sob = int(b & 63);  // % 64
//---
  ulong v[];
// suma + 1 en caso haya sobrante (osea digmoas se mueve 12 % 8 = 4 mas 1 comp´leto)
// a esto le sumamos el numero de (EL) que tenemos ahora mismo pero cuidado
// tenemos difenreis uniddades
// popr ejemplo si tenemos 128 bits de numero y queremos demzplacar 64 bits
// el numero tamaño serta 128+64 bits pero entre 8 pero hay un tema si hay sobrate tenmos que aumentar
// Por ejemplo con esta formula si quermos mover 70 bits en ese 128 seri aasi
  const int vs = els + (els_sob > 0) + m_v_s;
// s=SLOTS
// VS = 1 (64) + 1 (6 sobro 6 y como es mayo r a 0) + 2 (128)
  ArrayResize(v, vs);
  ArrayInitialize(v, 0);
//---
  int w = els + 1; // siguiente lo demas 0
  ulong overflow = 0;
//--- Todo loq eu qeuepe aqui
  for(int l = 0; l < m_v_s; l++)
   {
    const ulong y = m_v[l++];
    //
    v[w++] = (y << els_sob) | overflow;
    // el overflow lo (que sale) y ya no cabe aqui
    // lo guasrdmos en un temporal
    overflow = y >> (64 - els_sob);
   }
//--- termionamos con el overflow
  if(overflow)
   {
    // en caso haya overflow lo ponemos en la ultiam poscino de lectrau
    v[w] = overflow;
   }
//--- return
  return BigUInteger(v, vs);
 }

//----- macro general
#define BIGUINTEGER_BY_LEO_OP_LEFT_DEZ(TYPE) \
BigUInteger BigUInteger::operator<<(TYPE b)\
 {\
  const int els = int(b >> 6);  \
  const int els_sob = int(b & 63);   \
  ulong v[];\
  const int vs = els + (els_sob > 0) + m_v_s;\
  ArrayResize(v, vs);\
  ArrayInitialize(v, 0);\
  int w = els + 1;  \
  ulong overflow = 0;\
  for(int l = 0; l < m_v_s; l++)\
   {\
    const ulong y = m_v[l++];\
    v[w++] = (y << els_sob) | overflow;\
    overflow = y >> (64 - els_sob);\
   }\
  if(overflow)\
   {\
    v[w] = overflow;\
   }\
  return BigUInteger(v, vs);\
  }

//----- especializados
BIGUINTEGER_BY_LEO_OP_LEFT_DEZ(uchar)
BIGUINTEGER_BY_LEO_OP_LEFT_DEZ(ushort)
BIGUINTEGER_BY_LEO_OP_LEFT_DEZ(ulong)
BIGUINTEGER_BY_LEO_OP_LEFT_DEZ(char)
BIGUINTEGER_BY_LEO_OP_LEFT_DEZ(short)
BIGUINTEGER_BY_LEO_OP_LEFT_DEZ(int)
BIGUINTEGER_BY_LEO_OP_LEFT_DEZ(long)

//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
BigUInteger BigUInteger::operator>>(uint b)
 {


 }


}
//+------------------------------------------------------------------+
//