#include <RemoteReceiver.h>
#include <RemoteTransmitter.h>

#include <SensorReceiver.h>
#include <SensorTransmitter.h>

#include <InterruptChain.h>

#define SEN_WAIT_LED 3
#define REM_WAIT_LED 4
#define SEN_TRANS_LED 5
#define REM_TRANS_LED 13

#define TRANSMITTER_PIN 11

BlokkerTransmitter blokkerTransmitter(11);
ActionTransmitter actionTransmitter(11);
KaKuTransmitter kakuTransmitter(11);

unsigned long actionAOn = actionTransmitter.getTelegram(1,'A',true);
unsigned long actionAOff = actionTransmitter.getTelegram(1,'A',false);
unsigned long actionBOn = actionTransmitter.getTelegram(1,'B',true);
unsigned long actionBOff = actionTransmitter.getTelegram(1,'B',false);
unsigned long actionCOn = actionTransmitter.getTelegram(1,'C',true);
unsigned long actionCOff = actionTransmitter.getTelegram(1,'C',false);
unsigned long actionDOn = actionTransmitter.getTelegram(1,'D',true);
unsigned long actionDOff = actionTransmitter.getTelegram(1,'D',false);

unsigned long blokkerDOn = blokkerTransmitter.getTelegram(8,true);
unsigned long blokkerDOff = blokkerTransmitter.getTelegram(8,false);

unsigned long kakuO10On = kakuTransmitter.getTelegram('O',10,true);
unsigned long kakuO10Off = kakuTransmitter.getTelegram('O',10,false);

void setup() {
  pinMode(SEN_WAIT_LED, OUTPUT);
  pinMode(REM_WAIT_LED, OUTPUT);
  pinMode(SEN_TRANS_LED, OUTPUT);
  pinMode(REM_TRANS_LED, OUTPUT);

  // When no signal has been received, the LED is lit.
  digitalWrite(SEN_TRANS_LED, HIGH);

  RemoteReceiver::init(-1, 3, processCode);

  // Again, interrupt -1 to indicate you will call the interrupt handler with InterruptChain
  SensorReceiver::init(-1, retransmit);

  // On interrupt, call the interrupt handlers of remote and sensor receivers
  InterruptChain::addInterruptCallback(0, RemoteReceiver::interruptHandler);
  InterruptChain::addInterruptCallback(0, SensorReceiver::interruptHandler);
}

void loop() {
}

void processCode(unsigned long receivedCode, unsigned int period) {
  // Make RemoteReceiver the exclusive interrupt handler.
  // RemoteReceiver::isReceiving() requires "normal" handling,
  // but interference from SensorReceiver, which messes with interrupts
  // as well, should be avoided.
  attachInterrupt(0, RemoteReceiver::interruptHandler, CHANGE);

  interrupts();

  digitalWrite(REM_WAIT_LED, HIGH);
  // Wait for a free ether
  while(RemoteReceiver::isReceiving());
  digitalWrite(REM_WAIT_LED, LOW);

  // Ether is free.

  // Flash LED when transmitting.
  digitalWrite(REM_TRANS_LED, HIGH);

  for (byte i = 0; i < 2; i++) {
    if (RemoteTransmitter::isSameCode(actionAOn, receivedCode)) {
      blokkerTransmitter.sendSignal(5,true);
    } else if (RemoteTransmitter::isSameCode(actionAOff, receivedCode)) {
      blokkerTransmitter.sendSignal(5,false);
    } else if (RemoteTransmitter::isSameCode(actionBOn, receivedCode)) {
      blokkerTransmitter.sendSignal(6,true);
    } else if (RemoteTransmitter::isSameCode(actionBOff, receivedCode)) {
      blokkerTransmitter.sendSignal(6,false);
    } else if (RemoteTransmitter::isSameCode(actionCOn, receivedCode)) {
      blokkerTransmitter.sendSignal(7,true);
    } else if (RemoteTransmitter::isSameCode(actionCOff, receivedCode)) {
      blokkerTransmitter.sendSignal(7,false);
    } else if (RemoteTransmitter::isSameCode(actionDOn, receivedCode) || RemoteTransmitter::isSameCode(blokkerDOn, receivedCode) || RemoteTransmitter::isSameCode(kakuO10On, receivedCode)) {
      blokkerTransmitter.sendSignal(5,true);
      blokkerTransmitter.sendSignal(6,true);
      blokkerTransmitter.sendSignal(7,true);
    } else if (RemoteTransmitter::isSameCode(actionDOff, receivedCode) || RemoteTransmitter::isSameCode(blokkerDOff, receivedCode) || RemoteTransmitter::isSameCode(kakuO10Off, receivedCode)) {
      blokkerTransmitter.sendSignal(5,false);
      blokkerTransmitter.sendSignal(6,false);
      blokkerTransmitter.sendSignal(7,false);
    }
  }

  // Flash LED when transmitting.
  digitalWrite(REM_TRANS_LED, LOW);

  noInterrupts();

  // Re-enable the interrupt chain.
  InterruptChain::enable(0);
}


void retransmit(byte *data) {
  // Data received

  // Wait a second after a receiving. There's little point for decoding and sending the same signal multiple times.
  InterruptChain::disable(0);
  interrupts(); // delay() requires that interrupts are enabled

  digitalWrite(SEN_WAIT_LED, HIGH);
  delay(1000);
  digitalWrite(SEN_WAIT_LED, LOW);

  // Flash LED when transmitting.
  digitalWrite(SEN_TRANS_LED, HIGH);

  // Transmit signal. Note: this is a static method, no object required!
  SensorTransmitter::sendPackage(TRANSMITTER_PIN, data);

  digitalWrite(SEN_TRANS_LED, LOW);

  noInterrupts();
  InterruptChain::enable(0);
}