// import a library for an LCD
#include <LiquidCrystal.h>

float readDistanceCM();
void writeLCDMsg();
void createSpecialCharacters();

// LCD setup
const int RS = 11,
			E = 12,
			D4 = 6,
			D5 = 5,
			D6 = 4,
			D7 = 3;
LiquidCrystal lcd(RS,E,D4,D5,D6,D7);

const int LCD_COLS = 16;
const int LCD_ROWS = 2;
const int LCD_2_ROW_START_COL = 7;
const int LCD_1_ROW_SENSOR_START_COL = 12;


// pins declarations
const int RED_LED_PIN = 8;
const int GREEN_LED_PIN = 7;

const int RED_BTN_PIN = 2;

//const int RELAY_PIN = 7;

const int SENSOR_TRIG_PIN = 9;
const int SENSOR_ECHO_PIN = 10;


// arrays with pin numbers
const int LED_PIN_NRS[] = {RED_LED_PIN, GREEN_LED_PIN};
//const int BTN_PIN_NRS[] = {RED_BTN_PIN};
const char *const PIN_COLORS[] = {"red", "green"};
const char *const PIN_COLORS_PL[] = {"czerwony", "zielony"};
int ledStates[] = {0, 0};
const char *const DISTANCE_STATES[] = {"Daleko", "Blisko", "Bardzo blisko"};
// length counter for the above 
const int AMOUNT_OF_PINS_USED = (sizeof(LED_PIN_NRS) / sizeof(LED_PIN_NRS[0]));


// diodes counter
int x = 0;
// init diode status
int shouldLightOn = 0;
//int RELAY_STATE = 0;

int currentDistance = 0;


// time counter initial values
unsigned long previousMillis = 0;
const long INTERVAL = 100;
unsigned long currentMillis = 0;



const byte a_[8] = { //ą
  B00000,
	B01110,
  B00001,
  B01111,
  B10001,
  B01111,
  B00010,
  B00001,
};
const byte c_[8] = { //ć
  B00010,
  B00100,
  B01110,
  B10000,
  B10000,
  B10001,
  B01110,
  B00000,
};
const byte e_[8] = { //ę
  B00000,
  B01110,
  B10001,
  B11111,
  B10000,
  B01110,
  B00100,
  B00010,
};
const byte l_[8] = { //ł
  B01100,
  B00100,
  B00100,
  B00110,
  B01100,
  B00100,
  B01110,
  B00000,
};
const byte n_[8] = { //ń
	B00010,
  B00100,
  B10110,
  B11001,
  B10001,
  B10001,
  B10001,
  B00000,
};
const byte o_[8] = { //ó
	B00010,
  B00100,
  B01110,
  B10001,
  B10001,
  B10001,
  B01110,
  B00000,
};
const byte s_[8] = { //ś
	B00010,
  B00100,
  B01110,
  B10000,
  B01110,
  B00001,
  B11110,
  B00000,
};
const byte z__[8] = { //ź
  B00010,
  B00100,
  B11111,
  B00010,
  B00100,
  B01000,
  B11111,
  B00000,
};
const byte z_[8] = { //ż
  B00100,
  B00000,
  B11111,
  B00010,
  B00100,
  B01000,
  B11111,
  B00000,
};
const byte heartSymbol[8] = {
  B00000,
  B01010,
  B11111,
  B11111,
  B01110,
  B00100,
  B00000,
  B00000
};
const byte resetCharacter[8] = {
  B00000,B00000,B00000,B000000,B00000,B00000,B00000,B00000
};

void setup() {
  Serial.begin(9600);
  
	createSpecialCharacters();
	// lcd printing init
	lcd.begin(16,2);
	// set cursor at the beginning (col, row)  
  writeLCDMsg();

	// declare using pins
	for (int i = 0; i < AMOUNT_OF_PINS_USED; i++) {
		pinMode(LED_PIN_NRS[i], OUTPUT);
  }
  pinMode(SENSOR_TRIG_PIN, OUTPUT);
  pinMode(SENSOR_ECHO_PIN, INPUT);
  //writeLCDMsg();
}



// main loop for reading buttons' actions
void loop() {
  // default 1 means HIGH and 0 means LOW, so I use ! to convert
  int newShouldLightOn = !digitalRead(RED_BTN_PIN);

	// eliminate blinking & catch change
  if (shouldLightOn != newShouldLightOn) {
    shouldLightOn = newShouldLightOn;
    writeLCDMsg();
  }
  for(int i = 0; i < AMOUNT_OF_PINS_USED; i++) {
    x = i;
    diodePulseToggle();
    //if (shouldResetSecondRow()) lcd2ndRowReset();
	}
}



// switch the light of a diode
// write status on the LCD
void diodePulseToggle() {
  //currentMillis = millis();

  int ledPinNr = LED_PIN_NRS[x];
	int ledState = shouldLightOn;

	// eliminate blinking & catch change
  if(ledState != ledStates[x]){
    digitalWrite(ledPinNr, ledState);
    //lcd2ndRowReset();
    ledStates[x] = ledState;
    //previousMillis = currentMillis;
    /*if ( ledPinNr == relayPin ) {
      RELAY_STATE = digitalRead(relayPin);
      writeLCDMsg();
    }*/
  }
	//delay(2000);
}


// set cursor below the initially written "Light status "
// and write status of the specific diode
void writeLCDMsg() {
	lcd.setCursor(0,0);
  lcd.print("Odczyt odl: ");
	lcd.setCursor(LCD_1_ROW_SENSOR_START_COL, 0);
	/*for(int i = 0; i < String(pinColorsPL[x]).length(); i++){
		char currLetter = pinColorsPL[x][i];
		lcd.setCursor(LCD_2_ROW_START_COL + i, 1);

		if (currLetter == "ł") {
			lcd.write(byte(0));
		} else if (currLetter == "ó") {
			lcd.write(byte(1));
		} else if (currLetter == "ż") {
			lcd.write(byte(2));
		} else {
			lcd.print(pinColorsPL[x][2]);
		}
	}*/  
  writeLCDSensorState();
  //String stringToPrint = String("Przekaźnik: ");
  //      stringToPrint += (RELAY_STATE ? "za" : "wy") + String("łączony");
  //Serial.println(stringToPrint);
	//lcd.print(stringToPrint);
}


// return a boolean saying whether to reset the 2nd row
// if a second has passed and the text is still visible on the LCD
/*bool shouldResetSecondRow(){
  if (!ledStates[x] && lastLight == x) {
    int millisDifference = currentMillis-previousMillis;
    return millisDifference >= interval;
  } else {
    return false;
  }
}*/


void writeLCDSensorState() {
// check if btn is pushed
  lcd.print("w");
  if(shouldLightOn) {
    lcd.write(byte(1));
    lcd.print(". ");
  } else {
    lcd.print("y");
    lcd.write(byte(1));
  lcd.print(".");
  }
}


void lcd2ndRowReset() {
	lcd.setCursor(0, 1);
	lcd.print("                ");
}


void createSpecialCharacters() {
	// maximum is 0 - 7
  // reset character to avoid problem
  // with displaying letters
  // after e.g. changing their index nr
	lcd.createChar(0, resetCharacter);
	lcd.createChar(0, a_);

	//lcd.createChar(, resetCharacter);
	//lcd.createChar(, c_);

	//lcd.createChar(, resetCharacter);
	//lcd.createChar(, e_);

	lcd.createChar(1, resetCharacter);
	lcd.createChar(1, l_);

	//lcd.createChar(, resetCharacter);
	//lcd.createChar(, n_);

	//lcd.createChar(2, resetCharacter);
	//lcd.createChar(2, o_);

	lcd.createChar(2, resetCharacter);
	lcd.createChar(2, s_);

	//lcd.createChar(4, resetCharacter);
	//lcd.createChar(4, z__);

	//lcd.createChar(2, resetCharacter);
	//lcd.createChar(2, z_);

	lcd.createChar(3, resetCharacter);
	lcd.createChar(3, heartSymbol);
  
  //lcd.write(byte(0));
  //lcd.write(byte(1));
  //lcd.write(byte(2));
  //lcd.write(byte(3));
  //lcd.write(byte(4));
  //lcd.write(byte(5));
  //lcd.write(byte(6));
  //lcd.write(byte(7));
}