#include "esp_camera.h"
#include <WiFi.h>
#include "esp_http_server.h"
#include "soc/soc.h"
#include "soc/rtc_cntl_reg.h"
#include <TinyGPSPlus.h>
#include <HTTPClient.h>
#include <WiFiClientSecure.h>
#include <mbedtls/base64.h>

// ======================= WIFI CREDENTIALS =======================
const char* WIFI_SSID     = "PLDTHOMEFIBR42250";
const char* WIFI_PASSWORD = "PLDTWIFIxw232";

// ======================= OPTIONAL STATIC IP =====================
// Uncomment to lock the IP at 192.168.1.24
// #define USE_STATIC_IP
IPAddress local_IP(192, 168, 1, 24);
IPAddress gateway  (192, 168, 1, 1);
IPAddress subnet   (255, 255, 255, 0);
IPAddress dns1     (8, 8, 8, 8);
IPAddress dns2     (8, 8, 4, 4);

// ======================= CAMERA PINS (AI-Thinker) ===============
#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

// ======================= STATUS LED =============================
#define STATUS_LED_PIN     4

// ======================= CAPTURE BUTTON =========================
#define CAPTURE_BUTTON_PIN 15

// ======================= GPS PINS ===============================
#define GPS_RX_PIN        13
#define GPS_TX_PIN        14
#define GPS_BAUD          9600

// ======================= GOOGLE SHEETS ==========================
const char* GOOGLE_SCRIPT_URL =
  "https://script.google.com/macros/s/AKfycbw2ruhCAJ8C4HWvXdK0_SF8pC0svf7E4tENK_tQeg6Lf5TFsCJtrysaxIRXXhiJBEeH/exec";

// ======================= OBJECTS ================================
TinyGPSPlus gps;
HardwareSerial GPS_Serial(1);

httpd_handle_t camera_httpd = NULL;   // port 80  - UI / capture / GPS
httpd_handle_t stream_httpd = NULL;   // port 81  - MJPEG stream only

SemaphoreHandle_t captureMutex;
SemaphoreHandle_t cameraMutex;
volatile bool uploadBusy = false;

// ======================= SHARED STATE ===========================
volatile bool     capturePending    = false;
volatile bool     lastCaptureValid  = false;
volatile double   lastCaptureLat    = 0.0;
volatile double   lastCaptureLng    = 0.0;
volatile double   lastCaptureAlt    = 0.0;
volatile uint32_t lastCaptureSat    = 0;
volatile double   lastCaptureHdop   = 0.0;
String            lastCaptureStatus = "NO CAPTURE YET";
String            lastDriveUrl      = "";

uint8_t*          lastJpegBuf       = nullptr;
size_t            lastJpegLen       = 0;

volatile bool     logPending        = false;
bool              logValid          = false;
double            logLat = 0, logLng = 0, logAlt = 0, logHdop = 0;
uint32_t          logSat = 0;

// ======================= MJPEG BOUNDARY =========================
#define PART_BOUNDARY "123456789000000000000987654321"
static const char* STREAM_CONTENT_TYPE =
  "multipart/x-mixed-replace;boundary=" PART_BOUNDARY;
static const char* STREAM_BOUNDARY = "\r\n--" PART_BOUNDARY "\r\n";
static const char* STREAM_PART =
  "Content-Type: image/jpeg\r\nContent-Length: %u\r\n\r\n";

// ======================= GPS LED ================================
void updateGPSLED() {
  static unsigned long lastBlink = 0;
  static int  blinkCount = 0;
  static bool ledState = false;
  static bool pauseAfterBlink = false;

  if (!gps.location.isValid()) {
    digitalWrite(STATUS_LED_PIN, HIGH);
    blinkCount = 0; ledState = true; pauseAfterBlink = false;
    return;
  }
  if (pauseAfterBlink) {
    if (millis() - lastBlink >= 2000) {
      pauseAfterBlink = false; blinkCount = 0; lastBlink = millis();
    }
    return;
  }
  if (millis() - lastBlink >= 250) {
    lastBlink = millis();
    ledState = !ledState;
    digitalWrite(STATUS_LED_PIN, ledState ? HIGH : LOW);
    if (!ledState) {
      blinkCount++;
      if (blinkCount >= 2) {
        digitalWrite(STATUS_LED_PIN, LOW);
        pauseAfterBlink = true;
      }
    }
  }
}

// ======================= GOOGLE DRIVE + SHEETS UPLOAD ============
// The Apps Script receives one JSON POST containing:
//   - JPEG image as Base64
//   - GPS coordinates / metadata
// It then saves the JPEG to Google Drive and writes the capture
// information + Drive URL into the Google Sheet.
//
// IMPORTANT: Google Apps Script web apps don't return the response
// directly. They execute the script, then send a 302 redirect to a
// script.googleusercontent.com URL holding the real result. The
// ESP32 Arduino core's HTTPClient has a known bug where its
// automatic redirect-following mangles that second request (Google
// then rejects it with a generic "400 Bad Request" HTML error page
// that has nothing to do with your Apps Script code). So here we
// disable automatic redirects and follow the Location header
// ourselves with a clean, fresh GET request.
// ================================================================
bool uploadCaptureToGoogleDrive(bool valid, double latitude, double longitude,
                                double altitude, uint32_t satellites, double hdop) {
  if (WiFi.status() != WL_CONNECTED) {
    Serial.println("[UPLOAD] WiFi is not connected.");
    return false;
  }

  // Take a stable snapshot of the JPEG pointer/length. The capture task
  // refuses to replace the JPEG while an upload is in progress.
  xSemaphoreTake(captureMutex, portMAX_DELAY);
  if (!lastJpegBuf || lastJpegLen == 0) {
    xSemaphoreGive(captureMutex);
    Serial.println("[UPLOAD] No JPEG available.");
    return false;
  }
  uint8_t* jpeg = lastJpegBuf;
  size_t jpegLen = lastJpegLen;
  xSemaphoreGive(captureMutex);

  const size_t base64Len = ((jpegLen + 2) / 3) * 4;
  const size_t prefixCapacity = 600;
  const size_t bodyCapacity = base64Len + prefixCapacity + 4;

  char* body = (char*)ps_malloc(bodyCapacity + 1);
  if (!body) {
    Serial.println("[UPLOAD] PSRAM allocation FAILED.");
    return false;
  }

  int prefixLen = snprintf(
    body, bodyCapacity + 1,
    "{\"action\":\"upload\",\"valid\":%s,\"latitude\":%.6f,\"longitude\":%.6f,\"altitude\":%.2f,\"satellites\":%lu,\"hdop\":%.2f,\"image\":\"",
    valid ? "true" : "false",
    valid ? latitude : 0.0,
    valid ? longitude : 0.0,
    valid ? altitude : 0.0,
    (unsigned long)satellites,
    valid ? hdop : 0.0
  );

  if (prefixLen <= 0) {
    free(body);
    Serial.println("[UPLOAD] JSON prefix FAILED.");
    return false;
  }

  size_t encodedLen = 0;
  int b64 = mbedtls_base64_encode(
    (unsigned char*)(body + prefixLen), bodyCapacity - prefixLen,
    &encodedLen, jpeg, jpegLen
  );

  if (b64 != 0) {
    free(body);
    Serial.print("[UPLOAD] Base64 encoding FAILED: ");
    Serial.println(b64);
    return false;
  }

  size_t totalLen = (size_t)prefixLen + encodedLen;
  body[totalLen++] = '"';
  body[totalLen++] = '}';
  body[totalLen] = '\0';

  Serial.println();
  Serial.println("========== GOOGLE UPLOAD ==========");
  Serial.print("JPEG bytes: "); Serial.println(jpegLen);
  Serial.print("Base64 bytes: "); Serial.println(encodedLen);
  Serial.print("POST bytes: "); Serial.println(totalLen);

  WiFiClientSecure client;
  client.setInsecure();

  HTTPClient http;
  http.setConnectTimeout(30000);
  http.setTimeout(60000);
  // Do NOT auto-follow redirects here — see comment above the function.
  http.setFollowRedirects(HTTPC_DISABLE_FOLLOW_REDIRECTS);

  if (!http.begin(client, GOOGLE_SCRIPT_URL)) {
    free(body);
    Serial.println("[UPLOAD] HTTP begin FAILED.");
    return false;
  }

  http.addHeader("Content-Type", "application/json");
  http.addHeader("Accept", "application/json");
  http.addHeader("Connection", "close");

  Serial.println("[UPLOAD] Sending POST to Google Apps Script...");
  int code = http.POST((uint8_t*)body, totalLen);

  // We're done with the request body now regardless of outcome.
  free(body);

  String response;

  if (code == 301 || code == 302 || code == 303 || code == 307) {
    // Manually follow the redirect Google sends us with a fresh,
    // clean GET request — this is the part the built-in redirect
    // handling gets wrong.
    String location = http.header("Location");
    http.end();

    Serial.print("[UPLOAD] Redirected (");
    Serial.print(code);
    Serial.print(") to: ");
    Serial.println(location);

    if (location.length() == 0) {
      Serial.println("[UPLOAD] No Location header found on redirect.");
      Serial.println("===================================");
      return false;
    }

    WiFiClientSecure client2;
    client2.setInsecure();

    HTTPClient http2;
    http2.setConnectTimeout(30000);
    http2.setTimeout(60000);

    if (!http2.begin(client2, location)) {
      Serial.println("[UPLOAD] Redirect HTTP begin FAILED.");
      Serial.println("===================================");
      return false;
    }

    int code2 = http2.GET();
    Serial.print("[UPLOAD] Redirect HTTP code: ");
    Serial.println(code2);

    if (code2 > 0) {
      response = http2.getString();
      code = code2;
    } else {
      Serial.print("[UPLOAD] Redirect HTTP error: ");
      Serial.println(http2.errorToString(code2));
      http2.end();
      Serial.println("===================================");
      return false;
    }

    http2.end();

  } else if (code > 0) {
    response = http.getString();
    http.end();
  } else {
    Serial.print("[UPLOAD] HTTP error: ");
    Serial.println(http.errorToString(code));
    http.end();
    Serial.println("===================================");
    return false;
  }

  Serial.print("[UPLOAD] HTTP code: ");
  Serial.println(code);
  Serial.print("[UPLOAD] Response: ");
  Serial.println(response);

  bool ok = false;
  if (code >= 200 && code < 300 &&
      (response.indexOf("\"success\":true") >= 0 ||
       response.indexOf("\"success\": true") >= 0)) {
    ok = true;

    int u = response.indexOf("\"fileUrl\"");
    if (u >= 0) {
      u = response.indexOf(':', u);
      if (u >= 0) {
        u++;
        while (u < (int)response.length() && response[u] == ' ') u++;
        if (u < (int)response.length() && response[u] == '"') {
          u++;
          int e = response.indexOf('"', u);
          if (e > u) {
            xSemaphoreTake(captureMutex, portMAX_DELAY);
            lastDriveUrl = response.substring(u, e);
            xSemaphoreGive(captureMutex);
          }
        }
      }
    }
  }

  Serial.println(ok ? "[UPLOAD] SUCCESS: Drive + Sheets" : "[UPLOAD] FAILED");
  Serial.println("===================================");
  return ok;
}

// ======================= BACKGROUND UPLOAD TASK ================
void loggerTask(void* param) {
  for (;;) {
    if (logPending && !uploadBusy) {
      logPending = false;
      uploadBusy = true;

      bool ok = uploadCaptureToGoogleDrive(
        logValid, logLat, logLng, logAlt, logSat, logHdop);

      xSemaphoreTake(captureMutex, portMAX_DELAY);
      if (ok) {
        lastCaptureStatus = logValid
          ? "GPS FIX - IMAGE SAVED"
          : "NO GPS FIX - IMAGE SAVED";
      } else {
        lastCaptureStatus = logValid
          ? "GPS FIX - IMAGE UPLOAD FAILED"
          : "NO GPS FIX - IMAGE UPLOAD FAILED";
      }
      xSemaphoreGive(captureMutex);
      uploadBusy = false;
    }
    vTaskDelay(50 / portTICK_PERIOD_MS);
  }
}

// ======================= CAPTURE CORE ===========================
bool performCapture() {
  if (uploadBusy || logPending) {
    Serial.println(">>> Capture ignored: previous upload is still in progress.");
    return false;
  }

  Serial.println(">>> Starting camera capture...");

  // Protect the camera from the streaming task. The mutex is released
  // immediately after getting the frame so the network stream can continue.
  if (xSemaphoreTake(cameraMutex, pdMS_TO_TICKS(5000)) != pdTRUE) {
    Serial.println(">>> Camera busy: capture timed out.");
    return false;
  }

  camera_fb_t *fb = esp_camera_fb_get();
  if (!fb) {
    xSemaphoreGive(cameraMutex);
    Serial.println(">>> Camera capture FAILED (fb_get returned NULL).");
    return false;
  }

  size_t frameLen = fb->len;
  uint8_t* newBuf = (uint8_t*)ps_malloc(frameLen);
  if (newBuf) memcpy(newBuf, fb->buf, frameLen);
  esp_camera_fb_return(fb);
  xSemaphoreGive(cameraMutex);

  if (!newBuf) {
    Serial.println(">>> JPEG PSRAM allocation FAILED.");
    return false;
  }

  bool valid = gps.location.isValid();
  double lat = valid ? gps.location.lat() : 0.0;
  double lng = valid ? gps.location.lng() : 0.0;
  double alt = (valid && gps.altitude.isValid()) ? gps.altitude.meters() : 0.0;
  double hdop = (valid && gps.hdop.isValid()) ? gps.hdop.hdop() : 0.0;
  uint32_t sat = gps.satellites.isValid() ? gps.satellites.value() : 0;

  xSemaphoreTake(captureMutex, portMAX_DELAY);
  if (lastJpegBuf) free(lastJpegBuf);
  lastJpegBuf = newBuf;
  lastJpegLen = frameLen;
  lastCaptureValid = valid;
  lastCaptureLat = lat;
  lastCaptureLng = lng;
  lastCaptureAlt = alt;
  lastCaptureSat = sat;
  lastCaptureHdop = hdop;
  lastCaptureStatus = "UPLOAD QUEUED";
  lastDriveUrl = "";
  xSemaphoreGive(captureMutex);

  logValid = valid;
  logLat = lat;
  logLng = lng;
  logAlt = alt;
  logSat = sat;
  logHdop = hdop;
  logPending = true;

  Serial.println(">>> Capture done.");
  Serial.print(">>> JPEG bytes: "); Serial.println(frameLen);
  Serial.print(">>> GPS: "); Serial.println(valid ? "FIX" : "NO FIX");
  Serial.println(">>> Google Drive + Google Sheets upload queued.");
  return true;
}

// ======================= ROOT PAGE (HTML/CSS/JS) ================
static const char INDEX_HTML[] = R"HTML(
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="utf-8">
<title>ESP32-CAM GPS Live</title>
<meta name="viewport" content="width=device-width, initial-scale=1, maximum-scale=1">
<style>
  :root{
    --bg1:#0a0e17; --bg2:#111827; --card:rgba(255,255,255,.05);
    --card-border:rgba(255,255,255,.09); --text:#e7eaf2; --dim:#8b93a7;
    --accent1:#22d3ee; --accent2:#a78bfa; --good:#34d399; --bad:#f87171;
    --radius:18px;
  }
  *{box-sizing:border-box;}
  body{
    margin:0; min-height:100vh; color:var(--text);
    font-family:-apple-system,BlinkMacSystemFont,"Segoe UI",Roboto,Helvetica,Arial,sans-serif;
    background:
      radial-gradient(circle at 15% -10%, rgba(34,211,238,.14), transparent 40%),
      radial-gradient(circle at 100% 0%, rgba(167,139,250,.14), transparent 45%),
      linear-gradient(160deg,var(--bg1) 0%,var(--bg2) 55%,var(--bg1) 100%);
    padding:18px 14px 40px;
  }
  .wrap{max-width:640px; margin:0 auto;}
  .topbar{display:flex; align-items:center; justify-content:space-between;
    gap:10px; margin-bottom:16px; flex-wrap:wrap;}
  .brand{display:flex; align-items:center; gap:10px;}
  .brand svg{width:26px; height:26px; flex:none;}
  .brand h1{font-size:17px; margin:0; font-weight:700; letter-spacing:.2px;}
  .brand span{display:block; font-size:11px; color:var(--dim); font-weight:500;}
  .pill{display:flex; align-items:center; gap:7px;
    background:var(--card); border:1px solid var(--card-border);
    padding:7px 12px; border-radius:999px; font-size:12.5px; color:var(--dim);
    backdrop-filter:blur(6px);}
  .dot{width:8px; height:8px; border-radius:50%; background:var(--bad); flex:none;}
  .dot.on{background:var(--good); box-shadow:0 0 0 0 rgba(52,211,153,.6);
    animation:pulse 1.6s infinite;}
  @keyframes pulse{
    0%{box-shadow:0 0 0 0 rgba(52,211,153,.55);}
    70%{box-shadow:0 0 0 7px rgba(52,211,153,0);}
    100%{box-shadow:0 0 0 0 rgba(52,211,153,0);}
  }
  .card{background:var(--card); border:1px solid var(--card-border);
    border-radius:var(--radius); backdrop-filter:blur(6px);}
  .stream-card{position:relative; overflow:hidden; padding:0;}
  .stream-ratio{position:relative; width:100%; aspect-ratio:4/3; background:#000;}
  .stream-ratio img{position:absolute; inset:0; width:100%; height:100%;
    object-fit:cover; display:block;}
  .live-badge{position:absolute; top:10px; left:10px; z-index:2;
    display:flex; align-items:center; gap:6px;
    background:rgba(0,0,0,.55); border:1px solid rgba(255,255,255,.12);
    padding:5px 10px 5px 8px; border-radius:999px; font-size:11.5px; font-weight:700;
    letter-spacing:.4px; backdrop-filter:blur(4px);}
  .live-dot{width:7px; height:7px; border-radius:50%; background:var(--bad);}
  .live-dot.on{background:#ff3b3b; animation:pulse 1.3s infinite;}
  .stream-overlay{position:absolute; inset:0; z-index:1; display:flex; align-items:center;
    justify-content:center; flex-direction:column; gap:10px; text-align:center;
    padding:20px; color:var(--dim); font-size:13.5px; transition:opacity .3s;}
  .spinner{width:26px; height:26px; border-radius:50%;
    border:3px solid rgba(255,255,255,.15); border-top-color:var(--accent1);
    animation:spin 0.8s linear infinite;}
  @keyframes spin{to{transform:rotate(360deg);}}
  .controls{display:flex; flex-direction:column; align-items:center;
    gap:10px; margin:20px 0 6px;}
  .capture-btn{display:flex; align-items:center; gap:9px; border:none; cursor:pointer;
    color:#0a0e17; font-weight:800; font-size:15.5px; letter-spacing:.2px;
    padding:15px 30px; border-radius:999px;
    background:linear-gradient(135deg,var(--accent1),var(--accent2));
    box-shadow:0 10px 26px -10px rgba(34,211,238,.55);
    transition:transform .15s ease, box-shadow .15s ease, filter .15s ease;}
  .capture-btn:active{transform:scale(.97);}
  .capture-btn:hover{filter:brightness(1.06);}
  .capture-btn:disabled{cursor:wait; filter:grayscale(.35) brightness(.8);
    box-shadow:none; transform:none;}
  .capture-btn svg{width:19px; height:19px;}
  .btn-spinner{width:16px; height:16px; border-radius:50%;
    border:2.5px solid rgba(10,14,23,.25); border-top-color:#0a0e17;
    animation:spin .7s linear infinite;}
  .status-line{font-size:12.5px; color:var(--dim); min-height:16px; text-align:center;}
  .hint{display:flex; align-items:center; justify-content:center; gap:6px;
    font-size:11.5px; color:var(--dim); opacity:.75; margin-top:2px;}
  .gps-card{margin-top:16px; padding:16px 16px 18px; opacity:0; transform:translateY(-8px);
    max-height:0; overflow:hidden; transition:opacity .35s ease, transform .35s ease;}
  .gps-card.show{opacity:1; transform:translateY(0); max-height:600px;}
  .gps-head{display:flex; align-items:center; justify-content:space-between; margin-bottom:12px;}
  .gps-head h2{font-size:14px; margin:0; font-weight:700;}
  .badge{font-size:11px; font-weight:800; letter-spacing:.3px; padding:4px 10px;
    border-radius:999px; display:flex; align-items:center; gap:5px;}
  .badge.good{color:var(--good); background:rgba(52,211,153,.12);
    border:1px solid rgba(52,211,153,.3);}
  .badge.bad{color:var(--bad); background:rgba(248,113,113,.12);
    border:1px solid rgba(248,113,113,.3);}
  .stat-grid{display:grid; grid-template-columns:1fr 1fr; gap:8px;}
  .stat{background:rgba(255,255,255,.035); border:1px solid var(--card-border);
    border-radius:12px; padding:10px 12px;}
  .stat.wide{grid-column:1 / -1;}
  .stat .label{font-size:10.5px; color:var(--dim); text-transform:uppercase;
    letter-spacing:.5px; font-weight:700; margin-bottom:3px;}
  .stat .value{font-size:14.5px; font-weight:700; word-break:break-all;}
  .maps-btn{margin-top:12px; width:100%; display:flex; align-items:center;
    justify-content:center; gap:8px; text-decoration:none; padding:12px;
    border-radius:12px; font-weight:700; font-size:13.5px; color:var(--text);
    background:rgba(255,255,255,.04); border:1px solid var(--card-border);
    transition:background .15s ease;}
  .maps-btn:hover{background:rgba(255,255,255,.08);}
  .maps-btn svg{width:16px; height:16px;}
  .log-line{font-size:12px; color:var(--dim); margin-top:10px; text-align:center;}
  .log-line b{color:var(--text);}
</style>
</head>
<body>
<div class="wrap">
  <div class="topbar">
    <div class="brand">
      <svg viewBox="0 0 24 24" fill="none" stroke="url(#g1)" stroke-width="1.8">
        <defs><linearGradient id="g1" x1="0" y1="0" x2="1" y2="1">
          <stop offset="0" stop-color="#22d3ee"/><stop offset="1" stop-color="#a78bfa"/>
        </linearGradient></defs>
        <path d="M4 8h2l1.5-2h9L18 8h2a2 2 0 0 1 2 2v8a2 2 0 0 1-2 2H4a2 2 0 0 1-2-2v-8a2 2 0 0 1 2-2z"/>
        <circle cx="12" cy="13" r="3.5"/>
      </svg>
      <div><h1>ESP32-CAM GPS</h1><span>Live field camera</span></div>
    </div>
    <div class="pill"><span class="dot" id="wifiDot"></span><span id="ip">connecting...</span></div>
  </div>

  <div class="card stream-card">
    <div class="stream-ratio">
      <img id="stream" alt="live stream">
      <div class="stream-overlay" id="streamOverlay">
        <div class="spinner"></div>
        <div>Connecting to camera stream…</div>
      </div>
    </div>
    <div class="live-badge"><span class="live-dot" id="liveDot"></span><span id="liveText">OFFLINE</span></div>
  </div>

  <div class="controls">
    <button id="captureBtn" class="capture-btn" onclick="captureImage()">
      <svg id="camIcon" viewBox="0 0 24 24" fill="none" stroke="#0a0e17" stroke-width="2">
        <path d="M4 8h2l1.5-2h9L18 8h2a2 2 0 0 1 2 2v8a2 2 0 0 1-2 2H4a2 2 0 0 1-2-2v-8a2 2 0 0 1 2-2z"/>
        <circle cx="12" cy="13" r="3.5"/>
      </svg>
      <span id="btnLabel">Capture Image</span>
    </button>
    <div class="status-line" id="ts">Ready — tap to capture, or use the physical button.</div>
    <div class="hint">
      <svg width="13" height="13" viewBox="0 0 24 24" fill="none" stroke="#8b93a7" stroke-width="2">
        <circle cx="12" cy="12" r="9"/><path d="M12 8v4l3 2"/>
      </svg>
      Physical button on GPIO 15 also triggers capture
    </div>
  </div>

  <div class="card gps-card" id="gpsBox">
    <div class="gps-head">
      <h2>Capture details</h2>
      <span class="badge" id="fixBadge"></span>
    </div>
    <div class="stat-grid" id="statGrid"></div>
    <a class="maps-btn" id="mapsLink" target="_blank" style="display:none;">
      <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2">
        <path d="M12 21s-7-6.2-7-11a7 7 0 0 1 14 0c0 4.8-7 11-7 11z"/><circle cx="12" cy="10" r="2.5"/>
      </svg>
      Open in Google Maps
    </a>
    <div class="log-line" id="logLine"></div>
  </div>
</div>

<script>
  const streamImg   = document.getElementById('stream');
  const overlay     = document.getElementById('streamOverlay');
  const liveDot     = document.getElementById('liveDot');
  const liveText    = document.getElementById('liveText');
  const wifiDot     = document.getElementById('wifiDot');
  const ipEl        = document.getElementById('ip');
  const captureBtn  = document.getElementById('captureBtn');
  const camIcon     = document.getElementById('camIcon');
  const btnLabel    = document.getElementById('btnLabel');
  const ts          = document.getElementById('ts');
  const gpsBox      = document.getElementById('gpsBox');
  const fixBadge    = document.getElementById('fixBadge');
  const statGrid    = document.getElementById('statGrid');
  const mapsLink    = document.getElementById('mapsLink');
  const logLine     = document.getElementById('logLine');

  function streamUrl(){
    return 'http://' + location.hostname + ':81/stream?ts=' + Date.now();
  }
  function startStream(){
    overlay.style.opacity = '1';
    streamImg.src = streamUrl();
  }
  streamImg.addEventListener('load', () => {
    overlay.style.opacity = '0';
    liveDot.classList.add('on');
    liveText.textContent = 'LIVE';
    wifiDot.classList.add('on');
  });
  streamImg.addEventListener('error', () => {
    liveDot.classList.remove('on');
    liveText.textContent = 'OFFLINE';
    overlay.innerHTML = '<div class="spinner"></div><div>Stream dropped — reconnecting…</div>';
    overlay.style.opacity = '1';
    setTimeout(startStream, 1500);
  });
  startStream();

  fetch('/ip').then(r => r.text()).then(t => { ipEl.textContent = t; wifiDot.classList.add('on'); })
              .catch(() => { ipEl.textContent = 'offline'; });

  const spinnerSVG = '<div class="btn-spinner"></div>';

  function statTile(label, value, wide){
    return '<div class="stat' + (wide ? ' wide' : '') + '"><div class="label">' + label +
           '</div><div class="value">' + value + '</div></div>';
  }

  async function captureImage(){
    captureBtn.disabled = true;
    btnLabel.textContent = 'Capturing…';
    document.getElementById('camIcon').style.display = 'none';
    captureBtn.insertAdjacentHTML('afterbegin', spinnerSVG);
    ts.textContent = 'Taking photo and reading GPS…';
    gpsBox.classList.remove('show');

    try{
      const resp = await fetch('/capture?t=' + Date.now());
      if(!resp.ok) throw new Error('Capture failed (' + resp.status + ')');
      ts.textContent = 'Captured at ' + new Date().toLocaleTimeString() + ' — logging…';

      let data = null;
      for(let i = 0; i < 40; i++){
        const g = await fetch('/capture-info?t=' + Date.now());
        data = await g.json();
        if(data.status.indexOf('IMAGE SAVED') >= 0 || data.status.indexOf('FAILED') >= 0) break;
        await new Promise(r => setTimeout(r, 500));
      }

      statGrid.innerHTML = '';
      if(data.valid){
        fixBadge.className = 'badge good';
        fixBadge.textContent = 'GPS FIX';
        statGrid.innerHTML =
          statTile('Latitude', data.lat) +
          statTile('Longitude', data.lng) +
          statTile('Altitude', data.alt + ' m') +
          statTile('Satellites', data.sat) +
          statTile('HDOP', data.hdop, true);
        mapsLink.href = 'https://www.google.com/maps?q=' + data.lat + ',' + data.lng;
        mapsLink.style.display = 'flex';
        ts.textContent = 'Capture complete.';
      } else {
        fixBadge.className = 'badge bad';
        fixBadge.textContent = 'NO FIX';
        statGrid.innerHTML = statTile('Satellites visible', data.sat, true);
        mapsLink.style.display = 'none';
        ts.textContent = 'Captured — no GPS fix at the time.';
      }
      logLine.innerHTML = 'Cloud storage: <b>' + data.status + '</b>' +
          (data.driveUrl ? ' — <a href="' + data.driveUrl + '" target="_blank" style="color:inherit">Open Drive image</a>' : '');
      gpsBox.classList.add('show');
    }catch(err){
      ts.textContent = 'Error: ' + err.message;
      fixBadge.className = 'badge bad';
      fixBadge.textContent = 'ERROR';
      statGrid.innerHTML = '';
      mapsLink.style.display = 'none';
      logLine.textContent = '';
      gpsBox.classList.add('show');
    }finally{
      captureBtn.disabled = false;
      btnLabel.textContent = 'Capture Image';
      const sp = captureBtn.querySelector('.btn-spinner');
      if(sp) sp.remove();
      document.getElementById('camIcon').style.display = '';
    }
  }
</script>
</body>
</html>
)HTML";

// ======================= HTTPD HANDLERS (port 80) ===============
static esp_err_t root_handler(httpd_req_t *req) {
  httpd_resp_set_type(req, "text/html");
  return httpd_resp_send(req, INDEX_HTML, strlen(INDEX_HTML));
}

static esp_err_t favicon_handler(httpd_req_t *req) {
  httpd_resp_set_status(req, "204 No Content");
  return httpd_resp_send(req, NULL, 0);
}

static esp_err_t ip_handler(httpd_req_t *req) {
  String ip = WiFi.localIP().toString();
  httpd_resp_set_type(req, "text/plain");
  return httpd_resp_send(req, ip.c_str(), ip.length());
}

static esp_err_t capture_handler(httpd_req_t *req) {
  bool ok = performCapture();

  xSemaphoreTake(captureMutex, portMAX_DELAY);
  bool haveBuf = ok && lastJpegBuf && lastJpegLen > 0;
  esp_err_t res;
  if (!haveBuf) {
    xSemaphoreGive(captureMutex);
    httpd_resp_send_err(req, HTTPD_500_INTERNAL_SERVER_ERROR, "Capture failed");
    return ESP_FAIL;
  }
  httpd_resp_set_type(req, "image/jpeg");
  httpd_resp_set_hdr(req, "Content-Disposition", "inline; filename=capture.jpg");
  httpd_resp_set_hdr(req, "Cache-Control", "no-store");
  res = httpd_resp_send(req, (const char*)lastJpegBuf, lastJpegLen);
  xSemaphoreGive(captureMutex);
  return res;
}

static esp_err_t capture_jpg_handler(httpd_req_t *req) {
  xSemaphoreTake(captureMutex, portMAX_DELAY);
  if (!lastJpegBuf || lastJpegLen == 0) {
    xSemaphoreGive(captureMutex);
    httpd_resp_send_err(req, HTTPD_404_NOT_FOUND, "No capture yet");
    return ESP_FAIL;
  }
  httpd_resp_set_type(req, "image/jpeg");
  httpd_resp_set_hdr(req, "Cache-Control", "no-store");
  esp_err_t res = httpd_resp_send(req, (const char*)lastJpegBuf, lastJpegLen);
  xSemaphoreGive(captureMutex);
  return res;
}

static esp_err_t capture_info_handler(httpd_req_t *req) {
  xSemaphoreTake(captureMutex, portMAX_DELAY);
  String json = "{";
  json += "\"valid\":"  + String(lastCaptureValid ? "true" : "false") + ",";
  json += "\"lat\":"    + String((double)lastCaptureLat, 6) + ",";
  json += "\"lng\":"    + String((double)lastCaptureLng, 6) + ",";
  json += "\"alt\":"    + String((double)lastCaptureAlt, 2) + ",";
  json += "\"sat\":"    + String((uint32_t)lastCaptureSat) + ",";
  json += "\"hdop\":"   + String((double)lastCaptureHdop, 2) + ",";
  json += "\"status\":\"" + lastCaptureStatus + "\",";
  json += "\"driveUrl\":\"" + lastDriveUrl + "\"";
  json += "}";
  xSemaphoreGive(captureMutex);

  httpd_resp_set_type(req, "application/json");
  return httpd_resp_send(req, json.c_str(), json.length());
}

static esp_err_t gps_handler(httpd_req_t *req) {
  String json = "{";
  if (gps.location.isValid()) {
    json += "\"valid\":true,";
    json += "\"lat\":" + String(gps.location.lat(), 6) + ",";
    json += "\"lng\":" + String(gps.location.lng(), 6) + ",";
    json += "\"alt\":" + String(gps.altitude.isValid() ? gps.altitude.meters() : 0, 2) + ",";
    json += "\"sat\":" + String(gps.satellites.value()) + ",";
    json += "\"hdop\":" + String(gps.hdop.isValid() ? gps.hdop.hdop() : 0, 2);
  } else {
    json += "\"valid\":false,\"lat\":0,\"lng\":0,\"alt\":0,";
    json += "\"sat\":" + String(gps.satellites.value()) + ",\"hdop\":0";
  }
  json += "}";
  httpd_resp_set_type(req, "application/json");
  return httpd_resp_send(req, json.c_str(), json.length());
}

// ======================= HTTPD STREAM HANDLER (port 81) =========
static esp_err_t stream_handler(httpd_req_t *req) {
  camera_fb_t *fb = NULL;
  esp_err_t res = ESP_OK;
  char part_buf[64];

  res = httpd_resp_set_type(req, STREAM_CONTENT_TYPE);
  if (res != ESP_OK) return res;
  httpd_resp_set_hdr(req, "Cache-Control", "no-store");

  while (true) {
    if (xSemaphoreTake(cameraMutex, pdMS_TO_TICKS(3000)) != pdTRUE) {
      res = ESP_FAIL;
      break;
    }
    fb = esp_camera_fb_get();
    xSemaphoreGive(cameraMutex);
    if (!fb) {
      Serial.println("Stream: camera_fb_get failed");
      res = ESP_FAIL;
    } else if (fb->format != PIXFORMAT_JPEG) {
      esp_camera_fb_return(fb);
      fb = NULL;
      res = ESP_FAIL;
    }

    if (res == ESP_OK) {
      size_t hlen = snprintf(part_buf, sizeof(part_buf), STREAM_PART, fb->len);
      res = httpd_resp_send_chunk(req, part_buf, hlen);
    }
    if (res == ESP_OK) {
      res = httpd_resp_send_chunk(req, (const char*)fb->buf, fb->len);
    }
    if (res == ESP_OK) {
      res = httpd_resp_send_chunk(req, STREAM_BOUNDARY, strlen(STREAM_BOUNDARY));
    }
    if (fb) {
      esp_camera_fb_return(fb);
      fb = NULL;
    }
    if (res != ESP_OK) break;
  }
  return res;
}

// ======================= SERVER STARTUP ==========================
void startCameraServer() {
  httpd_config_t config = HTTPD_DEFAULT_CONFIG();
  config.server_port      = 80;
  config.ctrl_port        = 80;
  config.max_uri_handlers = 8;
  config.stack_size       = 8192;
  config.lru_purge_enable = true;

  httpd_uri_t root_uri    = { "/",             HTTP_GET, root_handler,         NULL };
  httpd_uri_t favicon_uri = { "/favicon.ico",  HTTP_GET, favicon_handler,      NULL };
  httpd_uri_t ip_uri      = { "/ip",           HTTP_GET, ip_handler,           NULL };
  httpd_uri_t capture_uri = { "/capture",      HTTP_GET, capture_handler,      NULL };
  httpd_uri_t capjpg_uri  = { "/capture.jpg",  HTTP_GET, capture_jpg_handler,  NULL };
  httpd_uri_t capinfo_uri = { "/capture-info", HTTP_GET, capture_info_handler, NULL };
  httpd_uri_t gps_uri     = { "/gps",          HTTP_GET, gps_handler,          NULL };

  if (httpd_start(&camera_httpd, &config) == ESP_OK) {
    httpd_register_uri_handler(camera_httpd, &root_uri);
    httpd_register_uri_handler(camera_httpd, &favicon_uri);
    httpd_register_uri_handler(camera_httpd, &ip_uri);
    httpd_register_uri_handler(camera_httpd, &capture_uri);
    httpd_register_uri_handler(camera_httpd, &capjpg_uri);
    httpd_register_uri_handler(camera_httpd, &capinfo_uri);
    httpd_register_uri_handler(camera_httpd, &gps_uri);
    Serial.println("Control server started on port 80");
  } else {
    Serial.println("FAILED to start control server");
  }

  config.server_port      = 81;
  config.ctrl_port        = 81;
  config.max_uri_handlers = 2;
  config.stack_size       = 8192;

  httpd_uri_t stream_uri = { "/stream", HTTP_GET, stream_handler, NULL };

  if (httpd_start(&stream_httpd, &config) == ESP_OK) {
    httpd_register_uri_handler(stream_httpd, &stream_uri);
    Serial.println("Stream server started on port 81");
  } else {
    Serial.println("FAILED to start stream server");
  }
}

// ======================= BUTTON =================================
void updateButton() {
  static bool lastState = HIGH;
  static unsigned long lastDebounce = 0;
  bool state = digitalRead(CAPTURE_BUTTON_PIN);

  if (state != lastState && (millis() - lastDebounce) > 50) {
    lastDebounce = millis();
    if (state == LOW) {
      Serial.println(">>> Physical button pressed");
      capturePending = true;
    }
    lastState = state;
  }
}

// ======================= GPS ====================================
void updateGPS() {
  while (GPS_Serial.available()) {
    gps.encode(GPS_Serial.read());
  }
  updateGPSLED();

  static unsigned long lastPrint = 0;
  if (millis() - lastPrint >= 2000) {
    lastPrint = millis();
    Serial.println();
    Serial.println("========== GPS DATA ==========");
    if (gps.location.isValid()) {
      Serial.println("GPS STATUS: FIXED");
      Serial.print("Lat: "); Serial.println(gps.location.lat(), 6);
      Serial.print("Lng: "); Serial.println(gps.location.lng(), 6);
      if (gps.altitude.isValid()) {
        Serial.print("Alt: "); Serial.print(gps.altitude.meters(), 2);
        Serial.println(" m");
      }
      Serial.print("Sat: ");  Serial.println(gps.satellites.value());
      if (gps.hdop.isValid()) {
        Serial.print("HDOP: "); Serial.println(gps.hdop.hdop(), 2);
      }
    } else {
      Serial.println("GPS STATUS: NO FIX");
      Serial.print("Sat: ");   Serial.println(gps.satellites.value());
      Serial.print("Chars: "); Serial.println(gps.charsProcessed());
    }
    Serial.println("==============================");
  }
}

// ======================= WIFI MONITOR ===========================
void updateWiFiMonitor() {
  static unsigned long lastCheck = 0;
  if (millis() - lastCheck < 3000) return;
  lastCheck = millis();

  Serial.print("[WiFi] status=");
  Serial.print(WiFi.status());
  Serial.print(" (3=connected)  RSSI=");
  Serial.print(WiFi.RSSI());
  Serial.print(" dBm  IP=");
  Serial.print(WiFi.localIP());
  Serial.print("  Heap=");
  Serial.println(ESP.getFreeHeap());
}

// ======================= 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;

  if (psramFound()) {
    config.frame_size   = FRAMESIZE_VGA;   // 640x480
    config.jpeg_quality = 15;              // tuned for weaker WiFi signal
    config.fb_count     = 2;
    config.fb_location  = CAMERA_FB_IN_PSRAM;
    config.grab_mode    = CAMERA_GRAB_LATEST;
  } else {
    config.frame_size   = FRAMESIZE_QVGA;  // 320x240 fallback
    config.jpeg_quality = 15;
    config.fb_count     = 1;
    config.grab_mode    = CAMERA_GRAB_WHEN_EMPTY;
  }

  esp_err_t err = esp_camera_init(&config);
  if (err != ESP_OK) {
    Serial.printf("Camera init FAILED 0x%x\n", err);
    Serial.println("-> Check ribbon cable (contacts facing the board).");
    Serial.println("-> Check 5V/2A power supply.");
    while (true) delay(1000);
  }

  // ================== ROTATION FIX ==================
  // The OV2640 sensor on the AI-Thinker board is mounted 180° rotated.
  // These two calls flip the image back so live stream and captures
  // both appear right-side-up.
  //
  // If after this the image is mirrored (text is backwards):
  //     change set_hmirror(s, 1) to set_hmirror(s, 0)
  // If it's upside-down instead of mirrored:
  //     change set_vflip(s, 1) to set_vflip(s, 0)
  sensor_t *s = esp_camera_sensor_get();
  if (s) {
    s->set_vflip(s, 1);     // <<< ROTATION FIX  (1 = flip vertically)
    s->set_hmirror(s, 1);   // <<< ROTATION FIX  (1 = mirror horizontally)
    Serial.println("Camera rotation applied (vflip=1, hmirror=1)");
  }
  // ==================================================

  Serial.println("Camera OK.");
  Serial.print("PSRAM: "); Serial.println(psramFound() ? "yes" : "no");
}

// ======================= SETUP ==================================
void setup() {
  WRITE_PERI_REG(RTC_CNTL_BROWN_OUT_REG, 0);

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

  Serial.println("\n==============================");
  Serial.println("  ESP32-CAM + NEO-6M + Button");
  Serial.println("==============================");
  Serial.print("Reset reason: ");
  Serial.println(esp_reset_reason());

  pinMode(STATUS_LED_PIN, OUTPUT);
  digitalWrite(STATUS_LED_PIN, LOW);

  pinMode(CAPTURE_BUTTON_PIN, INPUT_PULLUP);

  captureMutex = xSemaphoreCreateMutex();
  cameraMutex = xSemaphoreCreateMutex();
  if (!captureMutex || !cameraMutex) {
    Serial.println("ERROR: mutex creation failed.");
    while (true) delay(1000);
  }

  Serial.println("Initializing GPS...");
  GPS_Serial.begin(GPS_BAUD, SERIAL_8N1, GPS_RX_PIN, GPS_TX_PIN);

  Serial.println("Initializing camera...");
  initCamera();

  Serial.println("Connecting to WiFi...");
  WiFi.mode(WIFI_STA);
  WiFi.setSleep(false);

#ifdef USE_STATIC_IP
  if (!WiFi.config(local_IP, gateway, subnet, dns1, dns2)) {
    Serial.println("Static IP config failed, using DHCP");
  } else {
    Serial.println("Static IP configured");
  }
#endif

  WiFi.begin(WIFI_SSID, WIFI_PASSWORD);

  unsigned long start = millis();
  while (WiFi.status() != WL_CONNECTED && millis() - start < 20000) {
    delay(500); Serial.print(".");
  }
  Serial.println();

  if (WiFi.status() == WL_CONNECTED) {
    Serial.println("WiFi OK.");
    Serial.print("IP: http://"); Serial.println(WiFi.localIP());
    Serial.print("RSSI: "); Serial.print(WiFi.RSSI()); Serial.println(" dBm");
  } else {
    Serial.print("WiFi FAILED. status="); Serial.println(WiFi.status());
    Serial.println("Check SSID/password and 2.4 GHz band.");
  }

  startCameraServer();

  xTaskCreatePinnedToCore(loggerTask, "logger", 8192, NULL, 1, NULL, 0);

  Serial.println("\nWeb server started.");
  Serial.println("Control (port 80): /  /ip  /capture  /capture.jpg  /capture-info  /gps");
  Serial.println("Cloud: JPEG -> Google Drive, GPS -> Google Sheets");
  Serial.println("Stream  (port 81): /stream");
  Serial.println("Physical button on GPIO 15 triggers capture.");
}

// ======================= LOOP ===================================
void loop() {
  updateGPS();
  updateWiFiMonitor();
  updateButton();

  if (capturePending) {
    capturePending = false;
    performCapture();
  }

  vTaskDelay(2 / portTICK_PERIOD_MS);
}

// ============================================================
// ESP32-CAM GPS Logger
// GPS -> Google Sheets
// JPEG -> Google Drive
// ============================================================

const SHEET_ID   = "1EasvNeuC2uy-InbZufUampbmpZxqEvGkaS6kdpFzvAE";
const SHEET_NAME = "Logs";
const FOLDER_ID  = "1tJjZqpGCm1a90CzRmoC6EY3jQlyH8W7z";


// ============================================================
// GET
// GPS-only logging / testing
// ============================================================

function doGet(e) {
  const p = (e && e.parameter) ? e.parameter : {};

  return handleRequest(p, null);
}


// ============================================================
// POST
// ESP32 sends:
//
// {
//   "action": "upload",
//   "valid": true,
//   "latitude": 7.123456,
//   "longitude": 125.123456,
//   "altitude": 41.50,
//   "satellites": 6,
//   "hdop": 1.20,
//   "status": "GPS FIX",
//   "image": "BASE64 JPEG"
// }
//
// ============================================================

function doPost(e) {

  try {

    if (!e || !e.postData || !e.postData.contents) {
      return jsonResponse({ success: false, error: "Empty POST body" });
    }

    let params = {};
    let imageData = "";

    const body = e.postData.contents;
    const contentType = String(e.postData.type || "").toLowerCase();

    // --------------------------------------------------------
    // JSON POST
    // --------------------------------------------------------

    if (contentType.indexOf("application/json") !== -1) {

      let json;

      try {
        json = JSON.parse(body);
      } catch (err) {
        return jsonResponse({ success: false, error: "Invalid JSON: " + err.message });
      }

      params = json || {};

      if (json.image) {
        imageData = String(json.image);
      }

    }

    // --------------------------------------------------------
    // FORM / RAW POST fallback
    // --------------------------------------------------------

    else {

      params = (e.parameter) ? e.parameter : {};

      imageData = body;

      // If body itself is JSON even though the content type
      // wasn't correctly reported, try parsing it.
      if (body.trim().charAt(0) === "{") {

        try {

          const json = JSON.parse(body);

          params = json || {};

          if (json.image) {
            imageData = String(json.image);
          }

        } catch (err) {
          // Keep raw body as image data.
        }
      }
    }


    // --------------------------------------------------------
    // Decode URL encoding if necessary
    // --------------------------------------------------------

    if (imageData) {

      try {
        imageData = decodeURIComponent(imageData);
      } catch (err) {
        // Already decoded; continue.
      }
    }


    // --------------------------------------------------------
    // Process request
    // --------------------------------------------------------

    return handleRequest(params, imageData);

  } catch (err) {

    return jsonResponse({ success: false, error: "doPost failed: " + err.message });
  }
}


// ============================================================
// SHARED REQUEST HANDLER
// ============================================================

function handleRequest(p, imageData) {

  try {

    // --------------------------------------------------------
    // Open spreadsheet
    // --------------------------------------------------------

    const ss = SpreadsheetApp.openById(SHEET_ID);

    let sheet = ss.getSheetByName(SHEET_NAME);

    if (!sheet) {
      sheet = ss.insertSheet(SHEET_NAME);
    }


    // --------------------------------------------------------
    // Create header if sheet is empty
    // --------------------------------------------------------

    if (sheet.getLastRow() === 0) {

      sheet.appendRow([
        "Timestamp",
        "Latitude",
        "Longitude",
        "Altitude (m)",
        "Satellites",
        "HDOP",
        "Status",
        "Image",
        "Map Link"
      ]);
    }


    // --------------------------------------------------------
    // Read GPS data
    // --------------------------------------------------------

    const valid =
      p.valid === true ||
      String(p.valid).toLowerCase() === "true";

    const latitude =
      valid && isFinite(Number(p.latitude))
        ? Number(p.latitude)
        : "";

    const longitude =
      valid && isFinite(Number(p.longitude))
        ? Number(p.longitude)
        : "";

    const altitude =
      isFinite(Number(p.altitude))
        ? Number(p.altitude)
        : "";

    const satellites =
      isFinite(Number(p.satellites))
        ? Number(p.satellites)
        : "";

    const hdop =
      isFinite(Number(p.hdop))
        ? Number(p.hdop)
        : "";

    const status =
      p.status
        ? String(p.status)
        : (valid ? "GPS FIX" : "NO GPS FIX");

    // Only build a map link when we actually have a fix,
    // otherwise lat/lng are blank and the link would point at 0,0.
    const mapUrl =
      (valid && latitude !== "" && longitude !== "")
        ? "https://www.google.com/maps?q=" + latitude + "," + longitude
        : "";


    // --------------------------------------------------------
    // Save JPEG to Google Drive
    // --------------------------------------------------------

    let imageUrl = "";

    if (imageData && imageData.length > 100) {

      try {

        imageUrl = saveImageToDrive(
          imageData,
          status
        );

      } catch (err) {

        // Keep logging GPS even if Drive fails.
        imageUrl =
          "IMG ERROR: " + err.message;
      }
    }


    // --------------------------------------------------------
    // Write row to Google Sheets
    // --------------------------------------------------------

    const rowIndex = sheet.getLastRow() + 1;

    sheet.appendRow([
      new Date(),
      latitude,
      longitude,
      altitude,
      satellites,
      hdop,
      status,
      imageUrl,
      "" // placeholder; Map Link column filled in below as a clickable formula
    ]);

    // Write the Map Link as a real HYPERLINK formula so it's clickable,
    // rather than a plain-text URL string.
    if (mapUrl) {
      sheet.getRange(rowIndex, 9).setFormula(
        '=HYPERLINK("' + mapUrl + '","View on Map")'
      );
    }


    // --------------------------------------------------------
    // Return result to ESP32 (JSON, matching what the sketch parses)
    // --------------------------------------------------------

    if (imageUrl && imageUrl.indexOf("IMG ERROR:") === 0) {

      return jsonResponse({
        success: false,
        error: imageUrl,
        mapUrl: mapUrl
      });
    }

    return jsonResponse({
      success: true,
      fileUrl: imageUrl || "",
      mapUrl: mapUrl
    });

  } catch (err) {

    return jsonResponse({ success: false, error: err.message });
  }
}


// ============================================================
// SAVE IMAGE TO GOOGLE DRIVE
// ============================================================

function saveImageToDrive(base64String, status) {

  let b64 = String(base64String);


  // ----------------------------------------------------------
  // Remove data URI prefix if present
  // Example:
  // data:image/jpeg;base64,/9j/4AAQ...
  // ----------------------------------------------------------

  const commaIndex = b64.indexOf(",");

  if (
    b64.indexOf("base64") !== -1 &&
    commaIndex !== -1
  ) {
    b64 = b64.substring(commaIndex + 1);
  }


  // Remove whitespace
  b64 = b64.replace(/\s/g, "");


  if (!b64 || b64.length < 100) {
    throw new Error("Invalid or empty Base64 image");
  }


  // ----------------------------------------------------------
  // Get Drive folder
  // ----------------------------------------------------------

  const folder = DriveApp.getFolderById(FOLDER_ID);


  // ----------------------------------------------------------
  // Filename
  // ----------------------------------------------------------

  const timestamp = Utilities.formatDate(
    new Date(),
    Session.getScriptTimeZone(),
    "yyyyMMdd_HHmmss"
  );

  const safeStatus =
    String(status || "capture")
      .replace(/[^a-zA-Z0-9_-]/g, "_");

  const filename =
    "ESP32CAM_" +
    timestamp +
    "_" +
    safeStatus +
    ".jpg";


  // ----------------------------------------------------------
  // Decode Base64
  // ----------------------------------------------------------

  let bytes;

  try {

    bytes = Utilities.base64Decode(b64);

  } catch (err) {

    throw new Error(
      "Base64 decode failed: " + err.message
    );
  }


  // ----------------------------------------------------------
  // Create JPEG blob
  // ----------------------------------------------------------

  const blob = Utilities.newBlob(
    bytes,
    "image/jpeg",
    filename
  );


  // ----------------------------------------------------------
  // Save to folder
  // ----------------------------------------------------------

  const file = folder.createFile(blob);


  // ----------------------------------------------------------
  // Try to make it accessible by link
  //
  // Some Google Workspace accounts prohibit this.
  // Do NOT let that prevent the image from being saved.
  // ----------------------------------------------------------

  try {

    file.setSharing(
      DriveApp.Access.ANYONE_WITH_LINK,
      DriveApp.Permission.VIEW
    );

  } catch (sharingError) {

    console.log(
      "Warning: Could not enable anyone-with-link sharing: " +
      sharingError.message
    );
  }


  // ----------------------------------------------------------
  // Return Drive URL
  // ----------------------------------------------------------

  return file.getUrl();
}


// ============================================================
// JSON RESPONSE HELPER
// ============================================================

function jsonResponse(obj) {

  return ContentService
    .createTextOutput(JSON.stringify(obj))
    .setMimeType(ContentService.MimeType.JSON);
}


// ============================================================
// TEST 1
// GPS ONLY
// ============================================================

function testLogger() {

  const fake = {

    parameter: {

      latitude: "7.070644",
      longitude: "125.611370",
      altitude: "41.50",
      satellites: "6",
      hdop: "2.54",
      valid: "true",
      status: "GPS FIX"

    }

  };

  const result = doGet(fake);

  Logger.log(result.getContent());
}


// ============================================================
// TEST 2
// IMAGE UPLOAD
// ============================================================

function testImageUpload() {

  const tinyJpeg =
    "/9j/4AAQSkZJRgABAQEAYABgAAD/2wBDAAgGBgcGBQgHBwcJCQgKDBQNDAsLDBkS" +
    "Ew8UHRofHh0aHBwgJC4nICIsIxwcKDcpLDAxNDQ0Hyc5PTgyPC4zNDL/wAALCAAB" +
    "AAEBAREA/8QAFAABAAAAAAAAAAAAAAAAAAAACf/EABQQAQAAAAAAAAAAAAAAAAAA" +
    "AAD/2gAIAQEAAD8AKp//2Q==";


  const fake = {

    parameter: {

      latitude: "7.070644",
      longitude: "125.611370",
      altitude: "41.50",
      satellites: "6",
      hdop: "2.54",
      valid: "true",
      status: "TEST"

    },

    postData: {

      contents: JSON.stringify({

        action: "upload",
        valid: true,
        latitude: 7.070644,
        longitude: 125.611370,
        altitude: 41.50,
        satellites: 6,
        hdop: 2.54,
        status: "TEST",
        image: tinyJpeg

      }),

      type: "application/json"

    }

  };


  const result = doPost(fake);

  Logger.log(result.getContent());
}


// ============================================================
// TEST 3
// VERIFY DRIVE FOLDER
// ============================================================

function testFolderAccess() {

  const folder =
    DriveApp.getFolderById(FOLDER_ID);

  Logger.log(
    "Folder OK: " + folder.getName()
  );

  Logger.log(
    "Folder URL: " + folder.getUrl()
  );
}


// ============================================================
// TEST 4
// VERIFY SHEET
// ============================================================

function testSheetAccess() {

  const ss =
    SpreadsheetApp.openById(SHEET_ID);

  Logger.log(
    "Spreadsheet OK: " + ss.getName()
  );

  const sheet =
    ss.getSheetByName(SHEET_NAME);

  if (sheet) {

    Logger.log(
      "Sheet OK: " + SHEET_NAME
    );

  } else {

    Logger.log(
      "Sheet does not exist yet."
    );
  }
}

========== GOOGLE UPLOAD ==========
JPEG bytes: 21384
Base64 bytes: 28512
POST bytes: 28890
[UPLOAD] Sending POST to Google Apps Script...
[UPLOAD] Redirected (302) to: https://script.googleusercontent.com/...
[UPLOAD] HTTP code: 200
[UPLOAD] Response: {"success":true,"fileUrl":"https://drive.google.com/...","mapUrl":"https://www.google.com/maps?q=..."}
[UPLOAD] SUCCESS: Drive + Sheets
===================================