#include <Wire.h>
#include <LiquidCrystal_I2C.h>
#include <WiFi.h>
#include <HTTPClient.h>
#include "driver/i2s.h"
#include "Arduino.h" 
#include <Wire.h>
#include <LiquidCrystal_I2C.h>
#include <WiFi.h>
#include <HTTPClient.h>
#include <Base64.h>

#include <Wire.h>
#include <LiquidCrystal_I2C.h>
#include <WiFi.h>
#include <HTTPClient.h>
#include "driver/i2s.h"

#include <Wire.h>
#include <LiquidCrystal_I2C.h>
#include <WiFi.h>
#include <HTTPClient.h>
#include "driver/i2s.h"
#include "Base64.h"  // Include Base64 library

#include <Wire.h>
#include <LiquidCrystal_I2C.h>
#include <WiFi.h>
#include <HTTPClient.h>
#include "driver/i2s.h"
#include "Base64.h"

#include <Wire.h>
#include <LiquidCrystal_I2C.h>
#include <WiFi.h>
#include <HTTPClient.h>
#include "driver/i2s.h"
#include <Base64.h>

#include <Wire.h>
#include <LiquidCrystal_I2C.h>
#include <WiFi.h>
#include <HTTPClient.h>
#include "driver/i2s.h"

#include <Wire.h>
#include <LiquidCrystal_I2C.h>
#include <WiFi.h>
#include <HTTPClient.h>
#include <Base64.h>  // Include the Base64 library
#include "driver/i2s.h"

// WiFi credentials
const char* ssid = "Wokwi-GUEST";
const char* password = "";

// IBM Watson Speech-to-Text API credentials
const char* watsonEndpoint = "https://api.eu-gb.speech-to-text.watson.cloud.ibm.com/instances/18772bdb-f46f-48b0-b34c-bc269acf3ded";
const char* watsonApiKey = "0qbL1IoNhNBR9rXILEpw9QEKOI6Hy9DbofiymPRJw3BY";

// I2S Microphone Configuration
#define I2S_MIC_CHANNEL I2S_CHANNEL_FMT_ONLY_LEFT  // Left channel for mono audio
#define SAMPLE_RATE 16000                          // Sampling rate
#define I2S_MIC_PIN_BCK 26                         // I2S Bit Clock
#define I2S_MIC_PIN_WS 25                          // I2S Word Select
#define I2S_MIC_PIN_DATA 27                        // I2S Data
#define BUFFER_SIZE 1024                           // Buffer size for audio data

// LCD display
LiquidCrystal_I2C lcd(0x27, 20, 4);

// Function prototypes
void initI2SMicrophone();
String recordAudio();
String sendAudioToWatson(String audioData);

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

  // Initialize LCD
  lcd.init();
  lcd.backlight();
  lcd.setCursor(0, 0);
  lcd.print("Initializing...");

  // Connect to WiFi
  WiFi.begin(ssid, password);
  while (WiFi.status() != WL_CONNECTED) {
    delay(1000);
    Serial.println("Connecting to WiFi...");
    lcd.setCursor(0, 1);
    lcd.print("Connecting WiFi...");
  }
  Serial.println("Connected to WiFi");
  lcd.setCursor(0, 1);
  lcd.print("WiFi Connected  ");

  // Initialize I2S
  initI2SMicrophone();
  lcd.setCursor(0, 2);
  lcd.print("Mic Initialized");

  
}

void loop() {
  //lcd.clear();
  //lcd.setCursor(0, 3);
  //lcd.setCursor(0, 1);
  //lcd.print("Recording...");
  //delay(500);
  
  String audioData = recordAudio();

  lcd.setCursor(0, 3);
  lcd.print("Sending to API...");

  String transcript = sendAudioToWatson(audioData);

  lcd.clear();
  lcd.setCursor(0, 0);
  lcd.print("Transcript:");
  lcd.setCursor(0, 1);
  lcd.print(transcript);

  delay(10000); // Wait 10 seconds before the next recording
}

void initI2SMicrophone() {
  i2s_config_t i2s_config = {
      .mode = (i2s_mode_t)(I2S_MODE_MASTER | I2S_MODE_RX),
      .sample_rate = 16000,                      // Sampling frequency (16 kHz)
      .bits_per_sample = I2S_BITS_PER_SAMPLE_16BIT,
      .channel_format = I2S_CHANNEL_FMT_ONLY_LEFT, // INMP441 uses left channel by default
      .communication_format = I2S_COMM_FORMAT_I2S,
      .intr_alloc_flags = ESP_INTR_FLAG_LEVEL1,
      .dma_buf_count = 4,                        // Number of DMA buffers
      .dma_buf_len = 1024,                       // Length of each DMA buffer
      .use_apll = false,
      .tx_desc_auto_clear = false,
      .fixed_mclk = 0
  };

  i2s_pin_config_t pin_config = {
      .bck_io_num = 26,   // BCK pin
      .ws_io_num = 25,    // WS pin
      .data_out_num = I2S_PIN_NO_CHANGE,
      .data_in_num = 27   // DATA pin
  };

  // Install the I2S driver
  i2s_driver_install(I2S_NUM_0, &i2s_config, 0, NULL);
  // Configure I2S pins
  i2s_set_pin(I2S_NUM_0, &pin_config);
  // Set clock
  i2s_set_clk(I2S_NUM_0, 16000, I2S_BITS_PER_SAMPLE_16BIT, I2S_CHANNEL_MONO);
}


String recordAudio() {
  int16_t samples[BUFFER_SIZE];
  size_t bytesRead;
  String audioData = "";

  Serial.println("Start Recording...");
  unsigned long startTime = millis();

  while (millis() - startTime < 2000) { // Record for 2 seconds
    Serial.println("Reading I2S Data...");
    int res = i2s_read(I2S_NUM_0, samples, BUFFER_SIZE * sizeof(int16_t), &bytesRead, 1000 / portTICK_PERIOD_MS);
    //int res = i2s_read(I2S_NUM_0, samples, BUFFER_SIZE * sizeof(int16_t), &bytesRead, portMAX_DELAY);
    if (res == ESP_OK && bytesRead > 0) {
      Serial.println("Bytes read: " + String(bytesRead));
      for (int i = 0; i < bytesRead / 2; i++) {
        audioData += String(samples[i]) + ",";
      }
    } else if (res == ESP_ERR_TIMEOUT) {
      Serial.println("I2S Read timeout.");
    } else {
      Serial.println("I2S Read failed: " + String(res));
    }
  }

  Serial.println("Recording Completed.");
  return audioData;
}



String sendAudioToWatson(String audioData) {
  if (WiFi.status() == WL_CONNECTED) {
    HTTPClient http;
    http.begin(watsonEndpoint);

    // Create the Authorization header
    String auth = "apikey:" + String(watsonApiKey);
    char encodedAuth[128];
    Base64.encode(encodedAuth, (char*)auth.c_str(), auth.length());

    http.addHeader("Authorization", "Basic " + String(encodedAuth));
    http.addHeader("Content-Type", "audio/wav");

    int httpResponseCode = http.POST(audioData);
    if (httpResponseCode > 0) {
      String response = http.getString();
      Serial.println("Response: " + response);
      return response; // Extract and return transcript from response
    } else {
      Serial.println("Error on sending POST: " + String(httpResponseCode));
      return "Error Sending Data";
    }

    http.end();
  } else {
    Serial.println("WiFi not connected");
    return "WiFi Error";
  }
}