/**
   Arduino Electronic Safe

   Copyright (C) 2020, Uri Shaked.
   Released under the MIT License.
*/

#include <Keypad.h>
#include "controller.h"
#include "controllerHelper.h"
#include "debuger.h"

#define RELAY_PIN 4
#define FLOW_SENSOR_PIN 2
#define FLOWER_SENSOR_PIN 3

#define KEYPAD_ROWS 4
#define KEYPAD_COLS 4

enum MENU
{
  MAIN,
  START,
  CALIBRATION,
};

void counter();
void start2MainMenu();
void flowerStop();

Controller controller( FLOWER_SENSOR_PIN, RELAY_PIN, start2MainMenu, flowerStop, FLOW_SENSOR_PIN, counter);

void counter()
{
  controller.countImpulses();
}
void flowerStop()
{
  controller.stop();
}

/* Keypad setup */

byte rowPins[KEYPAD_ROWS] = {5, 8, 6, 7};
byte colPins[KEYPAD_COLS] = {A3, A2, A1, A0};
char keys[KEYPAD_ROWS][KEYPAD_COLS] = {
  {'1', '2', '3', 'A'},
  {'4', '5', '6', 'B'},
  {'7', '8', '9', 'C'},
  {'*', '0', '#', 'D'}
};

unsigned long timebefore = 0;
String s1;
String calibrationString;
MENU menu;

void start2MainMenu()
{
  menu = MENU::MAIN;
}

void getValue(char key, String& s)
{
  if (isdigit(key))
  {
    if (s[0] == '0')
    {
      s[0] = key;
      return;
    }
    s += key; // todo check if arduino has string::append funtion, it's faster than +=
  }
}
void keyManagerStart(const char key, MENU& menu, const Controller& con)
{
  switch (key)
  {
    case 'A':
      {
        Serial.print("A:");
        con.stop();
        menu = MENU::MAIN;
        break;
      }
    default:
      {
        break;
      }
  }
}
void keyManagerConfiguration(const char key, String& s, MENU& menu, const Controller& con)
{
  switch (key)
  {
    case 'A':
      {
        Serial.print("A saved To mem");
        uint32_t val2mem = static_cast<uint32_t>(s.toInt());
        controller.setCalibration2Memmory(val2mem);
        Serial.println(con.getCalibration());
        break;
      }
      case 'C':
      {
        Serial.println("Clean");
        s="0";
        break;
      }
    case 'D':
      {
        Serial.println("Go to main");
        menu = MENU::MAIN;
        break;
      }
    default:
      {
        getValue(key, s);
        //here print limit of liters
        Serial.print("new val: ");
        Serial.println(s);
        break;
      }
  }
}
void keyManagerMain(const char key, String& s, MENU& menu, const Controller& con)
{
  switch (key)
  {
    case 'A':
      {
        Serial.print("A:");
        Serial.println(s.toInt());
        uint32_t val = static_cast<uint32_t>(abs(s.toInt()));
        if(val <= con.maxLiters())
        {
          menu = MENU::START;
          con.start(val);
        }
        else
        {
            Serial.println("too hight Value");
        }
        break;
      }

    case 'B':
      {
        Serial.println("C");
        s = "0"; //todo it's not the best way
        break;
      }
    case 'C':
      {
        Serial.println("B");
        con.reset();
        break;
      }
    case 'D':
      {
        Serial.println("D");
        menu = MENU::CALIBRATION;
        break;
      }
    case '*':
      {
        Serial.println("*");
        break;
      }
    case '#':
      {
        Serial.println("#");
        break;
      }
    default:
      {
        getValue(key, s);
        //here print limit of liters
        Serial.println(s);
        break;
      }
  }
}
 
void printMenuStart(const Controller& con)
{
  Serial.print("Total: ");
  Serial.print(con.getLiters());
  Serial.print('/');
  Serial.print(con.getLimitOfLiters());
  Serial.print(" Flow rate (L/h): ");
  Serial.print(con.getFlowRate_h());
  Serial.print(" Flow rate (L/min): ");
  Serial.print(con.getFlowRate_m());
  Serial.print(" Flow rate (L/sec): ");
  Serial.print(con.getFlowRate_s());
  Serial.println();
}



Keypad keypad = Keypad(makeKeymap(keys), rowPins, colPins, KEYPAD_ROWS, KEYPAD_COLS);


void setup() {
  Serial.begin(9600);

  controller.setCalibrationFromMemmory();
  controller.setCalibration2Memmory(1);
}
void keyManager(const char key, String& str, String& calirationStr, const Controller& con, MENU& menu)
{
switch (menu)
  {
    case MENU::MAIN:
      {
        keyManagerMain(key, str, menu, con);

        break;
      }
    case MENU::START:
      {
        keyManagerStart(key, menu, con);
        break;
      }
    case MENU::CALIBRATION:
      {
        keyManagerConfiguration(key, calirationStr, menu, con);
        break;
      }
    default:
      break;
  }
}
void printMenu(const Controller& con, const MENU menu)
{
  switch (menu)
  {
    case MENU::MAIN:
      {
        break;
      }
    case MENU::START:
      {
        printMenuStart(con);
        break;
      }
    case MENU::CALIBRATION:
      {
        break;
      }
    default:
      break;
  }
}

void everySecTic(const Controller& con, const MENU menu)
{
  uint32_t currentTime = millis();
  if (currentTime - timebefore >= 1000)
  {
    con.read(currentTime);
    printMenu(con, menu);

    timebefore = currentTime;
  }
}

void loop() {

  char key = keypad.getKey();

  if (key)
  {
    keyManager(key, s1, calibrationString, controller, menu);
    //add return?
  }
  everySecTic(controller, menu);

}