
#include "MqttDesencadenadorManager.h"



MqttOper::MqttOper()
{
  
}
bool MqttOper::Test(MqttVarManager* vars)
{
  bool res=false;
  switch(oper)
  {
    case(Igual_val_oper):
    {
      MqttVar* v=vars->Get(x);
      if(v->flags & MqttVar::FLOAT_VAR )
        res=val.f==v->val.f;
      else
        res=val.i==v->val.i;
      break;
    }
    case(Menor_val_oper):
    {
      MqttVar* v=vars->Get(x);
      if(v->flags & MqttVar::FLOAT_VAR )
        res=val.f<v->val.f;
      else
        res=val.i<v->val.i;
      break;
    }
    case(Mayor_val_oper):
    {
      MqttVar* v=vars->Get(x);
      if(v->flags & MqttVar::FLOAT_VAR )
        res=val.f>v->val.f;
      else
        res=val.i>v->val.i;
      break;
    }
    default:
      break;
  }
  return res;
}
//*******************************************************************
MqttOperArray::MqttOperArray()
{
  n=0;
}

MqttOper* MqttOperArray:: Get(int i)
{
  return &(data[i]);
}

int MqttOperArray::Add(MqttOper* var)
{
  data[n]=*var;
  n++;
  return n-1;
}
//*******************************************************************
MqttCausa::MqttCausa()
{
  
}
bool MqttCausa::Test(MqttVarManager *vars)
{
  return true;
}
//*******************************************************************
MqttCausaArray::MqttCausaArray()
{
  n=0;
}

MqttCausa* MqttCausaArray:: Get(int i)
{
  return &(data[i]);
}

int MqttCausaArray::Add(MqttCausa* var)
{
  data[n]=*var;
  n++;
  return n-1;
}
//*******************************************************************
MqttCausaManager::MqttCausaManager()
{
  
}
bool MqttCausaManager::IsTrue(int icau, MqttVarManager *vars)
{
  return false;
}
int MqttCausaManager::AddCausa(byte tipo)
{
  MqttCausa c;
  c.tipo=tipo;
  return caus.Add(&c);
}
int MqttCausaManager::AddEfecto(int icau,byte tipo, int ivar,  MQTTvalor *val)
{
  MqttCausa* c=caus.Get(icau);
  MqttOper o;
  o.oper=tipo;
  if(val)
  o.val=*val;
  o.x=ivar;
  int ioper=oper.Add(&o);
  if(c->n<=0)
    c->ini=ioper;
  c->n++;
  return ioper;
}
//*******************************************************************

MqttEfecto::MqttEfecto()
{
  
}
void MqttEfecto::Exe(MqttVarManager *vars)
{

    switch((int)tipo)
        {
          case((int)MqttEfecto::InvierteValVar):
          {
             vars->InvierteVar(ia);
            break;
          }
           case((int)MqttEfecto::SetValVar):
          {
            vars->SetVal(ia, val);
            break;
          }
          default:
            break;
        }
}
//*******************************************************************
MqttEfectoArray::MqttEfectoArray()
{
  n=0;
}

MqttEfecto* MqttEfectoArray:: Get(int i)
{
  return &(data[i]);
}

int MqttEfectoArray::Add(MqttEfecto* var)
{
  data[n]=*var;
  n++;
  return n-1;
}
//*******************************************************************
MqttDesencadenador::MqttDesencadenador()
{
  ne=0;
  ic=-1;
  ie=-1;
}
void MqttDesencadenador::Exe(MqttVarManager *vars,  MqttEfectoArray *efe, MqttCausaManager* caus)
{
   /*switch(tipo)
        {
          default:*/
          if(caus->IsTrue(ie,vars))
            efe->Get(ie)->Exe(vars);
          /*  break;
        }*/
}
//*******************************************************************
MqttDesencadenadorArray::MqttDesencadenadorArray()
{
  n=0;
}

MqttDesencadenador* MqttDesencadenadorArray::Get(int i)
{
  return &(data[i]);
}

int MqttDesencadenadorArray::Add(MqttDesencadenador* var)
{
  data[n]=*var;
  n++;
  return n-1;
}
//*******************************************************************
MqttDesencadenadorManager::MqttDesencadenadorManager()
{
  revisa=true;
}

void MqttDesencadenadorManager::OnVarChange(int ivar)
{
  revisa=true;
  //marca Accion--
}

void MqttDesencadenadorManager::inicia( MqttVarManager *v)
{
  vars=v;
}

void MqttDesencadenadorManager::Suscribe()
{
  
}
int MqttDesencadenadorManager::OnMqtt(char* topic, char* payload)
{
  
}

void MqttDesencadenadorManager::loop()
{
  if(revisa)
  {
    revisa=false;
    RevisaDesencadenadores();
  }
}

void MqttDesencadenadorManager::RevisaDesencadenadores()
{
  #ifdef DEBUG_PS

            Serial.println("MqttDesencadenadorManager::RevisaDesencadenadores");
  #endif
  for(int i=0; i<des.n; i++)
  {
    des.Get(i)->Exe(vars, &efec, &caus);
  }
  #ifdef DEBUG_PS

            Serial.println("ResetVolatileVar");
  #endif
  //desmarca Var de volatiles
  vars->ResetVolatileVar();
   #ifdef DEBUG_PS

            Serial.println("RevisaDesencadenadores fin");
  #endif
}
//add---------------------
  int MqttDesencadenadorManager::addDesencadenador(byte tipoCausa)
  {
    #ifdef DEBUG_PS

            Serial.println("MqttDesencadenadorManager::addDesencadenador");
        #endif
    MqttDesencadenador d;
    d.ic=caus.AddCausa(tipoCausa);
    return des.Add(&d);
  }
  int MqttDesencadenadorManager::addEfecto(int ides, byte tipo, char *topic)
  {
     #ifdef DEBUG_PS

            Serial.println("MqttDesencadenadorManager::addEfecto");
        #endif
       MqttDesencadenador *d=des.Get(ides);
       MqttEfecto e;
         #ifdef DEBUG_PS

            Serial.println("addEfecto busca var");
        #endif
       e.ia=vars->GetId(topic);
        #ifdef DEBUG_PS

            Serial.println("addEfecto fin busca var");
        #endif
       e.tipo=tipo;
       int ie=efec.Add(&e);
        #ifdef DEBUG_PS

            Serial.println("addEfecto fin");
        #endif
       if(d->ne<=0)
        d->ie=ie;
       d->ne++;
        #ifdef DEBUG_PS

            Serial.println("addEfecto fin fin");
        #endif
  }
  int MqttDesencadenadorManager::addOperCausaI(int ides, char *topic, byte tipo, byte val )
  {
    #ifdef DEBUG_PS

            Serial.println("MqttDesencadenadorManager::addOperCausaI");
        #endif
    MQTTvalor v;
    v.i=val;
    MqttDesencadenador *d=des.Get(ides);
    int ivar=vars->GetId(topic);
    return caus.AddEfecto(d->ic, tipo, ivar, &v );
  }
  int MqttDesencadenadorManager::addOperCausaF(int ides, char *topic, int tipo, float val )
  {
    #ifdef DEBUG_PS

            Serial.println("MqttDesencadenadorManager::addOperCausaF");
        #endif
    MQTTvalor v;
    v.i=val;
    MqttDesencadenador *d=des.Get(ides);
    int ivar=vars->GetId(topic);
    return caus.AddEfecto(d->ic, tipo, ivar, &v );
  }
  //-------------------
