//INCLUDE LIBRARIES:-------------------------------------------------------------
#include <ClickButton.h>

// DEFINE INITIAL FUNCTION STATES: ----------------------------------------------
boolean runlightsActive = true;
boolean britesActive = false;
boolean brakeActive = false;
boolean leftTurnActive = false;
boolean rightTurnActive = false;
boolean hornActive = false;
boolean startActive = false;
boolean suspendRunlights = false;
boolean parkActive = false;
boolean hazzardActive = false;
//boolean killActive = false;
boolean headlightActive = false;


// DEFINE INPUT PINS: -----------------------------------------------------------//
#define frontCtrlPin A0
#define britesCtrlPin 10
#define brakeCtrlPin 11
#define leftCtrlPin 12
#define rightCtrlPin A0
#define hornCtrlPin A1
#define startCtrlPin A3
#define headlightCtrlPin A4

// DEFINE CLICKBUTTONS


ClickButton britesButton (britesCtrlPin, LOW, CLICKBTN_PULLUP);
ClickButton brakeButton (brakeCtrlPin, LOW, CLICKBTN_PULLUP);
ClickButton leftButton (leftCtrlPin, LOW, CLICKBTN_PULLUP);
ClickButton rightButton (rightCtrlPin, LOW, CLICKBTN_PULLUP);
ClickButton hornButton (hornCtrlPin, LOW, CLICKBTN_PULLUP);
ClickButton startButton (startCtrlPin, LOW, CLICKBTN_PULLUP);
ClickButton headlightButton (headlightCtrlPin, LOW, CLICKBTN_PULLUP);

// DEFINE RELAY PINS: -----------------------------------------------------------


#define runlightsPin 2
#define britesPin 3
#define brakePin 4
#define leftTurnPin 5
#define rightTurnPin 6
#define hornPin 7
#define startPin 8
//#define killPin
#define headlightPin 9


// DEFINE INITIAL RELAY STATES FOR TIMED FUNCTIONS: -----------------------------
int leftLight = HIGH;
int rightLight = HIGH;


// DEFINE INITIAL MS COUNT FOR FUNCTIONS: ---------------------------------------
// will store last time LED was updated OR switch debonce
unsigned long leftTurnMs = 0;
unsigned long rightTurnMs = 0;
unsigned long hazzardMs = 0;


unsigned long britesCtrlMs = 0;
unsigned long brakeCtrlMS = 0;
unsigned long leftCtrlMS = 0;
unsigned long rightCtrlMS = 0;
unsigned long hornCtrlMS = 0;
unsigned long startCtrlMS = 0;
unsigned long headlightCtrlMS = 0;







// DEFINE CONSTANT INTERVALS:----------------------------------------------------
#define turnInterval 500
#define hazzardInterval 200






// SETUP ///////////////////////////////////////////////////////////////////////


void setup() {


// SET INITIAL RELAY STATES TO AVOID MISFIRES AT STARTUP:------------------------
  digitalWrite (runlightsPin,LOW);
  digitalWrite (britesPin,HIGH);
  digitalWrite (brakePin,HIGH);
  digitalWrite (rightTurnPin, rightLight);
  digitalWrite (leftTurnPin, leftLight);
  digitalWrite (hornPin,HIGH);
  digitalWrite (startPin, HIGH);
  //digitalWrite (killPin, HIGH);
  digitalWrite (headlightPin,HIGH);

/* / ACTIVATE INPUT BUTTION PULLUPS:-----------------------------------------------
  digitalWrite (britesCtrlPin, HIGH);
  digitalWrite (brakeCtrlPin, HIGH);
  digitalWrite (leftCtrlPin, HIGH);
  digitalWrite (rightCtrlPin, HIGH);
  digitalWrite (hornCtrlPin, HIGH);
  digitalWrite (startCtrlPin, HIGH);
  digitalWrite (headlightCtrlPin,HIGH);   */

/* // DEFINE INPUT PINS:------------------------------------------------------------
  //pinMode(frontCtrlPin,INPUT);
  pinMode(britesCtrlPin,INPUT_PULLUP);
  pinMode(brakeCtrlPin,INPUT_PULLUP);
  pinMode(leftCtrlPin,INPUT_PULLUP);
  pinMode(rightCtrlPin,INPUT_PULLUP);
  pinMode(hornCtrlPin,INPUT_PULLUP);
  pinMode(startCtrlPin,INPUT_PULLUP);
  pinMode(headlightCtrlPin,INPUT_PULLUP);  */





  // Setup button timers (all in milliseconds / ms)
  // (These are default if not set, but changeable for convenience)
  //button1.debounceTime   = 20;   // Debounce timer in ms
  brakeButton.multiclickTime = 1000;  // Time limit for multi clicks
  startButton.longClickTime  = 1500; // time until "held-down clicks" register

// DEFINE OUTPUT PINS:-----------------------------------------------------------
  pinMode(runlightsPin, OUTPUT);
  pinMode(britesPin, OUTPUT);
  pinMode(brakePin, OUTPUT);
  pinMode(leftTurnPin, OUTPUT);
  pinMode(rightTurnPin, OUTPUT);
  pinMode(hornPin, OUTPUT);
  pinMode(startPin, OUTPUT);
  //pinMode(killPin, OUTPUT);
  pinMode(headlightPin, OUTPUT);
}




// MAIN LOOP ////////////////////////////////////////////////////////////////////
void loop()
{

// CHECK CONDITIONS FOR EACH FUNCTION STATE AND CALL APPROPRIATE FUNCTION ////////////////////////


readInputSwitches();


if (runlightsActive == true && suspendRunlights == false ){ runlightsOn();}
else{runlightsOff();}

if (britesActive == true){britesOn();}
else{britesOff();}

if (brakeActive == true){brakeLightsOn();}
else{brakeLightsOff();}

if (hornActive == true){hornOn();}
else{hornOff();}


if (startActive == true){
  starterOn();
  suspendRunlights = true;
}
else{
  starterOff();
  suspendRunlights = false;
}

if (leftTurnActive == true){
  leftTurnOn();
  rightTurnActive = false;
  parkActive = false;
  hazzardActive = false;
}
else if (rightTurnActive == true){
  rightTurnOn();
  leftTurnActive = false;
  parkActive = false;
  hazzardActive = false;
}
else if (hazzardActive == true){
  hazzardFlashers();
  leftTurnActive = false;
  rightTurnActive = false;
  parkActive = false;
}
else if (parkActive == true){
  parkingLightsOn();
  leftTurnActive = false;
  rightTurnActive = false;
  hazzardActive = false;
}
else {blinkersOff();}

if (headlightActive == true){headlightOn();}
else{headlightOff();}

  // TEST SEQUENCE TO CHECK FUNCTIONS WITHOUT BUTTONS


//leftTurnActive = true;


//rightTurnActive = true;


//hazzardActive = true;


//parkActive = true;


//brakeActive = true;


//headlightOn();


//britesActive = true;


//runlightsOff();


//hornActive = true;


//startActive = true;


}






//FUNCTIONS///////////////////////////////////////////////////////////////////




// READ INPUT SWITCHES


void readInputSwitches(){

//WITH CLICKBUTTON


britesButton.Update();
if (britesButton.depressed == true)britesActive = !britesActive;


leftButton.Update();
if (leftButton.depressed == true) leftTurnActive = !leftTurnActive;

rightButton.Update();
if (rightButton.depressed == true) rightTurnActive = !rightTurnActive;


brakeButton.Update();
if (brakeButton.depressed == true){brakeActive = true;}
else brakeActive = false;


hornButton.Update();
if (hornButton.depressed == true){hornActive = true;}
else hornActive = false;


startButton.Update();
if (startButton.depressed == true){startActive = true;}
else startActive = false;

headlightButton.Update();
if (headlightButton.depressed == true){headlightActive = true;}
else headlightActive = false;

/*  WITHOUT CLICKBUTTON
if (digitalRead (britesCtrlPin) == LOW){britesActive = true;}
else britesActive = false;


if (digitalRead (leftCtrlPin) == LOW){leftTurnActive = true;}
else leftTurnActive = false;


if (digitalRead (rightCtrlPin) == LOW){rightTurnActive = true;}
else rightTurnActive = false;


if (digitalRead (brakeCtrlPin) == LOW){brakeActive = true;}
else brakeActive = false;


if (digitalRead (hornCtrlPin) == LOW){hornActive = true;}
else hornActive = false;


if (digitalRead (startCtrlPin) == LOW){startActive = true;}
else startActive = false;   */


}


// RUNNING LIGHTS: --------------------------------------------------------------


void runlightsOn(){
  digitalWrite(runlightsPin, LOW);
}


void runlightsOff(){
  digitalWrite(runlightsPin, HIGH);
}




// HIGHBEAM: -------------------------------------------------------------------


void britesOn(){
  digitalWrite(britesPin, LOW);
}


void britesOff(){
  digitalWrite(britesPin, HIGH);
}




// BRAKE LIGHTS: ---------------------------------------------------------------


void brakeLightsOn(){
  digitalWrite(brakePin, LOW);
}


void brakeLightsOff(){
  digitalWrite(brakePin, HIGH);
}




// LEFT TURN SIGNAL: ---------------------------------------------------------


void leftTurnOn(){
  unsigned long currentMs = millis();
  if(currentMs - leftTurnMs >= turnInterval) {
    // save the last time you blinked the LED
    leftTurnMs = currentMs;


    // if the LED is off turn it on and vice-versa:
    if (leftLight == HIGH)
      leftLight = LOW;
    else
      leftLight = HIGH;


    // set the LED with the ledState of the variable:
    digitalWrite(leftTurnPin, leftLight);
    digitalWrite(rightTurnPin, HIGH);
  }
}




// RIGHT TURN SIGNAL: ---------------------------------------------------------


void rightTurnOn(){
  unsigned long currentMs = millis();
  if(currentMs - rightTurnMs >= turnInterval) {
    // save the last time you blinked the LED
    rightTurnMs = currentMs;


    // if the LED is off turn it on and vice-versa:
    if (rightLight == HIGH)
      rightLight = LOW;
    else
      rightLight = HIGH;


    // set the LED with the ledState of the variable:
    digitalWrite(rightTurnPin, rightLight);
    digitalWrite(leftTurnPin, HIGH);
  }
}




// HAZZARD FLASHERS: -----------------------------------------------------------


void hazzardFlashers(){
  unsigned long currentMs = millis();
  if(currentMs - hazzardMs >= hazzardInterval) {
    // save the last time you blinked the LED
    hazzardMs = currentMs;


    // if the LED is off turn it on and vice-versa:
    if (rightLight == HIGH)
      rightLight = LOW;
    else
      rightLight = HIGH;


    if (leftLight == HIGH)
      leftLight = LOW;
    else
      leftLight = HIGH;


    // set the LED with the ledState of the variable:
    digitalWrite(rightTurnPin, rightLight);
    digitalWrite(leftTurnPin, leftLight);
  }
}




// PARKING LIGHTS: -------------------------------------------------------------


void parkingLightsOn(){
  digitalWrite(rightTurnPin, LOW);
  digitalWrite(leftTurnPin, LOW);
}




// BLINKERS OFF: ---------------------------------------------------------------


void blinkersOff(){
  digitalWrite(rightTurnPin, HIGH);
  digitalWrite(leftTurnPin, HIGH);
}




// HORN: ------------------------------------------------------------------------


void hornOn(){
  digitalWrite(hornPin, LOW);
}


void hornOff(){
  digitalWrite(hornPin, HIGH);
}




// STARTER: ---------------------------------------------------------------------


void starterOn(){
  digitalWrite(startPin, LOW);
}


void starterOff(){
  digitalWrite(startPin, HIGH);
}




/* / KILLSWITCH: ------------------------------------------------------------------


void killOn(){
  digitalWrite(killPin, LOW);
}


void killOff(){
  digitalWrite(killPin, HIGH);
}
*/




// HEADLIGHT: ------------------------------------------------------------------


void headlightOn(){
  digitalWrite(headlightPin, LOW);
}


void headlightOff(){
  digitalWrite(headlightPin, HIGH);
}



//  END OF CODE (FOR NOW)