// run once in main loop, handles reading pin vals
// setting heater on/off
void SlowCooker::loop(){
  m_lastLidState = m_lidState;
  m_lidState = digitalRead(m_lidSwitchPin);
  m_currentTemp = readTemp(); // float in C

  if(m_state == STATE_NOT_COOKING)
    return;
  
  if(calcHeaterState()){
    if(!m_heaterActive){
      Serial.println(F("Turning Heater On"));
      m_heaterOnTime = millis();
    }
    setHeaterState(true);
  }else{
    if(m_heaterActive){
      Serial.println(F("Turning Heater Off"));
      m_heaterOnTime = millis();
    }
    setHeaterState(false);
  }
  
  
  // check if cook is finished based on start time.
  // if cook time is zero then it will run forever!!!
  if(m_cookTime != 0){
    long sLeft = (m_cookTime * 60) - ((millis() - m_timeCookStarted)/1000);
    if(sLeft <= 0){
      stopCook();
      m_eventCallback(EVENT_COOK_END);
    }
  }

  // send event if lid has been opened or closed.
  if(m_lastLidState && !m_lidState){
    m_eventCallback(EVENT_LID_CLOSED);
  }else if(!m_lastLidState && m_lidState){
    m_eventCallback(EVENT_LID_OPENED);
  }

}
bool GHOST_CallbackEventConsumer::processEvent(GHOST_IEvent* event)
{
	return m_eventCallback((GHOST_EventHandle)event, m_userData) != 0;
}
void SocketClientBase::ProcessReceivedBytes()
{
    if(m_processingBuffer->Length() > 0)
    {
        uint16 packetSize = m_processingBuffer->Get<uint16>(2);
        while(m_processingBuffer->Length() < packetSize && m_receiveQueue.size() > 0)
        {
            m_processingBuffer->Add(m_receiveQueue.front());
            m_receiveQueue.pop();
        }

        if(m_processingBuffer->Length() == packetSize)
        {
            if(m_eventCallback != NULL)
            {
                m_eventCallback(this, CEV_PACKET_RECEIVED, &m_eventCallback);
            }
            m_processingBuffer = Buffer_ptr(new Buffer());
        }

        if(m_receiveQueue.size() > 0)
        {
            ProcessReceivedBytes();
        }
    }
    else
    {
        if(m_receiveQueue.size() > 11)
        {
            for(int i = 0; i < 12; i++)
            {
                m_processingBuffer->Add(m_receiveQueue.front());
                m_receiveQueue.pop();
            }

            crypto::CryptEngine::GetInstance_ptr()->XorDecryptPacketHeader(m_processingBuffer->Data());

            uint16 packetSize = m_processingBuffer->Get<uint16>(2) & ~(PACKET_TYPE_NORMAL | PACKET_TYPE_COMPRESSED);
            while(m_processingBuffer->Length() < packetSize && m_receiveQueue.size() > 0)
            {
                m_processingBuffer->Add(m_receiveQueue.front());
                m_receiveQueue.pop();
            }

            if(m_processingBuffer->Length() == packetSize)
            {
                crypto::CryptEngine::Cryptkey key;
                m_processingBuffer->GetPack(key, 4);
                crypto::CryptEngine::GetInstance_ptr()->XorDecryptPacketBody(m_processingBuffer->Data(), m_processingBuffer->Length(), key);
                if(m_eventCallback != NULL)
                {
                    m_eventCallback(this, CEV_PACKET_RECEIVED, &m_processingBuffer);
                }
                m_processingBuffer = Buffer_ptr(new Buffer());
            }

            if(m_receiveQueue.size() > 0)
            {
                ProcessReceivedBytes();
            }
        }
    }
}