#include <Arduino.h>
#include <WiFi.h>
#include <WiFiClientSecure.h>
#include "esp_camera.h"
#include <WebServer.h>

const char* ssid       = "yourssidname";
const char* password   = "yourwifipassword";
const char* serverName = "www.circuitdigest.cloud";
const char* serverPath = "/api/v1/object-detection/detect";
const int   serverPort = 443;
const char* apiKey     = "yourapikey";
const char* classes    = "[]";
const char* confidence = "0.2";

#define TRIGGER_BTN 13
unsigned long lastTriggerTime = 0;
const unsigned long debounceDelay = 500;

#define PWDN_GPIO_NUM   32
#define RESET_GPIO_NUM  -1
#define XCLK_GPIO_NUM    0
#define SIOD_GPIO_NUM   26
#define SIOC_GPIO_NUM   27
#define Y9_GPIO_NUM     35
#define Y8_GPIO_NUM     34
#define Y7_GPIO_NUM     39
#define Y6_GPIO_NUM     36
#define Y5_GPIO_NUM     21
#define Y4_GPIO_NUM     19
#define Y3_GPIO_NUM     18
#define Y2_GPIO_NUM      5
#define VSYNC_GPIO_NUM  25
#define HREF_GPIO_NUM   23
#define PCLK_GPIO_NUM   22

WiFiClientSecure client;
WebServer previewServer(80);

// ── Thread-safe camera lock ────────────────────────────────────────────────
SemaphoreHandle_t camMutex = NULL;
inline bool lockCam(TickType_t wait = portMAX_DELAY) {
 return xSemaphoreTake(camMutex, wait) == pdTRUE;
}
inline void unlockCam() { xSemaphoreGive(camMutex); }

// ── Camera init ───────────────────────────────────────────────────────────
void initCamera() {
 camera_config_t config;
 config.ledc_channel = LEDC_CHANNEL_0;
 config.ledc_timer   = LEDC_TIMER_0;
 config.pin_d0 = Y2_GPIO_NUM; config.pin_d1 = Y3_GPIO_NUM;
 config.pin_d2 = Y4_GPIO_NUM; config.pin_d3 = Y5_GPIO_NUM;
 config.pin_d4 = Y6_GPIO_NUM; config.pin_d5 = Y7_GPIO_NUM;
 config.pin_d6 = Y8_GPIO_NUM; config.pin_d7 = Y9_GPIO_NUM;
 config.pin_xclk     = XCLK_GPIO_NUM;
 config.pin_pclk     = PCLK_GPIO_NUM;
 config.pin_vsync    = VSYNC_GPIO_NUM;
 config.pin_href     = HREF_GPIO_NUM;
 config.pin_sscb_sda = SIOD_GPIO_NUM;
 config.pin_sscb_scl = SIOC_GPIO_NUM;
 config.pin_pwdn     = PWDN_GPIO_NUM;
 config.pin_reset    = RESET_GPIO_NUM;
 config.xclk_freq_hz = 20000000;
 config.pixel_format = PIXFORMAT_JPEG;
 config.frame_size   = FRAMESIZE_SVGA;
 config.jpeg_quality = 8;
 config.fb_count     = 2;
 
 esp_err_t err = esp_camera_init(&config);
 if (err != ESP_OK) {
   Serial.printf("Camera init failed: 0x%x\n", err);
   return;
 }
 
 sensor_t* s = esp_camera_sensor_get();
 s->set_brightness(s, 1);
 s->set_contrast(s, 2);
 s->set_saturation(s, 0);
 s->set_whitebal(s, 1);
 s->set_exposure_ctrl(s, 1);
 s->set_gain_ctrl(s, 1);
 s->set_aec2(s, 1);
 s->set_ae_level(s, 1);
 Serial.println("Camera initialized.");
}

// ── Root page (with auto-refresh fallback JS) ─────────────────────────────
void handleRoot() {
 previewServer.send(200, "text/html",
   ""
   ""
   "

"
   ""
   ""
   "

Camera Preview

"
   "

Press the button to detect objects

"
   ""
   ""
 );
}

// ── MJPEG stream handler ──────────────────────────────────────────────────
void handleStream() {
 WiFiClient streamClient = previewServer.client();
 streamClient.println("HTTP/1.1 200 OK");
 streamClient.println("Content-Type: multipart/x-mixed-replace; boundary=frame");
 streamClient.println("Cache-Control: no-cache");
 streamClient.println("Connection: close");
 streamClient.println();
 
 const TickType_t lockWait  = pdMS_TO_TICKS(200);  
 const uint32_t   frameGap  = 50;                  
 const uint32_t   yieldGap  = 80;                  
 const uint32_t   watchdog  = 8000;                
 uint32_t lastFrame = millis();
 
 while (streamClient.connected()) {
   if (millis() - lastFrame > watchdog) {
     Serial.println("[stream] watchdog timeout, dropping client");
     break;
   }
   
   if (!lockCam(lockWait)) {
     vTaskDelay(pdMS_TO_TICKS(yieldGap));
     continue;
   }
   
   camera_fb_t* discard = esp_camera_fb_get();
   if (discard) esp_camera_fb_return(discard);
   camera_fb_t* fb = esp_camera_fb_get();
   unlockCam();
   
   if (!fb) {
     vTaskDelay(pdMS_TO_TICKS(10));
     continue;
   }
   
   streamClient.print("--frame\r\nContent-Type: image/jpeg\r\nContent-Length: ");
   streamClient.print(fb->len);
   streamClient.print("\r\n\r\n");
   size_t written = streamClient.write(fb->buf, fb->len);
   streamClient.print("\r\n");
   esp_camera_fb_return(fb);
   
   if (written == 0) {
     Serial.println("[stream] write failed, dropping client");
     break;
   }
   
   lastFrame = millis();
   vTaskDelay(pdMS_TO_TICKS(frameGap));
 }
 streamClient.stop();
 Serial.println("[stream] client disconnected");
}

// ── Web server task (Core 0) ──────────────────────────────────────────────
void webServerTask(void* param) {
 while (true) {
   previewServer.handleClient();
   vTaskDelay(1);
 }
}

// ── API call ──────────────────────────────────────────────────────────────
String sendImageToAPI(camera_fb_t* fb) {
 if (!client.connect(serverName, serverPort)) {
   return "Connection failed";
 }
 
 String boundary    = "----ESP32Boundary";
 String head        = "--" + boundary + "\r\n"
                      "Content-Disposition: form-data; name=\"imageFile\"; filename=\"photo.jpg\"\r\n"
                      "Content-Type: image/jpeg\r\n\r\n";
 String classesPart = "\r\n--" + boundary + "\r\n"
                      "Content-Disposition: form-data; name=\"classes\"\r\n\r\n"
                    + String(classes) + "\r\n";
 String confPart    = "--" + boundary + "\r\n"
                      "Content-Disposition: form-data; name=\"confidence\"\r\n\r\n"
                    + String(confidence) + "\r\n";
 String tail        = "--" + boundary + "--\r\n";
 
 int contentLen = head.length() + fb->len
                + classesPart.length() + confPart.length() + tail.length();
                
 client.println("POST " + String(serverPath) + " HTTP/1.1");
 client.println("Host: " + String(serverName));
 client.println("X-API-Key: " + String(apiKey));
 client.println("Content-Type: multipart/form-data; boundary=" + boundary);
 client.println("Content-Length: " + String(contentLen));
 client.println("Connection: close");
 client.println();
 client.print(head);
 client.write(fb->buf, fb->len);
 client.print(classesPart);
 client.print(confPart);
 client.print(tail);
 
 uint32_t timeout = millis();
 while (client.available() == 0) {
   if (millis() - timeout > 15000) {
     client.stop();
     return "Timeout";
   }
   delay(10);
 }
 
 String response = "";
 while (client.available()) {
   response += (char)client.read();
 }
 client.stop();
 
 int jsonStart = response.indexOf("\r\n\r\n");
 return (jsonStart != -1) ? response.substring(jsonStart + 4) : response;
}

// ── Setup ─────────────────────────────────────────────────────────────────
void setup() {
 Serial.begin(115200);
 pinMode(TRIGGER_BTN, INPUT_PULLUP);
 camMutex = xSemaphoreCreateMutex();
 
 initCamera();
 WiFi.begin(ssid, password);
 Serial.print("Connecting to WiFi");
 while (WiFi.status() != WL_CONNECTED) {
   delay(500);
   Serial.print(".");
 }
 Serial.println("\nWiFi connected: " + WiFi.localIP().toString());
 Serial.println("Preview: http://" + WiFi.localIP().toString());
 
 client.setInsecure();
 previewServer.on("/",        handleRoot);
 previewServer.on("/stream", handleStream);
 previewServer.begin();
 
 xTaskCreatePinnedToCore(webServerTask, "webTask", 8192, NULL, 1, NULL, 0);
}

// ── Main loop (Core 1) ────────────────────────────────────────────────────
void loop() {
 if (digitalRead(TRIGGER_BTN) != LOW) return;
 uint32_t now = millis();
 if (now - lastTriggerTime < debounceDelay) return;
 lastTriggerTime = now;
 
 Serial.println("Button pressed — capturing...");
 
 if (WiFi.status() != WL_CONNECTED) {
   Serial.println("WiFi lost, reconnecting...");
   WiFi.begin(ssid, password);
   for (int i = 0; i < 20 && WiFi.status() != WL_CONNECTED; i++) {
     delay(500); Serial.print(".");
   }
   if (WiFi.status() != WL_CONNECTED) {
     Serial.println("Reconnect failed!");
     return;
   }
   Serial.println("WiFi back.");
 }
 
 if (!lockCam(pdMS_TO_TICKS(3000))) {
   Serial.println("Could not lock camera — try again");
   return;
 }
 
 sensor_t* s = esp_camera_sensor_get();
 s->set_framesize(s, FRAMESIZE_VGA);
 s->set_quality(s, 10);
 delay(150);
 
 camera_fb_t* warmup = esp_camera_fb_get();
 if (warmup) esp_camera_fb_return(warmup);
 delay(80);
 
 camera_fb_t* fb = esp_camera_fb_get();
 if (!fb) {
   Serial.println("Capture failed");
   s->set_framesize(s, FRAMESIZE_SVGA);
   s->set_quality(s, 8);
   unlockCam();
   return;
 }
 
 Serial.printf("Captured %u bytes — sending to API...\n", fb->len);
 String result = sendImageToAPI(fb);
 esp_camera_fb_return(fb);
 
 s->set_framesize(s, FRAMESIZE_SVGA);
 s->set_quality(s, 8);
 unlockCam();
 
 Serial.println("Response: " + result);
 int idx = result.indexOf("\"detection_count\":");
 if (idx != -1) {
   int start = result.indexOf(':', idx) + 1;
   int end   = result.indexOf(',', start);
   String count = result.substring(start, end);
   count.trim();
   Serial.println("Objects detected: " + count);
 } else {
   Serial.println("No detection data in response.");
 }
}