// Connections
// Arduino UNO Q :  
//                                Capacitive Fingerprint Sensor (UART)
// 3.3V    ------------------------ VIN
// GND     ------------------------ GND
// D1 / USART1_TX ----------------- RX
// D0 / USART1_RX ----------------- TX
// 3.3V    ------------------------ 3V3
//                                Gravity: Electrochemical Alcohol Sensor
// 3.3V    ------------------------ +
// GND     ------------------------ -
// SCL     ------------------------ C/R
// SDA     ------------------------ D/T
//                                Gravity: 1Kg Weight Sensor Kit - HX711
// 3.3V    ------------------------ VCC
// GND     ------------------------ GND
// SCL     ------------------------ SCL
// SDA     ------------------------ SDA
//                                Gravity: Geiger Counter Module - Ionizing Radiation Detector
// GND     ------------------------ -
// 3.3V    ------------------------ +
// D2      ------------------------ D
//                                Gravity: Electrochemical Nitrogen Dioxide Sensor - NO2
// 3.3V    ------------------------ +
// GND     ------------------------ -
// SCL     ------------------------ C/R
// SDA     ------------------------ D/T
//                                Grove - Integrated Pressure Sensor Kit - MPX5700AP
// GND     ------------------------ GND
// 3.3V    ------------------------ VCC
// A0      ------------------------ SIG
//                                Grove - Water Atomization Sensor - Ultrasonic
// GND     ------------------------ GND
// 5V      ------------------------ VCC
// D4      ------------------------ EN
//                                Gravity: GNSS Positioning Module
// 3.3V    ------------------------ +
// GND     ------------------------ -
// SCL     ------------------------ C/R
// SDA     ------------------------ D/T
//                                Waveshare - 1.28inch Round LCD Display Module
// 3.3V    ------------------------ VCC
// GND     ------------------------ GND
// D11     ------------------------ DIN
// D13     ------------------------ CLK
// D10     ------------------------ CS
// D7      ------------------------ DC
// D8      ------------------------ RST
// D9      ------------------------ BL
//                                Control Button (A)
// A1      ------------------------ +
//                                Control Button (B)
// A2      ------------------------ +
//                                Control Button (C)
// A3      ------------------------ +
//                                Control Button (D)
// A4      ------------------------ +
//                                5mm Common Anode RGB LED
// D3      ------------------------ R
// D5      ------------------------ G
// D6      ------------------------ B

#include <Arduino_RouterBridge.h>
#include <DFRobot_ID809.h>
#include "DFRobot_Alcohol.h"
#include <DFRobot_HX711_I2C.h>
#include "DFRobot_MultiGasSensor.h"
#include <DFRobot_Geiger.h>
#include "DFRobot_GNSS.h"
#include "SPI.h"
#include "Adafruit_GFX.h"
#include "Adafruit_GC9A01A.h"

#include "logo.h"

// Import the custom color theme.
#include "color_theme.h"

#define SCREEN_WIDTH   240
#define SCREEN_HEIGHT  240
#define TFT_DC         D7
#define TFT_CS         D10
Adafruit_GC9A01A tft(TFT_CS, TFT_DC);

/*
  1) The available collection range is between 1 and 100. The sensor generates the final result as the average of the given number (collection range) of the latest data collection array items.
 
  2) The available I2C addresses are as follows. Please use the onboard the DIP switch to change the default I2C address. 
                        | A0 | A1 |  
    ALCOHOL_ADDRESS_0   | 0  | 0  |   0x72
    ALCOHOL_ADDRESS_1   | 1  | 0  |   0x73
    ALCOHOL_ADDRESS_2   | 0  | 1  |   0x74
    ALCOHOL_ADDRESS_3   | 1  | 1  |   0x75 (Default)
*/
#define alcohol_collect_num  10
DFRobot_Alcohol_I2C alcohol_sensor(&Wire, ALCOHOL_ADDRESS_3);

/*
  1) The available I2C addresses are as follows. Please use the onboard the DIP switch to change the default I2C address.
    | A0 | A1 |  
    | 0  | 0  |   0x74 (Default)
    | 0  | 1  |   0x75
    | 1  | 0  |   0x76
    | 1  | 1  |   0x77    
*/
DFRobot_GAS_I2C no2_gas_sensor(&Wire, 0x74);

/*
  1) The available I2C addresses are as follows. Please use the onboard the DIP switch to change the default I2C address.
    | A0 | A1 |  
    | 0  | 0  |   0x64 (Default)
    | 1  | 0  |   0x65
    | 0  | 1  |   0x66
    | 1  | 1  |   0x67 
*/
DFRobot_HX711_I2C weight_sensor(&Wire,/*addr=*/0x64);

/*
  1) The default I2C address is 0x20.
  2) Once the module acquires a GPS signal successfully, the onboard LED should turn from red to green.
*/
DFRobot_GNSS_I2C gnss_sensor(&Wire ,GNSS_DEVICE_ADDR);

volatile boolean __debug_monitor = false;

struct sensor_readings {
  unsigned long latest_read_time, read_offset = 1000000;
  float pressure;
  float alcohol_concentration;
  float weight;
  struct _no2{ float concentration; int board_temp; }; struct _no2 _no2;
  struct _geiger{ int cpm, nsvh, usvh; }; struct _geiger _geiger;
  struct _gnss{ String date, utc; char lat_dir, lon_dir; double latitude, longitude, altitude, sog, cog; }; struct _gnss _gnss;
  String water_atomization = "OFF";
};

Bridge.begin();

//Monitor.begin();

Bridge.provide("interface_web_control", interface_web_control);

  Serial.begin(115200);
  delay(1000);

sensor_readings.latest_read_time = micros();

void obtain_sensor_readings(unsigned long read_offset){
  if(micros() - sensor_readings.latest_read_time >= read_offset){
    pressure_sensor.raw_value = 0;
    for(int x = 0; x < pressure_sensor.collection_range; x++) pressure_sensor.raw_value = pressure_sensor.raw_value + analogRead(pressure_sensor.c_pin);
    sensor_readings.pressure = (pressure_sensor.raw_value - pressure_sensor.offset) * 700.0 / (pressure_sensor.full_scale - pressure_sensor.offset);
    //if(__debug_monitor){Monitor.print("Pressure sensor raw value (A/D) is  "); Monitor.print(pressure_sensor.raw_value); Monitor.print("\nEstimated pressure is "); Monitor.print(sensor_readings.pressure);  Monitor.println(" kPa\n");}    
  }
  if(micros() - sensor_readings.latest_read_time >= 2*read_offset){
    sensor_readings.alcohol_concentration = alcohol_sensor.readAlcoholData(alcohol_collect_num);
    if(sensor_readings.alcohol_concentration == ERROR) sensor_readings.alcohol_concentration = -1;
    //if(__debug_monitor){ Monitor.print("Alcohol concentration is "); Monitor.print(sensor_readings.alcohol_concentration); Monitor.println(" PPM.\n"); }
  }
  if(micros() - sensor_readings.latest_read_time >= 3*read_offset){
    sensor_readings.weight = weight_sensor.readWeight();
    if(sensor_readings.weight < 0.5) sensor_readings.weight = 0;
    //if(__debug_monitor){ Monitor.print("Estimated weight is "); Monitor.print(sensor_readings.weight); Monitor.println(" g.\n"); }
    sensor_readings._geiger.cpm = geiger.getCPM();
    sensor_readings._geiger.nsvh = geiger.getnSvh();
    sensor_readings._geiger.usvh = geiger.getuSvh();
    //if(__debug_monitor){Monitor.print("CPM: "); Monitor.println(sensor_readings._geiger.cpm); Monitor.print("nSv/h: "); Monitor.println(sensor_readings._geiger.nsvh); Monitor.print("μSv/h "); Monitor.println(sensor_readings._geiger.usvh);}
  }
  if(micros() - sensor_readings.latest_read_time >= 4*read_offset){
    sensor_readings._no2.concentration = no2_gas_sensor.readGasConcentrationPPM();
    sensor_readings._no2.board_temp = no2_gas_sensor.readTempC();
    //if(__debug_monitor){ Monitor.print("NO2 concentration is: "); Monitor.print(sensor_readings._no2.concentration); Monitor.println(" PPM\n"); Monitor.print("NO2 sensor board temperature is: "); Monitor.print(sensor_readings._no2.board_temp); Monitor.println(" ℃\n"); }
  }
  if(micros() - sensor_readings.latest_read_time >= 5*read_offset){
    sTim_t utc = gnss_sensor.getUTC();
    sTim_t date = gnss_sensor.getDate();
    sLonLat_t lat = gnss_sensor.getLat();
    sLonLat_t lon = gnss_sensor.getLon();
    sensor_readings._gnss.date = String(date.year) + "/" + String(date.month) + "/" + String(date.date); sensor_readings._gnss.utc = String(utc.hour) + "_" + String(utc.minute) + "_" + String(utc.second);
    sensor_readings._gnss.lat_dir = (char)lat.latDirection; sensor_readings._gnss.lon_dir = (char)lon.lonDirection;
    sensor_readings._gnss.latitude = lat.latitudeDegree; sensor_readings._gnss.longitude = lon.lonitudeDegree;
    sensor_readings._gnss.altitude = gnss_sensor.getAlt();
    sensor_readings._gnss.sog = gnss_sensor.getSog(); // Speed Over Ground
    sensor_readings._gnss.cog = gnss_sensor.getCog(); // Course Over Ground
    //if(__debug_monitor){ Monitor.print("GNSS (latitude): ");  Monitor.print(sensor_readings._gnss.latitude); Monitor.print("GNSS (longitude): ");  Monitor.print(sensor_readings._gnss.longitude); Monitor.print("GNSS (altitude): ");  Monitor.print(sensor_readings._gnss.altitude); }
  }
  if(micros() - sensor_readings.latest_read_time >= 6*read_offset){
    // After collecting all sensor variables, invoke the borrowed Python function via the Arduino Router using MessagePack RPC.
    Bridge.call("update_sensor_on_app", sensor_readings.pressure, sensor_readings.alcohol_concentration, sensor_readings.weight, sensor_readings._no2.concentration, sensor_readings._no2.board_temp, sensor_readings._geiger.cpm, sensor_readings._geiger.nsvh, sensor_readings._geiger.usvh, sensor_readings._gnss.date, sensor_readings._gnss.utc, sensor_readings._gnss.lat_dir, sensor_readings._gnss.lon_dir, sensor_readings._gnss.latitude, sensor_readings._gnss.longitude, sensor_readings._gnss.altitude, sensor_readings._gnss.sog, sensor_readings._gnss.cog);
    // Restart the sensor reading timer.
    sensor_readings.latest_read_time = micros();    
  }
}

void show_sensor_screen(String title, String title_exp, String sensor_value, String sensor_unit, int _theme){
  int l_1_s = 6, l_2_s = 14, l_sp = 5;
  int divider_w = SCREEN_WIDTH, divider_h = SCREEN_HEIGHT/4;
  int title_w = (divider_w/5)*3, title_h = (divider_h/3)*2;
  int logo_r = 40;
  int panel_w = SCREEN_WIDTH-logo_r-(4*l_sp), panel_h = (2*logo_r)-(4*l_sp);
  int inner_panel_w = panel_w-logo_r, inner_panel_h = panel_h-(2*l_sp);
  int t_x_s = (logo_r+(2*l_sp)+logo_r-l_sp) + inner_panel_w/2;
  int t_h_s = (SCREEN_HEIGHT/2)+(1.5*l_sp)-(l_2_s/2);
  if(!shown_screen_sensor){
    adjustColor(1,0,1);
    tft.fillScreen(Q_teal);
    tft.fillRect(0, 0, divider_w, divider_h, Q_grey);
    tft.fillRoundRect((divider_w-title_w)/2, (divider_h/3)*2, title_w, title_h, 5, Q_golden);
    tft.setTextSize(2); tft.setTextColor(Q_light_grey);
    tft.setCursor((SCREEN_WIDTH-(title.length()*l_2_s))/2, ((divider_h/3)*2)+l_sp);
    tft.print(title);
    tft.setTextSize(1);
    tft.setCursor((SCREEN_WIDTH-(title_exp.length()*l_1_s))/2, ((divider_h/3)*2)+title_h-l_1_s-l_sp);
    tft.print(title_exp);
    tft.fillCircle(logo_r+(2*l_sp), (SCREEN_HEIGHT/2)+(1.5*l_sp), logo_r, Q_primary);
    tft.fillRoundRect(logo_r+(2*l_sp), (SCREEN_HEIGHT/2)+(1.5*l_sp)-(panel_h/2), panel_w, panel_h, 5, Q_primary);
    tft.drawBitmap(logo_r+(2*l_sp)-(sensor_logo_w[_theme]/2), (SCREEN_HEIGHT/2)+(1.5*l_sp)-(sensor_logo_h[_theme]/2), sensor_logo_bit[_theme], sensor_logo_w[_theme], sensor_logo_h[_theme], Q_white);
    tft.fillRect(logo_r+(2*l_sp)+logo_r-l_sp, (SCREEN_HEIGHT/2)+(1.5*l_sp)-(inner_panel_h/2), inner_panel_w, inner_panel_h, Q_cyan);
    tft.setTextSize(2); tft.setTextColor(Q_white);
    tft.setCursor(t_x_s-((sensor_value.length()*l_2_s)/2), t_h_s);
    tft.print(sensor_value);
    tft.fillRect(0, SCREEN_HEIGHT-divider_h, divider_w, divider_h, Q_grey);
    tft.setTextSize(2); tft.setTextColor(Q_cyan);
    tft.setCursor((SCREEN_WIDTH-(sensor_unit.length()*l_2_s))/2, SCREEN_HEIGHT-(divider_h/2)-(l_2_s/2));
    tft.print(sensor_unit);
  }else{
    tft.fillRect(logo_r+(2*l_sp)+logo_r-l_sp, (SCREEN_HEIGHT/2)+(1.5*l_sp)-(inner_panel_h/2), inner_panel_w, inner_panel_h, Q_cyan);
    tft.setTextSize(2); tft.setTextColor(Q_white);
    tft.setCursor(t_x_s-((sensor_value.length()*l_2_s)/2), t_h_s);
    tft.print(sensor_value);    
  }
  // Avoid flickering due to drawing the same interface consecutively.
  shown_screen_sensor = true;
}

void show_fingerprint_task_screen(String title, String title_exp, uint16_t bg_color, uint16_t t_color){
  int l_1_s = 6, l_2_s = 14, l_sp = 5;
  int divider_w = SCREEN_WIDTH, divider_h = SCREEN_HEIGHT-fingerprint_h-(5*l_sp);
  if(!shown_screen_fingerprint){
    adjustColor(1,1,1);
    tft.fillScreen(Q_primary);
    tft.drawBitmap((SCREEN_WIDTH-fingerprint_w)/2, 2*l_sp, fingerprint_bits, fingerprint_w, fingerprint_h, bg_color);
    tft.fillRect(0, SCREEN_HEIGHT-divider_h, divider_w, divider_h, bg_color);
    tft.setTextSize(2); tft.setTextColor(t_color);
    tft.setCursor(((SCREEN_WIDTH-(title.length()*l_2_s))/2)+(2*l_sp), SCREEN_HEIGHT-divider_h+l_sp);
    tft.print(title);
    tft.setTextSize(1);
    tft.setCursor((SCREEN_WIDTH-(title_exp.length()*l_1_s))/2, SCREEN_HEIGHT-(5*l_sp));
    tft.print(title_exp);
  }
  // Avoid flickering due to drawing the same interface consecutively.
  shown_screen_fingerprint = true;
  
}

void show_err_screen(String title, String title_exp, String err_description){
  int l_1_s = 6, l_2_s = 14, l_sp = 5;
  int divider_w = SCREEN_WIDTH, divider_h = SCREEN_HEIGHT/4;
  int title_w = (divider_w/5)*3, title_h = (divider_h/3)*2;
  int logo_r = 36;
  tft.fillScreen(Q_teal);
  tft.fillRect(0, 0, divider_w, divider_h, Q_red);
  tft.fillRoundRect((divider_w-title_w)/2, (divider_h/3)*2, title_w, title_h, 5, Q_golden);
  tft.setTextSize(2); tft.setTextColor(Q_light_grey);
  tft.setCursor((SCREEN_WIDTH-(title.length()*l_2_s))/2, ((divider_h/3)*2)+l_sp);
  tft.print(title);
  tft.setTextSize(1);
  tft.setCursor((SCREEN_WIDTH-(title_exp.length()*l_1_s))/2, ((divider_h/3)*2)+title_h-l_1_s-l_sp);
  tft.print(title_exp);
  tft.fillCircle(SCREEN_WIDTH/2, (SCREEN_HEIGHT/2)+(1.5*l_sp), logo_r, Q_red);
  tft.drawBitmap((SCREEN_WIDTH-error_w)/2, ((SCREEN_HEIGHT-error_h)/2)+(1.5*l_sp), error_bits, error_w, error_h, Q_white);
  tft.fillRect(0, SCREEN_HEIGHT-divider_h, divider_w, divider_h, Q_red);
  tft.setTextSize(2); tft.setTextColor(Q_white);
  tft.setCursor((SCREEN_WIDTH-(err_description.length()*l_2_s))/2, SCREEN_HEIGHT-(divider_h/2)-(l_2_s/2));
  tft.print(err_description);
}

void manage_fingerprint_task(String task, uint8_t requested_id){
  uint8_t result = 0;
  if(task == "check_id"){
    shown_screen_fingerprint = false;
    show_fingerprint_task_screen("Check ID", "Please scan finger!", Q_cyan, Q_primary);
    // Once the user places a finger onto the capacitive fingerprint sensor, capture the fingerprint image.
    if(fingerprint.collectionFingerprint(/*timeout=*/0) != ERR_ID809){
      // Then, notify the user that the fingerprint image captured successfully via the respective task interface.
      shown_screen_fingerprint = false;
      show_fingerprint_task_screen("Captured", "Remove finger!", Q_golden, Q_primary);
      // Wait until the user removes the captured finger.
      while(fingerprint.detectFinger());
      // Then, obtain the ID of the captured fingerprint if registered in the sensor's fingerprint library - ID(1-80).
      result = fingerprint.search();
      if(result != 0){
        // If the captured fingerprint is registered (enrolled):
        shown_screen_fingerprint = false;
        show_fingerprint_task_screen("ID: "+String(result), "Successful!", Q_green, Q_primary);
        delay(2000);
        // Return to the home interface.
        return_home();
      }else{
        // Otherwise, notify the user accordingly:
        shown_screen_fingerprint = false;
        show_fingerprint_task_screen("ID: N", "Not registered!", Q_magenta, Q_white);
        delay(2000);
        // Return to the home interface.
        return_home();        
      }
    }else{
      // If the sensor cannot capture fingerprints precisely, notify the user accordingly.
      shown_screen_fingerprint = false;
      show_fingerprint_task_screen("Error", "Cannot capture!", Q_red, Q_white);
      delay(2000);
      // Return to the home interface.
      return_home();        
    }
  }
  else if(task == "register_id"){
    uint8_t register_ID;
    int fingerprint_sampling_number = 3, current_sample = 0;
    shown_screen_fingerprint = false;
    show_fingerprint_task_screen("Register", "Please scan finger!", Q_cyan, Q_primary);
    // Obtain an available fingerprint ID from the sensor's fingerprint library - ID(1-80) - for registering the new fingerprint.
    register_ID = fingerprint.getEmptyID();
    if(register_ID != ERR_ID809){
      // Up to the given sampling number, capture fingerprint images consecutively.
      while(current_sample < fingerprint_sampling_number){
        // Once the user places a finger onto the capacitive fingerprint sensor, capture the fingerprint image.
        if(fingerprint.collectionFingerprint(/*timeout=*/0) != ERR_ID809){
          // Then, notify the user that the fingerprint image sample captured successfully via the respective task interface.
          shown_screen_fingerprint = false;
          show_fingerprint_task_screen("Captured ["+String(current_sample+1)+"]", "Remove finger!", Q_golden, Q_primary);
          // Proceed to capturing the following fingerprint image sample.
          current_sample++;
          // Wait until the user removes the captured finger.
          while(fingerprint.detectFinger());          
        }else{
          // If the sensor cannot capture fingerprint image samples precisely, notify the user accordingly.
          shown_screen_fingerprint = false;
          show_fingerprint_task_screen("Error", "Please reposition!", Q_red, Q_white);
          delay(2000);          
        }
      }
      // After capturing fingerprint image samples successfully, record the new fingerprint to the provided unregistered ID.
      if(fingerprint.storeFingerprint(/*Empty ID = */register_ID) != ERR_ID809){
        shown_screen_fingerprint = false;
        show_fingerprint_task_screen("Success ["+String(register_ID)+"]", "Registered!", Q_green, Q_primary);
        delay(2000);
        // Notify the Python backend accordingly via the borrowed function.
        Bridge.call("manage_account_actions_on_stm32", "signup", register_ID);        
        // Return to the home interface.
        return_home();
      }else{
        // If the sensor cannot save the new fingerprint to the provided ID, notify the user accordingly.
        shown_screen_fingerprint = false;
        show_fingerprint_task_screen("Error", "Cannot register!", Q_red, Q_white);
        delay(2000);
        // Notify the Python backend accordingly via the borrowed function.
        Bridge.call("manage_account_actions_on_stm32", "signup", -1);
        // Return to the home interface.
        return_home();          
      }
    }else{
      // If the sensor cannot produce an unregistered ID, notify the user accordingly.
      shown_screen_fingerprint = false;
      show_fingerprint_task_screen("Error", "Cannot find ID!", Q_red, Q_white);
      delay(2000);
      // Notify the Python backend accordingly via the borrowed function.
      Bridge.call("manage_account_actions_on_stm32", "signup", -2);      
      // Return to the home interface.
      return_home();       
    }
  }
  else if(task == "verify_id"){
    shown_screen_fingerprint = false;
    show_fingerprint_task_screen("Verify User", "Please scan finger!", Q_cyan, Q_primary);
    // Once the user places a finger onto the capacitive fingerprint sensor, capture the fingerprint image.
    if(fingerprint.collectionFingerprint(/*timeout=*/0) != ERR_ID809){
      // Then, notify the user that the fingerprint image captured successfully via the respective task interface.
      shown_screen_fingerprint = false;
      show_fingerprint_task_screen("Captured", "Remove finger!", Q_golden, Q_primary);
      // Wait until the user removes the captured finger.
      while(fingerprint.detectFinger());
      // Then, obtain the ID of the captured fingerprint if registered in the sensor's fingerprint library - ID(1-80).
      result = fingerprint.search();
      if(result != 0 && result == requested_id){
        // If the captured fingerprint is registered (enrolled) and its ID corresponds with the requested ID, verify the user to utilize the web application (dashboard).
        shown_screen_fingerprint = false;
        show_fingerprint_task_screen("Matched!", "User verified!", Q_green, Q_primary);
        delay(2000);
        // Notify the Python backend accordingly via the borrowed function.
        Bridge.call("manage_account_actions_on_stm32", "signin", result);        
        // Return to the home interface.
        return_home();
      }else{
        // Otherwise, notify the user accordingly and wait until the user scans the accurate fingerprint:
        shown_screen_fingerprint = false;
        show_fingerprint_task_screen("Try again!", "Not verified!", Q_magenta, Q_white);
        delay(2000);
        // Notify the Python backend accordingly via the borrowed function.
        Bridge.call("manage_account_actions_on_stm32", "signin", -1);
        // Return to the home interface.
        return_home();        
      }
    }else{
      // If the sensor cannot capture fingerprints precisely, notify the user accordingly and wait until the user scans the accurate fingerprint.
      shown_screen_fingerprint = false;
      show_fingerprint_task_screen("Error", "Cannot capture!", Q_red, Q_white);
      delay(2000);
      // Notify the Python backend accordingly via the borrowed function.
      Bridge.call("manage_account_actions_on_stm32", "signin", -2);       
    }    
  }
}

  if(!digitalRead(control_button_A)){
    current_sensor_screen++;
    if(current_sensor_screen >= total_sensor_screen) current_sensor_screen = 0;   
    shown_screen_sensor = false;
    activated_screen_home = false; shown_screen_home = false;
    activated_screen_fingerprint = false; shown_screen_fingerprint = false;
    delay(500);
  }

  if(!digitalRead(control_button_B)){
    current_sensor_screen--;
    if(current_sensor_screen < 0) current_sensor_screen = total_sensor_screen-1;   
    shown_screen_sensor = false;
    activated_screen_home = false; shown_screen_home = false;
    activated_screen_fingerprint = false; shown_screen_fingerprint = false;     
    delay(500);
  }  

  if(!activated_screen_home && !activated_screen_fingerprint){
    switch(current_sensor_screen){
      case 0:
        show_sensor_screen("NO2", "Concentration", String(sensor_readings._no2.concentration), "PPM", 0);
      break;
      case 1:
        show_sensor_screen("NO2", "Board Temp.", String(sensor_readings._no2.board_temp), "C", 0);
      break;
      case 2:
        show_sensor_screen("Alcohol", "Concentration", String(sensor_readings.alcohol_concentration), "PPM", 1);
      break; 
      case 3:
        show_sensor_screen("Weight", "Estimation", String(sensor_readings.weight), "G (g)", 2);
      break; 
      case 4:
        show_sensor_screen("Geiger", "Ionizing", String(sensor_readings._geiger.cpm), "CPM", 3);
      break; 
      case 5:
        show_sensor_screen("Geiger", "Ionizing", String(sensor_readings._geiger.nsvh), "nSv/h", 3);
      break;
      case 6:
        show_sensor_screen("Geiger", "Ionizing", String(sensor_readings._geiger.usvh), "uSv/h", 3);
      break; 
      case 7:
        show_sensor_screen("Pressure", "Integrated", String(sensor_readings.pressure), "kPa", 4);
      break;
      case 8:
        show_sensor_screen("Water", "Atomization", sensor_readings.water_atomization, "V", 5);
      break; 
      case 9:
        show_sensor_screen("GNSS", "Date", sensor_readings._gnss.date, "Y/M/D", 6);
      break; 
      case 10:
        show_sensor_screen("GNSS", "UTC", sensor_readings._gnss.utc, "H_M_S", 6);
      break;       
      case 11:
        show_sensor_screen("GNSS", "Latitude", String(sensor_readings._gnss.latitude), "Degrees", 6);
      break; 
      case 12:
        show_sensor_screen("GNSS", "Longitude", String(sensor_readings._gnss.longitude), "Degrees", 6);
      break; 
      case 13:
        show_sensor_screen("GNSS", "Altitude", String(sensor_readings._gnss.altitude), "M (m)", 6);
      break;
      case 14:
        show_sensor_screen("GNSS", "Speed Over Ground", String(sensor_readings._gnss.sog), "SOG", 6);
      break;  
      case 15:
        show_sensor_screen("GNSS", "Course Over Ground", String(sensor_readings._gnss.cog), "COG", 6);
      break;        
    }
  }

if(activated_screen_home) show_home_screen();

if(!digitalRead(control_button_D)) return_home();

  while(activated_screen_fingerprint){
    // Start the requested fingerprint sensor task.
    manage_fingerprint_task(ongoing_fingerprint_task, (uint8_t)provided_user_id);    
  }

  if(!digitalRead(control_button_C)){
    shown_screen_sensor = false;
    activated_screen_home = false; shown_screen_home = false;
    activated_screen_fingerprint = true; shown_screen_fingerprint = false;
    ongoing_fingerprint_task = "check_id";
    delay(500);
  }

void interface_web_control(String command, int interface_num){
  // Update the lab assistant interface (onboard) according to the provided user selection.
  if(command == "update_interface" || command == "update_water_on" || command == "update_water_off"){
    // Change the water atomization sensor state once requested by the user.
    if(command == "update_water_on"){ sensor_readings.water_atomization = "ON"; digitalWrite(water_atomization_pin, HIGH); }
    else if(command == "update_water_off"){ sensor_readings.water_atomization = "OFF"; digitalWrite(water_atomization_pin, LOW); } 
    if(interface_num != -1){
      current_sensor_screen = interface_num;
      shown_screen_sensor = false;
      activated_screen_home = false; shown_screen_home = false;
      activated_screen_fingerprint = false; shown_screen_fingerprint = false;
      delay(500);
    }else{
      return_home();
    }    
  }else{
     shown_screen_sensor = false;
     activated_screen_home = false; shown_screen_home = false;
     activated_screen_fingerprint = true; shown_screen_fingerprint = false;
     ongoing_fingerprint_task = command;
     provided_user_id = interface_num;
     delay(500);
   }
}

import os
from arduino.app_bricks.video_objectdetection import VideoObjectDetection
from arduino.app_bricks.cloud_llm import CloudLLM, CloudModel
from arduino.app_bricks.web_ui import WebUI
from arduino.app_bricks.dbstorage_sqlstore import SQLStore
from arduino.app_utils import *
from datetime import datetime
from time import sleep
import re
import random
import string
import cv2

    def __init__(self, clean_tables=False):
        # Initialize the integrated Cloud LLM management module to utilize the provided Google (Gemini) API key to generate AI-based lab lessons.
        self.llm_gemini = CloudLLM(
            model=CloudModel.GOOGLE_GEMINI,
            system_prompt="You are a lab assistant and must generate HTML pages about the given questions by providing extensive information on the requested subject."
        )
        # Initialize the integrated object detection model classifier instance with video stream (over WebSocket) for the provided Edge Impulse FOMO object detection model to precisely identify lab equipment.
        self.edge_impulse_model = VideoObjectDetection(confidence=0.35, debounce_sec=5)
        # Define the callback function once the provided model detects an equipment.
        self.edge_impulse_model.on_detect_all(lambda detections: self.process_inference_results(detections))
        # Declare and create the SQL database to register user and lesson information.
        self.db = SQLStore("lab_assistant.db")
        # Create the essential database tables. The built-in table creation function checks whether the given table is already exists.
        if(clean_tables):
            self.db.drop_table("account_info")
            self.db.drop_table("lesson_info")
        self.db.create_table("account_info", {"user_id": "INT", "firstname": "TEXT", "lastname": "TEXT", "activation": "TEXT"})
        self.db.create_table("lesson_info", {"question": "TEXT", "equipment": "TEXT", "date": "TEXT", "user_id": "INT", "lesson_id": "TEXT", "filename": "TEXT"})
        # Declare the integrated WebUI Brick class instance to initiate the custom lab assistant web dashboard.
        self.web_ui = WebUI(assets_dir_path="/app/lab_web_dashboard")
        # Listen WebSocket messages from the client (web dashboard) to obtain the latest updates. 
        self.web_ui.on_message("interface_web_control", self.interface_web_control_on_app)
        self.web_ui.on_message("manage_account_actions", self.manage_account_actions_on_app)
        self.web_ui.on_message("save_new_image_sample", self.save_new_image_sample_on_app)
        # Expose REST API endpoints (HTTP GET or POST) to transfer current user account and its associated AI-generated lesson information to all clients, including the web dashboard.
        self.web_ui.expose_api("GET", "/account_lessons", self.update_web_dashboard_with_database_info)        
        # Declare the sensor variables array.
        self.sensor_values = {
                                 "pressure": 0,
                                 "alcohol_concentration": 0,
                                 "weight": 0,
                                 "no2": {"concentration": 0, "board_temp": 0},
                                 "geiger": {"cpm": 0, "nsvh": 0, "usvh": 0},
                                 "gnss": {"date": "", "utc": "", "lat_dir": "", "lon_dir": "", "latitude": 0, "longitude": 0, "altitude": 0, "sog": 0, "cog": 0}
                             }
        # Declare the essential account information holders.
        self.sign_up_account_info = None
        
        # Employ the Arduino Router background Linux service to enable STM32 MCU to borrow and run these functions on Qualcomm MPU.
        Bridge.provide("update_sensor_on_app", self.update_sensor_on_app)
        Bridge.provide("manage_account_actions_on_stm32", self.manage_account_actions_on_stm32)

    def process_inference_results(self, detections: dict):
        # According to my experiments, I noticed that the built-in detection function sorts the detection results while returning them as a dictionary based on confidence levels. Thus, I was able to get the first dictionary item to transfer the most accurate result once multiple items detected.
        label, result = next(iter(detections.items()))
        confidence = round(result[0]["confidence"], 2)
        # If the current user account is activated, transfer the processed detection result to the web dashboard.
        current_user = self.db.execute_sql("SELECT * FROM account_info WHERE activation = 'activated';")
        if(current_user != None):
            self.web_ui.send_message("latest_obj_detection_result", {"label": label, "confidence": confidence})

    def generate_AI_lesson_w_gemini(self, lesson_info):
        retrieved_llm_response = self.llm_gemini.chat("Generate an HTML page on this question: " + lesson_info["question"])
        # Derive only the generated HTML page from the retrieved LLM response.
        processed_llm_response = re.search(r'(<!DOCTYPE html>.*?</html>)', retrieved_llm_response, re.DOTALL)
        if(processed_llm_response):
            # If the provided LLM produces the lesson as an HTML page successfully:
            generated_lesson_html = processed_llm_response.group(1)
            # Generate the unique 5-digit lesson ID.
            unique_lesson_id = ''.join(random.choices(string.ascii_letters + string.digits, k=5))
            # Get the lesson generation date in the required format.
            date = datetime.now().strftime("%m %d, %Y %H:%M:%S")
            # Save the LLM-generated lesson as an HTML file.
            lesson_filename = str(lesson_info["user_id"]) + "_" + lesson_info["equipment"] + "_" + unique_lesson_id + ".html"
            with open("lab_web_dashboard/lessons/"+lesson_filename, "w", encoding="utf-8") as new_lesson:
                new_lesson.write(generated_lesson_html)
            # Register the generated lesson information to the associated database table.
            self.db.execute_sql("INSERT INTO lesson_info (`question`, `equipment`, `date`, `user_id`, `lesson_id`, `filename`) VALUES ('"+lesson_info["question"]+"', '"+lesson_info["equipment"]+"', '"+date+"', "+lesson_info["user_id"]+", '"+unique_lesson_id+"', '"+lesson_filename+"');")
            # Notify the web dashboard accordingly.
            self.web_ui.send_message("generate_ai_lesson_action", {"response": "Google (Gemini) [gemini-2.5-flash] produced the requested lesson successfully!"})
        else:
            self.web_ui.send_message("generate_ai_lesson_action", {"response": "🪐 Google (Gemini) [gemini-2.5-flash] LLM could not generate an appropriately-formatted HTML page. Please try again!"})
      

    def update_sensor_on_app(self, p, a, w, n_c, n_b, g_c, g_n, g_u, gn_d, gn_u, gn_lt_d, gn_ln_d, gn_lat, gn_lon, gn_alt, gn_sog, gn_cog):
        # Record the retrieved sensor variables to the associated array.
        self.sensor_values["pressure"] = round(p, 2)
        self.sensor_values["alcohol_concentration"] = round(a, 2)
        self.sensor_values["weight"] = round(w, 2)
        self.sensor_values["no2"]["concentration"] = round(n_c, 2); self.sensor_values["no2"]["board_temp"] = n_b
        self.sensor_values["geiger"]["cpm"] = g_c; self.sensor_values["geiger"]["nsvh"] = g_n; self.sensor_values["geiger"]["usvh"] = g_u
        self.sensor_values["gnss"]["date"] = gn_d; self.sensor_values["gnss"]["utc"] = gn_u; self.sensor_values["gnss"]["lat_dir"] = gn_lt_d; self.sensor_values["gnss"]["lon_dir"] = gn_ln_d; self.sensor_values["gnss"]["latitude"] = round(gn_lat, 4); self.sensor_values["gnss"]["longitude"] = round(gn_lon, 4); self.sensor_values["gnss"]["altitude"] = gn_alt; self.sensor_values["gnss"]["sog"] = gn_sog; self.sensor_values["gnss"]["cog"] = gn_cog
        # Transfer the obtained sensor information to the lab assistant web dashboard via the WebSocket connection.
        self.web_ui.send_message("sensor_values", self.sensor_values)

    def manage_account_actions_on_app(self, sid, data):
        com = data["command"]
        if(com == "signin_user"):
            # Initiate the associated fingerprint sensor task on the STM32 microcontroller via the borrowed function.
            Bridge.call("interface_web_control", "verify_id", int(data["given_user_id"]))
            sleep(1)            
        elif(com == "signup_user"):
            self.sign_up_account_info = data;
            # Initiate the associated fingerprint sensor task on the STM32 microcontroller via the borrowed function.
            Bridge.call("interface_web_control", "register_id", -2)
            sleep(1)
        elif(com == "logout_user"):
            self.db.execute_sql("UPDATE account_info SET activation = 'not_activated' WHERE user_id = "+data["current_user_id"]+";")
        elif(com == "delete_user"):
            self.db.execute_sql("DELETE FROM account_info WHERE user_id = "+data["current_user_id"]+";")
            # Also delete all AI-generated lessons associated to this account.
            self.db.execute_sql("DELETE FROM lesson_info WHERE user_id = "+data["current_user_id"]+";")
        elif(com == "generate_new_ai_lesson"):
            self.generate_AI_lesson_w_gemini(data)

    def manage_account_actions_on_stm32(self, command, provided_user_id):     
        if(command == "signup"):
            if(self.sign_up_account_info == None):
                self.web_ui.send_message("signup_action", {"response": "❌ Python backend did not receive the given user information!"})
            else:
                if(provided_user_id == -1):
                    self.web_ui.send_message("signup_action", {"response": "❌ Fingerprint sensor cannot register!"})
                elif(provided_user_id == -2):
                    self.web_ui.send_message("signup_action", {"response": "🔍 Fingerprint sensor cannot find an available ID!"})
                else:
                    # Create a new user account with the provided user information and the given fingerprint scan ID as the user ID.
                    self.db.execute_sql("INSERT INTO account_info (`user_id`, `firstname`, `lastname`, `activation`) VALUES ("+str(provided_user_id)+", '"+self.sign_up_account_info["firstname"]+"', '"+self.sign_up_account_info["lastname"]+"', 'activated');")
                    self.sign_up_account_info = None
                    self.web_ui.send_message("signup_action", {"response": "New user account successfully created!"})
        elif(command == "signin"):
            if(provided_user_id == -1):
                self.web_ui.send_message("signin_action", {"response": "🔍 The given user ID was not verified by the fingerprint sensor! Try again!"})
            elif(provided_user_id == -2):
                self.web_ui.send_message("signin_action", {"response": "❌ Fingerprint sensor cannot capture fingerprints precisely!"})
            else:
                # Activate the requested account via its verified (matched) user (fingerprint) ID.
                account_check = self.db.execute_sql("SELECT * FROM account_info WHERE user_id = "+str(provided_user_id)+";")
                if(account_check != None):
                    self.db.execute_sql("UPDATE account_info SET activation = 'activated' WHERE user_id = "+str(provided_user_id)+";")
                    self.web_ui.send_message("signin_action", {"response": "Account activated successfully!"})
                else:
                    self.web_ui.send_message("signin_action", {"response": "✍ Given fingerprint belongs to a previously removed account! Please register a new account!"})
          

    def update_web_dashboard_with_database_info(self):
        current_user = self.db.execute_sql("SELECT * FROM account_info WHERE activation = 'activated';")
        if(current_user == None):
            html_content = ('<article class="account_notification)['
                            '<h1><span>Sign In: </span>Please utilize the fingerprint sensor to activate your user account!</h1>'
                            '<div>'
                            '<section> <span>User ID</span> <input name="user_id" placeholder="1)[</input> </section>'
                            '<section> <span>UNO Q</span> <span id="sign_in_button" class="highlight)[Sign In</span> </section>'
                            '</div>'
                            '</article>'
                            '<article class="account_notification)['
                            '<h1><span>Sign Up: </span>Please enter your credentials and register your fingerprint to create a new account!</h1>'
                            '<div>'
                            '<section> <span>Firstname</span> <input name="firstname" placeholder="Kutluhan)[</input> </section>'
                            '<section> <span>Lastname</span> <input name="lastname" placeholder="Aktar)[</input> </section>'
                            '<section> <span>UNO Q</span> <span id="sign_up_button" class="highlight)[Sign Up</span> </section>'
                            '</div>'
                            '</article>'
                           )
            return {"activation": "not_activated", "html_content": html_content}
        else:
            current_user = current_user[0]
            current_user_lessons = self.db.execute_sql("SELECT * FROM lesson_info WHERE user_id = "+str(current_user["user_id"])+";")
            html_content = ('<article class="account_notification" name="logout_section" user_id="'+str(current_user["user_id"])+')['
                            '<h1><span>Hi, '+current_user["firstname"]+' '+current_user["lastname"]+' 😊</span> ID: ['+str(current_user["user_id"])+']</h1>'
                            '<div>'
                            '<section> <span>UNO Q</span> <span id="logout_button" class="highlight)[Logout</span> </section>'
                            '<section> <span>UNO Q</span> <span id="delete_user_button" class="highlight)[Delete Account</span> </section>'
                            '</div>'
                            '</article>'
                            )
            if(current_user_lessons != None):
                # Sort the retrieved lessons array based on their creation dates to produce an ordered list from latest to earliest.
                current_user_lessons.sort(key=lambda l: datetime.strptime(l["date"], "%m %d, %Y %H:%M:%S"), reverse=True)
                # Then, proceed generating HTML lesson information cards.
                for index, lesson in enumerate(current_user_lessons):
                    if(index==0): html_content += "<h2>Latest Lesson</h2>"
                    if(index==1): html_content += "<h2>Previous Lessons</h2>"
                    html_lesson = ('<article lesson_filename="lessons/'+lesson["filename"]+')['
                                   '<h1><span>Q: </span>'+lesson["question"]+'</h1>'
                                   '<div>'
                                   '<section> <span>Date</span> <span>'+lesson["date"]+'</span> </section>'
                                   '<section> <span>User ID</span> <span>'+str(lesson["user_id"])+'</span> </section>'
                                   '<section> <span>Lesson ID</span> <span>'+lesson["lesson_id"]+'</span> </section>'
                                   '<section> <span>Subject</span> <span class="highlight)['+lesson["equipment"].upper()+'</span> </section>'
                                   '</div>'
                                   '</article>'
                                  )
                    html_content += html_lesson
            else:
                html_content += "<h2>No lesson found!</h2>"
            return {"activation": "activated", "firstname": current_user["firstname"], "lastname": current_user["lastname"], "user_id": current_user["user_id"], "html_content": html_content}
    

    def save_new_image_sample_on_app(self, sid, data):
        # Stop the Edge Impulse classifier instance to release camera resources.
        self.edge_impulse_model.stop()
        sleep(1)
        # Save the latest generated frame (image) by the USB camera.
        usb_camera_feed = cv2.VideoCapture(0)
        success, latest_frame = usb_camera_feed.read()
        if(success):
            # Get the sample generation date.
            date = datetime.now().strftime("%Y%m%d_%H%M%S")
            sample_file_name = data["sample_label"] + "_" + date + ".jpg"
            cv2.imwrite("ei_model/new_samples/" + sample_file_name, latest_frame)
            # Notify the web dashboard accordingly.
            self.web_ui.send_message("save_sample_result", {"response": "🖼️ New image sample successfully saved! \n\n" + sample_file_name})
        else:
            # Notify the web dashboard accordingly.
            self.web_ui.send_message("save_sample_result", {"response": "❌ Cannot obtain the latest frame produced by the USB camera!"})
        # Release OpenCV camera resources before restarting the classifier instance.
        usb_camera_feed.release()
        sleep(5)
        # Resume the Edge Impulse classifier instance.
        self.edge_impulse_model.start()
        sleep(5)

    def interface_web_control_on_app(self, sid, data):
        Bridge.call("interface_web_control", data["command"], data["interface_num"])
        sleep(1)

    def __debug(self, _debug):
        if(_debug):
            print("\n\n/////// Collected Sensor Information ///////\n\n")
            for(main_key, main_value) in self.sensor_values.items():
                if(isinstance(main_value, dict)):
                    for (key, value) in main_value.items():
                        print("{}[{}]: {}\n".format(main_key, key, value))
                else:
                    print("{}: {}\n".format(main_key, main_value))
            print("\n////////////////////////////////////////////////\n\n")

    def main_loop(self):
        while True:
            # Set 'True' for debugging on the built-in terminal.
            self.__debug(False)
            sleep(10)

ai_lab_assistant_obj = ai_lab_assistant();

# Initiate the main Arduino App application loop with the provided function, including the added Bricks.
App.run(user_loop=ai_lab_assistant_obj.main_loop)

import default_questions from './default_equipment_questions.json' with {type:'json'};

const socket = io(`http://${window.location.host}`);

let form_shown = false;

const ei_web_runner_embed = `http://${window.location.hostname}:4912/embed`;

setInterval(() => {
	// Obtain the required updates from the integrated SQL database.
	$.ajax({
		url: "account_lessons",
		type: "GET",
		success: (response) => {
				// Process the obtained information.
                let container_element = $('div.gemini_lessons > section[cat="lesson_panel"]');
          		if(response["activation"] == "not_activated" && form_shown == false){
                  container_element.html(response["html_content"]);
                  form_shown = true;
                }
                if(response["activation"] == "activated"){
                  container_element.html(response["html_content"]);
                  form_shown = false;
                  // In case the user refreshes the web dashboard after the account activation.
                  if(refreshed){ return_state("account_activated"); refreshed = false; }
                }
			}
		});	
}, 2000);

setInterval(() => {
    if(most_recent_detection == true){
      $('div.gemini_lessons > section[cat="object_detection"] > h2 > span').text("⏳ ");
      most_recent_detection = false;
    }
}, 10000);

function return_state(state){
  if(state == "default"){
      $('div.gemini_lessons > section[cat="object_detection"] > h2').text("🚀 Please activate your account");
      $('div.gemini_lessons > section[cat="object_detection"] > section > iframe').attr("src", "lessons/gemini_animations/gemini_obj_detection_waiting.html");
	  if($('div.gemini_lessons > section[cat="object_detection"] > section').hasClass("camera_show")) $('div.gemini_lessons > section[cat="object_detection"] > section').removeClass("camera_show");
      $('div.gemini_lessons > section[cat="lesson"] > iframe').attr("src", "lessons/gemini_animations/gemini_lesson_show_idle.html");
      $('div.gemini_lessons > section[cat="object_detection"] > div > article').html("");
      $('div.gemini_lessons > section[cat="object_detection"] > div > article').attr("latest_detected_equipment", "None");
  }else if(state == "account_activated"){
      $('div.gemini_lessons > section[cat="object_detection"] > h2').text("📸 Detecting lab equipment...");
	  if(!$('div.gemini_lessons > section[cat="object_detection"] > section').hasClass("camera_show")) $('div.gemini_lessons > section[cat="object_detection"] > section').addClass("camera_show");
      $('div.gemini_lessons > section[cat="object_detection"] > section > iframe').attr("src", ei_web_runner_embed);
  }
}

const sensor_interface_num = {
	"home": -1,
	"no2": {"concentration": 0, "board_temp": 1},
	"alcohol_concentration": 2,
	"weight": 3,
	"geiger": {"cpm": 4, "nsvh": 5, "usvh": 6},
	"pressure": 7,
	"water": {"on": 8, "off": 8},
	"gnss": {"date": 9, "utc": 10, "lat_dir": 11, "lon_dir": 12, "latitude": 11, "longitude": 12, "altitude": 13, "sog": 14, "cog": 15},
};

$('div.sensor_interface > section[cat="data"] > article').on("click", function(event){
    // Sensor card design updates.
	let item = $(this);
	let sensor_name = item.attr("sensor");
	let specified_variable = item.attr("sp");
	let interface_num = -1;
	let all_sensor_cards = $('div.sensor_interface > section[cat="data"] > article');
	let associated_cards = $('div.sensor_interface > section[cat="data"] > article[sensor="'+sensor_name+'"]');
	all_sensor_cards.each((index, elem) => { if($(elem).hasClass("highlight")) $(elem).removeClass("highlight"); if($(elem).hasClass("active")) $(elem).removeClass("active"); });
	if(!item.hasClass("active")) item.addClass("active");
	if(specified_variable != "none"){
		interface_num = sensor_interface_num[sensor_name][specified_variable];
		associated_cards.each((index, elem) => {
			if(!$(elem).hasClass("highlight") && !$(elem).hasClass("active")) $(elem).addClass("highlight");
		});
	}else{
		interface_num = sensor_interface_num[sensor_name];
	}
  // Transfer the requested command and the associated lab assistant sensor interface number.
	/* Since the communication with the water atomization sensor is a special case, requiring the user to control the sensor state, I added a different command to enable the user to change its current state via its sensor variable cards. */
	if(sensor_name != "water"){
		socket.emit("interface_web_control", {"command": "update_interface", "interface_num": interface_num});
	}else{
		if(specified_variable == "on") socket.emit("interface_web_control", {"command": "update_water_on", "interface_num": interface_num});
		else if(specified_variable == "off") socket.emit("interface_web_control", {"command": "update_water_off", "interface_num": interface_num});
	}
    // Bring the respective information page generated by Gemini.
    let info_page = "experiments/gemini_"+sensor_name+".html";
    let showing_page = $('div.sensor_interface > section[cat="exp"] > iframe').attr("src");
    if(info_page != showing_page) $('div.sensor_interface > section[cat="exp"] > iframe').attr("src", info_page);
});

$('div.gemini_lessons > section[cat="lesson_panel"]').on("click", "#sign_in_button", function(event){
    // Obtain the provided user ID to initiate the account activation procedure.
    let given_user_id = $('div.gemini_lessons > section[cat="lesson_panel"] input[name="user_id"]').val();
    if(given_user_id != ""){
      let overlay = $('div.main > div.notification_overlay');
      if(overlay.hasClass("idle")) overlay.removeClass("idle");
      overlay.children("iframe").attr("src", "lessons/gemini_animations/gemini_fingerprint_waiting.html");
      // Notify the Python backend accordingly.
      socket.emit("manage_account_actions", {"command": "signin_user", "given_user_id": given_user_id});
    }else{
      alert("📝 Please fill all required areas!");
    }
});

$('div.gemini_lessons > section[cat="lesson_panel"]').on("click", "#sign_up_button", function(event){
    // Obtain the provided user information to create a new account.
    let firstname = $('div.gemini_lessons > section[cat="lesson_panel"] input[name="firstname"]').val();
    let lastname = $('div.gemini_lessons > section[cat="lesson_panel"] input[name="lastname"]').val();
    if(firstname != "" && lastname != ""){
      let overlay = $('div.main > div.notification_overlay');
      if(overlay.hasClass("idle")) overlay.removeClass("idle");
      overlay.children("iframe").attr("src", "lessons/gemini_animations/gemini_fingerprint_waiting.html");
      // Notify the Python backend accordingly.
      socket.emit("manage_account_actions", {"command": "signup_user", "firstname": firstname, "lastname": lastname});
    }else{
      alert("📝 Please fill all required areas!");
    }
});

$('div.gemini_lessons > section[cat="lesson_panel"]').on("click", "#logout_button", function(event){
    // Obtain the user ID of the currently activated account.
    let current_user_id = $('div.gemini_lessons > section[cat="lesson_panel"] article[name="logout_section"]').attr("user_id");
    return_state("default");
	socket.emit("manage_account_actions", {"command": "logout_user", "current_user_id": current_user_id});
    alert("👋 Successfully signed out!");
});

$('div.gemini_lessons > section[cat="lesson_panel"]').on("click", "#delete_user_button", function(event){
    // Obtain the user ID of the currently activated account.
    let current_user_id = $('div.gemini_lessons > section[cat="lesson_panel"] article[name="logout_section"]').attr("user_id");
    return_state("default");
	socket.emit("manage_account_actions", {"command": "delete_user", "current_user_id": current_user_id});
    alert("❌ Account information and the associated lesson entries are removed from the database! \n\n📌Nonetheless, the AI-generated lesson (HTML) files remain for further research!");
});

$('div.gemini_lessons > section[cat="object_detection"] > div > textarea').on("input click", function(event){
	provided_lesson_question = $(this).val();
	$('div.gemini_lessons > section[cat="object_detection"] > div > article > p').removeClass("clicked");
});

$('div.gemini_lessons > section[cat="object_detection"] > div > article').on("click", "p", function(event){
	$('div.gemini_lessons > section[cat="object_detection"] > div > article > p').removeClass("clicked");
	$(this).addClass("clicked");
	provided_lesson_question = $(this).text();
});

$('div.gemini_lessons > section[cat="object_detection"]').on("click", "#generate_ai_lesson", function(event){
    // Obtain the user ID of the currently activated account.
    let current_user_id = $('div.gemini_lessons > section[cat="lesson_panel"] article[name="logout_section"]').attr("user_id");
    // Obtain the latest detected lab equipment by the provided Edge Impulse object detection model.
    let latest_detected_equipment = $('div.gemini_lessons > section[cat="object_detection"] > div > article').attr("latest_detected_equipment")
	// Check whether the user provided a lesson question or not.
	if(provided_lesson_question == ""){
		alert("🖥️ Please select (default) or request (enter) a lesson question!");
	}else{
        // Proceed to the LLM-based lesson generation if the object detection model has already detected a lab equipment. Otherwise, inform the user accordingly.
        if(latest_detected_equipment == "None"){
            alert("📸 Please show a lab equipment to the assistant to initiate the LLM-based lesson generation process.");
        }else{
		    // Notify the Python backend accordingly.
            socket.emit("manage_account_actions", {"command": "generate_new_ai_lesson", "question": provided_lesson_question, "equipment": latest_detected_equipment, "user_id": current_user_id});
		    // Inform the user of the lesson generation process.
		    let overlay = $('div.main > div.notification_overlay');
		    if(overlay.hasClass("idle")) overlay.removeClass("idle");
		    overlay.children("iframe").attr("src", "lessons/gemini_animations/gemini_lesson_waiting_generation.html");
		    overlay.children("h2").text("🤖 [gemini-2.5-flash] generating a new lesson on: " + provided_lesson_question);	
		    // Then, clear previously given lesson question choices for performing the subsequent AI-based lesson generation accurately.
		    $('div.gemini_lessons > section[cat="object_detection"] > div > textarea').val("");
		    $('div.gemini_lessons > section[cat="object_detection"] > div > article > p').removeClass("clicked");
		    provided_lesson_question = "";
        }
	}
});

$('div.gemini_lessons > section[cat="lesson_panel"]').on("click", '> article:not(.account_notification)', function(event){
    let lesson_filename = $(this).attr("lesson_filename");
    $('div.gemini_lessons > section[cat="lesson"] > iframe').attr("src", lesson_filename);
});

$("div.header > div.menu_control").on("click", function(event){
	let menu_but_overlay = $(this).children("section:nth-child(3)");
	if(!menu_but_overlay.hasClass("to_right") && !menu_but_overlay.hasClass("to_left")){
		menu_but_overlay.addClass("to_right");
	}else if(menu_but_overlay.hasClass("to_right") && !menu_but_overlay.hasClass("to_left")){
		menu_but_overlay.removeClass("to_right");
		menu_but_overlay.addClass("to_left");
	}else if(!menu_but_overlay.hasClass("to_right") && menu_but_overlay.hasClass("to_left")){
		menu_but_overlay.removeClass("to_left");
		menu_but_overlay.addClass("to_right");		
	}
});

$("div.header > div.menu_control > section:nth-child(3)").on("animationend", function(event){
	let menu_but_right = $(this).parent().children("section:nth-child(2)");
	let menu_but_left = $(this).parent().children("section:nth-child(1)");
	const applied_anim = event.originalEvent.animationName;
	if(applied_anim == "move_header_right"){
		menu_but_right.children("h2").addClass("highlighted");
		menu_but_left.children("h2").removeClass("highlighted");
		// Update dashboard section visibility accordingly.
		$("div.main > div.sensor_interface").removeClass("showing");
		$("div.main > div.gemini_lessons").addClass("showing");
	}else if(applied_anim == "move_header_left"){
		menu_but_left.children("h2").addClass("highlighted");
		menu_but_right.children("h2").removeClass("highlighted");
		// Update dashboard section visibility accordingly.
		$("div.main > div.gemini_lessons").removeClass("showing");
		$("div.main > div.sensor_interface").addClass("showing");		
	}
});

$('div.gemini_lessons > section[cat="object_detection"] > section > div > button').on("click", function(event){
    // Get the given label for the image sample.
    let sample_label = $('div.gemini_lessons > section[cat="object_detection"] > section > div > input').val();
    if(sample_label != ""){
      // Inform the backend accordingly.
      socket.emit("save_new_image_sample", {"sample_label": sample_label});
    }else{
      alert("⚠️ Please enter a label for the new image sample!");
    }
});

$('div.sensor_interface > section[cat="exp"] > span').on("click", function(event){
	// Get the contents of the target iframe as plain text.
	let lab_exp_container = $('div.sensor_interface > section[cat="exp"] > iframe');
	let lab_exp_src = lab_exp_container.attr("src");
	let lab_experiment_content = lab_exp_container.contents().find('body').text();
	// Check whether the user selected an example lab experiment.
	if(lab_exp_src != "experiments/gemini_home.html"){
		// Check if the text-to-speech module has already been activated to stop the ongoing speech with a subsequent click.
		if(window.speechSynthesis.speaking){
			// Halt the ongoing speech.
			if($(this).hasClass("initiated")) $(this).removeClass("initiated");
			window.speechSynthesis.cancel();
		}else{
			// Define custom module configurations.
			window.speechSynthesis.cancel();
			if(!$(this).hasClass("initiated")) $(this).addClass("initiated");
			const tts_module = new SpeechSynthesisUtterance(lab_experiment_content);
			tts_module.voice = googleVoices.find(v => v.name === "Google UK English Female");
			// Assign an end operation function to notify the user accordingly when the speech completed.
			tts_module.onend = function(event){
				if($('div.sensor_interface > section[cat="exp"] > span').hasClass("initiated")) $('div.sensor_interface > section[cat="exp"] > span').removeClass("initiated");
			    const milliseconds = Math.floor(event.elapsedTime / 1000);
				const minutes = Math.floor(milliseconds / 60);
				const seconds = milliseconds % 60;
				const total_elapsed_time = `${minutes} minutes and ${seconds} seconds`;				
				alert("📚 Selected lab experiment text-to-speech event completed in " + total_elapsed_time + ".");
			};
			// Initiate the integrated text-to-speech module.			
			window.speechSynthesis.speak(tts_module);				
		}
	}else{
		alert("🔊 Please select an example lab experiment to be able to utilize the built-in browser text-to-speech module!");
	}
});

$('div.gemini_lessons > section[cat="lesson"] > span').on("click", function(event){
	// Get the contents of the target iframe as plain text.
	let lesson_container = $('div.gemini_lessons > section[cat="lesson"] > iframe');
	let lesson_src = lesson_container.attr("src");
	let lesson_content = lesson_container.contents().find('body').text().trim();
	// Check whether the user selected a previously generated lesson.
	if(lesson_src != "lessons/gemini_animations/gemini_lesson_show_idle.html"){
		// Check if the text-to-speech module has already been activated to stop the ongoing speech with a subsequent click.
		if(window.speechSynthesis.speaking){
			// Halt the ongoing speech.
			if($(this).hasClass("initiated")) $(this).removeClass("initiated");
			window.speechSynthesis.cancel();
		}else{
			// Define custom module configurations.
			window.speechSynthesis.cancel();
			if(!$(this).hasClass("initiated")) $(this).addClass("initiated");
			const tts_module_lesson = new SpeechSynthesisUtterance(lesson_content);
			// Assign an end operation function to notify the user accordingly when the speech completed.
			tts_module_lesson.onend = function(event){
				if($('div.gemini_lessons > section[cat="lesson"] > span').hasClass("initiated")) $('div.gemini_lessons > section[cat="lesson"] > span').removeClass("initiated");
			    const milliseconds = Math.floor(event.elapsedTime / 1000);
				const minutes = Math.floor(milliseconds / 60);
				const seconds = milliseconds % 60;
				const total_elapsed_time = `${minutes} minutes and ${seconds} seconds`;				
				alert("📚 Selected lesson text-to-speech event completed in " + total_elapsed_time + ".");
			};
			// Initiate the integrated text-to-speech module.			
			window.speechSynthesis.speak(tts_module_lesson);
		}
	}else{
		alert("🔊 Please select a previously generated lesson (Gemini) to be able to utilize the built-in browser text-to-speech module!");
	}
});

socket.on("sensor_values", (values) => {
    // Process the received object (Python backend) to obtain and print the retrieved sensor variables.
    Object.keys(values).forEach((main_key) => {
      if(typeof(values[main_key]) === "object"){
        Object.keys(values[main_key]).forEach((key) => {
          $('div.sensor_interface > section[cat="data"] > article[sensor="'+main_key+'"][sp="'+key+'"] > h2').text(values[main_key][key]);
        });
      }else{
        $('div.sensor_interface > section[cat="data"] > article[sensor="'+main_key+'"] > h2').text(values[main_key]);
      }
    });
});

socket.on("latest_obj_detection_result", (detection) => {
    // Process the received object (Python backend) to obtain the latest lab equipment detection results generated by the provided Edge Impulse FOMO object detection model.
    let detected_label = detection["label"];
    let confidence = String(detection["confidence"]);
    let default_questions_container = $('div.gemini_lessons > section[cat="object_detection"] > div > article');
    default_questions_container.attr("latest_detected_equipment", detected_label);
    let associated_default_questions = default_questions[detected_label];
	let question_html_content = "";
	associated_default_questions.forEach((question) => {
		question_html_content += "<p>" + question + "</p>";
	});
	if(question_html_content != "") default_questions_container.html(question_html_content);
    // Notify the user of the detected label and confidence level.
    const label_logo = {"skeleton_model": "💀 ", "microscope": "🔬 ", "alcohol_burner": "⚗️ ", "bunsen_burner": "🪔 ", "dynamometer": "⏲️ "};
    $('div.gemini_lessons > section[cat="object_detection"] > h2').html("<span>" + label_logo[detected_label] + "</span>" + detected_label + " [" + confidence + "]");
    most_recent_detection = true;
});

socket.on("signup_action", (r) => {
    // Process the responses from the Python backend while creating a new user account, distinguished by the registered fingerprint.
    let response = r["response"]; 
    let overlay = $('div.main > div.notification_overlay');
    if(response != "New user account successfully created!"){
      overlay.children("h2").text(response);
    }else{
      if(!overlay.hasClass("idle")) overlay.addClass("idle");
      overlay.children("iframe").attr("src", "");
      overlay.children("h2").text("Please scan your fingerprint!");
      return_state("account_activated");
      alert("🚀 " + response);
    }
});

socket.on("signin_action", (r) => {
    // Process the responses from the Python backend while handling the account activation procedure.
    let response = r["response"];  
    let overlay = $('div.main > div.notification_overlay');
    if(response != "Account activated successfully!"){
      overlay.children("h2").text(response);
    }else{
      if(!overlay.hasClass("idle")) overlay.addClass("idle");
      overlay.children("iframe").attr("src", "");
      overlay.children("h2").text("Please scan your fingerprint!");
      return_state("account_activated");
      alert("🚀 " + response);
    }
});

socket.on("generate_ai_lesson_action", (r) => {
    // Process the responses from the Python backend while producing a new lesson via the provided Cloud LLM (Gemini).
    let response = r["response"];  
    let overlay = $('div.main > div.notification_overlay');
    if(response != "Google (Gemini) [gemini-2.5-flash] produced the requested lesson successfully!"){
      overlay.children("h2").text(response);
    }else{
      if(!overlay.hasClass("idle")) overlay.addClass("idle");
      overlay.children("iframe").attr("src", "");
      overlay.children("h2").text("Please scan your fingerprint!");
      alert("👩‍🚀 " + response);
    }
});

socket.on("save_sample_result", (r) => {
    // Process the responses from the Python backend on the new image sample generation process.
    let response = r["response"];
    alert(response);
});