#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;
}
//*******************************************************************

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()
{
  tipo=0;
}
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()
{
  for(int i=0; i<des.n; i++)
  {
    des.Get(i)->Exe(vars, &act, &caus);
  }
  //desmarca Var de volatiles
  vars->ResetVolatileVar();
}