//This is the code for the "Sensing Pillow"
// This value will store the last time we published an event
long lastPublishedAt = 0;
// this is the time delay before we should publish a new event
// from this device
int publishAfter = 20000;

//setup pins
int bendPin1 = A1; 
int bendPin2 = A2; 
int bendPin3 = A4;
int bendPin4 = A5;
bool backPin = false;
int bendReading;
int bendReading2;
int bendReading3;
int bendReading4;


void setup(void) 
{
    Serial.begin(9600);   // We'll send debugging information via the Serial monitor
    pinMode(bendPin1 , INPUT);
    pinMode(bendPin2 , INPUT);
    pinMode(bendPin3 , INPUT);
    pinMode(bendPin4 , INPUT);
    pinMode(backPin , INPUT);
    Particle.subscribe(  "hugIt/imReady" , handleSharedEvent );
    Particle.subscribe(  "hugIt/imScared" , handleSharedEvent );
}
 
void loop(void) 
{
    int bendReading1 = analogRead(bendPin1);
    Serial.print("Bend1 Analog reading = ");
    Serial.println(bendReading1);
    
    int bendReading2 = analogRead(bendPin2);
    Serial.print("Bend2 Analog reading = ");
    Serial.println(bendReading2);
    
    int bendReading3 = analogRead(bendPin3);
    Serial.print("Bend3 Analog reading = ");
    Serial.println(bendReading3);
    
    int bendReading4 = analogRead(bendPin4);
    Serial.print("Bend4 Analog reading = ");
    Serial.println(bendReading4);
    
    if(bendReading1 > 1000 || bendReading2 > 1000 || bendReading3 > 1000 || bendReading4 > 1000 )
    {
        publishImScared();//sends "ready" signal
        delay(100);// delay for a bit
    }
      
    if(backPin = TRUE)
    {
        publishImReady();//sends signal that you are scared
        delay(30000);
    }
}

void publishImReady()
{
  // Remember that a device can publish at rate of about 1 event/sec,
  // with bursts of up to 4 allowed in 1 second.
  // Back to back burst of 4 messages will take 4 seconds to recover.
  // So we want to limit the amount of publish events that happen.

  // check that it's been 10 secondds since our last publish
  if( lastPublishedAt + publishAfter < millis() )
  {
      // Remember our subscribe is matching  "db2018/paired/"
      // We'll append the device id to get more specific
      // about where the event came from

      // System.deviceID() provides an easy way to extract the device
      // ID of your device. It returns a String object of the device ID,
      // which is used to identify your device.

      String eventName = "hugIt/imReady" + System.deviceID();

      // now we have something like "diot/2019/paired/0123456789abcdef"
      // and that corresponds to this devices info

      // then we share it out
      Particle.publish( eventName, "I'm READY" );

      // And this will get shared out to all devices using this code

      // we just pubished so capture this.
      lastPublishedAt = millis();
  }

}

void publishImScared()
{
  // Remember that a device can publish at rate of about 1 event/sec,
  // with bursts of up to 4 allowed in 1 second.
  // Back to back burst of 4 messages will take 4 seconds to recover.
  // So we want to limit the amount of publish events that happen.

  // check that it's been 10 secondds since our last publish
  if( lastPublishedAt + publishAfter < millis() )
  {
      // Remember our subscribe is matching  "db2018/paired/"
      // We'll append the device id to get more specific
      // about where the event came from

      // System.deviceID() provides an easy way to extract the device
      // ID of your device. It returns a String object of the device ID,
      // which is used to identify your device.

      String eventName = "hugIt/imScared" + System.deviceID();

      // now we have something like "diot/2019/paired/0123456789abcdef"
      // and that corresponds to this devices info

      // then we share it out
      Particle.publish( eventName, "I'm SCARED" );

      // And this will get shared out to all devices using this code

      // we just pubished so capture this.
      lastPublishedAt = millis();
  }

}

// Our event handlde requires two bits of information
// This gives us:
// A character array that consists of the event name
// A character array that contains the data published in the event we're responding to.
void handleSharedEvent(const char *event, const char *data)
{
    // Now we're getting ALL events published using "db2018/paired/"
    // This includes events from this device.
    // So we need to ignore any events that we sent.

    // Let's check the event name
    String eventName = String( event ); // convert to a string object
    // This gives us access to a bunch of built in methods
    // Like indexOf()
    // Locates a character or String within another String.
    // By default, searches from the beginning of the String,
    // but can also start from a given index,
    // allowing for the locating of all instances of the character or String.
    // It Returns: The index of val within the String, or -1 if not found.

    // We can use this to check if our event name contains the
    // id of this device

    String deviceID = System.deviceID();

    // device id = 0123456789abcdef
    // event = "diot/2019/paired/0123456789abcdef"

    if( eventName.indexOf( deviceID ) != -1 ){
      // if we get anything other than -1
      // the event came from this device.
      // so stop doing stuff
      return;
    }
}