#include <WiFi.h>
#include <FirebaseClient.h>
#include <WiFiClientSecure.h>
#include <ArduinoJson.h>
#include <Wire.h>
#include <LiquidCrystal_I2C.h>
#include <Keypad.h>
#include <Adafruit_Fingerprint.h>

#define  touch    4

LiquidCrystal_I2C lcd(0x27,20,4);

const byte ROWS = 4; //four rows
const byte COLS = 3; //three columns
char keys[ROWS][COLS] = {
  {'1','2','3'},
  {'4','5','6'},
  {'7','8','9'},
  {'*','0','#'}
};
byte rowPins[ROWS] = {18, 25, 27,32}; //connect to the row pinouts of the keypad
byte colPins[COLS] = {18, 26, 33}; //connect to the column pinouts of the keypad

Keypad keypad = Keypad( makeKeymap(keys), rowPins, colPins, ROWS, COLS );

HardwareSerial mySerial(2);
Adafruit_Fingerprint finger = Adafruit_Fingerprint(&mySerial);
// USED FOR FIREBASE
#define WIFI_SSID "TEST"
#define WIFI_PASSWORD "test@test"
#define API_KEY "AIzaSyAQRBQOWbZ15E1PX4a-Zp7HIZYrVvd4CVA"
#define USER_EMAIL "[email protected]"
#define USER_PASSWORD "********" 
#define DATABASE_URL "https://biometric-authentication-a3cd3-default-rtdb.firebaseio.com"

DefaultNetwork network; // initilize with boolean parameter to enable/disable network reconnection
UserAuth user_auth(API_KEY, USER_EMAIL, USER_PASSWORD);
FirebaseApp app;
WiFiClientSecure ssl_client;
using AsyncClient = AsyncClientClass;
AsyncClient aClient(ssl_client, getNetwork(network));
RealtimeDatabase Database;

//global variable
String NAME,STATUS,GENDER,EXPIREDATE;
String path1="/REGISTERED_MEMBER/";
String path2="/Members/";


void setup()
{
  pinMode(touch,INPUT);
  Serial.begin(115200);
  delay(500);
    // set the data rate for the sensor serial port
  mySerial.begin(57600,SERIAL_8N1, 16, 17);
  finger.begin(57600);
  delay(5);
  if (finger.verifyPassword()) {
    Serial.println("Found fingerprint sensor!");
  } else {
    Serial.println("Did not find fingerprint sensor :(");
    while (1) { delay(1); }
  }

  Serial.println(F("Reading sensor parameters"));
  finger.getParameters();
  Serial.print(F("Status: 0x")); Serial.println(finger.status_reg, HEX);
  Serial.print(F("Sys ID: 0x")); Serial.println(finger.system_id, HEX);
  Serial.print(F("Capacity: ")); Serial.println(finger.capacity);
  Serial.print(F("Security level: ")); Serial.println(finger.security_level);
  Serial.print(F("Device address: ")); Serial.println(finger.device_addr, HEX);
  Serial.print(F("Packet len: ")); Serial.println(finger.packet_len);
  Serial.print(F("Baud rate: ")); Serial.println(finger.baud_rate);

  finger.getTemplateCount();

  if (finger.templateCount == 0) {
    Serial.print("Sensor doesn't contain any fingerprint data. Please run the 'enroll' example.");
  }
  else {
    Serial.println("Waiting for valid finger...");
      Serial.print("Sensor contains "); Serial.print(finger.templateCount); Serial.println(" templates");
  }
 
    lcd.init();                  
    lcd.backlight();
    loadingdisplay();

    //CONNECT TO WIFY
    WiFi.begin(WIFI_SSID, WIFI_PASSWORD);
    Serial.print("Connecting to Wi-Fi");
    unsigned long ms = millis();
    while (WiFi.status() != WL_CONNECTED)
    {
      Serial.print(".");
      delay(300);
    }
    Serial.println();
    Serial.print("Connected with IP: ");
    Serial.println(WiFi.localIP());
    Serial.println();

    Firebase.printf("Firebase Client v%s\n", FIREBASE_CLIENT_VERSION);
    Serial.println("Initializing app...");
    ssl_client.setInsecure();
    app.setCallback(asyncCB);
    initializeApp(aClient, app, getAuth(user_auth));

    // Waits for app to be authenticated.
    // For asynchronous operation, this blocking wait can be ignored by calling app.loop() in loop().
    ms = millis();
    while (app.isInitialized() && !app.ready() && millis() - ms < 120 * 1000);
    app.getApp<RealtimeDatabase>(Database);
    Database.url(DATABASE_URL);
}
  
void loop()
{
  homedisplay();
  app.loop();         // This function is required for handling async operations and maintaining the authentication tasks.    
  Database.loop();    // (For Async Only) This required when different AsyncClients than used in FirebaseApp assigned to the Realtime database functions.
  uint8_t datax=getFingerprintID();
  Serial.println(datax);
  if(datax>2 && datax<100)
  {
    String dataxx = tagQuery(String(datax));      
    if(tagQuery(String(datax)=!"error") )      
    {
      if(extractAndStore(dataxx))
      {                                                                                         
        showResult();
        delay(3000);
      }
     else
      {
        Serial.println("error querry data");
      } 
    }   
    else
    {
      Serial.println("error querry data");
    }                                                                                                                                                  
  }
  if(digitalRead(enrolButton))
  {
    while(getFingerprintEnroll()!=1)
  }
}

void asyncCB(AsyncResult &aResult)
{
    if (aResult.appEvent().code() > 0)
    {
        Firebase.printf("Event msg: %s, code: %d\n", aResult.appEvent().message().c_str(), aResult.appEvent().code());
    }

    if (aResult.isDebug())
    {
        Firebase.printf("Debug msg: %s\n", aResult.debug().c_str());
    }

    if (aResult.isError())
    {
        Firebase.printf("Error msg: %s, code: %d\n", aResult.error().message().c_str(), aResult.error().code());
    }
}

void printError(int code, const String &msg)
{
    Firebase.printf("Error, msg: %s, code: %d\n", msg.c_str(), code);
}

bool extractAndStore(String jsonString) 
{
  StaticJsonDocument<200> doc;  // Allocate a buffer for parsing the JSON data
  DeserializationError error = deserializeJson(doc, jsonString);  // Deserialize the JSON data
  if (error)  // Check for errors
  {
    Serial.print("Failed to parse JSON: ");
    Serial.println(error.c_str());
    return LOW;
  }
  String name = doc["NAME"];    // Extract and store key-value pairs in variables
  NAME=name;
  String balance = doc["EXPIREDATE"];
  EXPIREDATE=balance;
  String gender = doc["GENDER"];
  GENDER=gender;
  String state = doc["STATUS"];
  STATUS=state;
   
  Serial.println("Extracted Values:");  // Print extracted values for verification
  Serial.print("NAME: ");
  Serial.println(NAME);
  Serial.print("EXPIREDATE: ");
  Serial.println(EXPIREDATE);
  Serial.print("STATE: ");
  Serial.println(STATUS);
  Serial.print("GENDER: ");
  Serial.println(GENDER);
  return HIGH;
}

String tagQuery(String tgId)
{
  String nodePath =path1+tgId;
  Serial.print("Getting query...");
  String stdata = Database.get<String>(aClient,nodePath );
  if (aClient.lastError().code() == 0)
  {
      Serial.print("OBTAINED RESULT:");
      Serial.println(stdata);
      return stdata;
  }
  else
  {
      printError(aClient.lastError().code(), aClient.lastError().message());
      return "error";
  }
}

void loadingdisplay()
{
  lcd.clear();
  lcd.setCursor(0,0);
  lcd.print("*      IOT BASED     *"); 
  lcd.setCursor(0,1);
  lcd.print("*BIOMETRIC ATTENDANCE*"); 
  lcd.setCursor(0,2);
  lcd.print(" SYSTEM INITIALIZE ");
  lcd.setCursor(0,3);
  lcd.print("PLEASE WAIT");
  for(int k=11;k<20;k++)
  {
    lcd.setCursor(k,3);
    lcd.print(".");
    delay(500);
  }
}

void homedisplay()
{
  lcd.setCursor(0,0);
  lcd.print("BIOMETRIC ATTENDANCE");
  lcd.setCursor(0,1);
  lcd.print("---------<>---------"); 
  lcd.setCursor(0,2);
  lcd.print("PLACE FINGER SENSOR");
  lcd.setCursor(0,3);
  lcd.print("----> ACTIVATED <---");
}

void mydisplay(String TEXT)
{
     lcd.clear();
     lcd.setCursor(0,0);
     lcd.print("----NOTIFICATION----"); 
     lcd.setCursor(0,1);
     lcd.print("--------------------"); 
     lcd.setCursor(0,2);
     lcd.print(TEXT);   
     lcd.setCursor(0,3);
     lcd.print("--------------------"); 
}

uint8_t getFingerprintID() 
{
  uint8_t p = finger.getImage();
  switch (p) 
  {
    case FINGERPRINT_OK:
      Serial.println("Image taken");
      break;
    case FINGERPRINT_NOFINGER:
      Serial.println("No finger detected");
      return p;
    case FINGERPRINT_PACKETRECIEVEERR:
      Serial.println("Communication error");
      return p;
    case FINGERPRINT_IMAGEFAIL:
      Serial.println("Imaging error");
      return p;
    default:
      Serial.println("Unknown error");
      return p;
  }
  // OK success!
  p = finger.image2Tz();
  switch (p) 
  {
    case FINGERPRINT_OK:
      Serial.println("Image converted");
      break;
    case FINGERPRINT_IMAGEMESS:
      Serial.println("Image too messy");
      return p;
    case FINGERPRINT_PACKETRECIEVEERR:
      Serial.println("Communication error");
      return p;
    case FINGERPRINT_FEATUREFAIL:
      Serial.println("Could not find fingerprint features");
      return p;
    case FINGERPRINT_INVALIDIMAGE:
      Serial.println("Could not find fingerprint features");
      return p;
    default:
      Serial.println("Unknown error");
      return p;
  }
  // OK converted!
  p = finger.fingerSearch();
  if (p == FINGERPRINT_OK) 
  {
    Serial.println("Found a print match!");
  } 
  else if (p == FINGERPRINT_PACKETRECIEVEERR) 
  {
    Serial.println("Communication error");
    return p;
  } 
  else if (p == FINGERPRINT_NOTFOUND) 
  {
    Serial.println("Did not find a match");
    return p;
  } else {
    Serial.println("Unknown error");
    return p;
  }

  // found a match!
  Serial.print("Found ID #"); Serial.print(finger.fingerID);
  Serial.print(" with confidence of "); Serial.println(finger.confidence);

  return finger.fingerID;
}

// returns -1 if failed, otherwise returns ID #
int getFingerprintIDez() 
{
  uint8_t p = finger.getImage();
  if (p != FINGERPRINT_OK)  return -1;

  p = finger.image2Tz();
  if (p != FINGERPRINT_OK)  return -1;

  p = finger.fingerFastSearch();
  if (p != FINGERPRINT_OK)  return -1;

  // found a match!
  Serial.print("Found ID #"); Serial.print(finger.fingerID);
  Serial.print(" with confidence of "); Serial.println(finger.confidence);
  return finger.fingerID;
}

uint8_t getFingerprintEnroll() 
{

  int p = -1;
  Serial.print("Waiting for valid finger to enroll as #"); Serial.println(id);
  while (p != FINGERPRINT_OK) {
    p = finger.getImage();
    switch (p) {
    case FINGERPRINT_OK:
      Serial.println("Image taken");
      break;
    case FINGERPRINT_NOFINGER:
      Serial.print(".");
      break;
    case FINGERPRINT_PACKETRECIEVEERR:
      Serial.println("Communication error");
      break;
    case FINGERPRINT_IMAGEFAIL:
      Serial.println("Imaging error");
      break;
    default:
      Serial.println("Unknown error");
      break;
    }
  }

  // OK success!

  p = finger.image2Tz(1);
  switch (p) {
    case FINGERPRINT_OK:
      Serial.println("Image converted");
      break;
    case FINGERPRINT_IMAGEMESS:
      Serial.println("Image too messy");
      return p;
    case FINGERPRINT_PACKETRECIEVEERR:
      Serial.println("Communication error");
      return p;
    case FINGERPRINT_FEATUREFAIL:
      Serial.println("Could not find fingerprint features");
      return p;
    case FINGERPRINT_INVALIDIMAGE:
      Serial.println("Could not find fingerprint features");
      return p;
    default:
      Serial.println("Unknown error");
      return p;
  }

  Serial.println("Remove finger");
  delay(2000);
  p = 0;
  while (p != FINGERPRINT_NOFINGER) {
    p = finger.getImage();
  }
  Serial.print("ID "); Serial.println(id);
  p = -1;
  Serial.println("Place same finger again");
  while (p != FINGERPRINT_OK) {
    p = finger.getImage();
    switch (p) {
    case FINGERPRINT_OK:
      Serial.println("Image taken");
      break;
    case FINGERPRINT_NOFINGER:
      Serial.print(".");
      break;
    case FINGERPRINT_PACKETRECIEVEERR:
      Serial.println("Communication error");
      break;
    case FINGERPRINT_IMAGEFAIL:
      Serial.println("Imaging error");
      break;
    default:
      Serial.println("Unknown error");
      break;
    }
  }

  // OK success!

  p = finger.image2Tz(2);
  switch (p) {
    case FINGERPRINT_OK:
      Serial.println("Image converted");
      break;
    case FINGERPRINT_IMAGEMESS:
      Serial.println("Image too messy");
      return p;
    case FINGERPRINT_PACKETRECIEVEERR:
      Serial.println("Communication error");
      return p;
    case FINGERPRINT_FEATUREFAIL:
      Serial.println("Could not find fingerprint features");
      return p;
    case FINGERPRINT_INVALIDIMAGE:
      Serial.println("Could not find fingerprint features");
      return p;
    default:
      Serial.println("Unknown error");
      return p;
  }

  // OK converted!
  Serial.print("Creating model for #");  Serial.println(id);

  p = finger.createModel();
  if (p == FINGERPRINT_OK) {
    Serial.println("Prints matched!");
  } else if (p == FINGERPRINT_PACKETRECIEVEERR) {
    Serial.println("Communication error");
    return p;
  } else if (p == FINGERPRINT_ENROLLMISMATCH) {
    Serial.println("Fingerprints did not match");
    return p;
  } else {
    Serial.println("Unknown error");
    return p;
  }

  Serial.print("ID "); Serial.println(id);
  p = finger.storeModel(id);
  if (p == FINGERPRINT_OK) {
    Serial.println("Stored!");
  } else if (p == FINGERPRINT_PACKETRECIEVEERR) {
    Serial.println("Communication error");
    return p;
  } else if (p == FINGERPRINT_BADLOCATION) {
    Serial.println("Could not store in that location");
    return p;
  } else if (p == FINGERPRINT_FLASHERR) {
    Serial.println("Error writing to flash");
    return p;
  } else {
    Serial.println("Unknown error");
    return p;
  }

  return true;
}

void showResult()
{
     lcd.clear();
     lcd.setCursor(0,0);
     lcd.print("--- SEARCH RESULT---"); 
     lcd.setCursor(0,1);
     lcd.print(NAME); 
     lcd.setCursor(0,2);
     lcd.print(STATUS);   
     lcd.setCursor(0,3);
     lcd.print(EXPIREDATE); 
}