1 files changed, 235 insertions, 0 deletions

diff --git a/main/mint_health.c b/main/mint_health.c
new file mode 100644
index 0000000..5853a39
--- /dev/null
+++ b/main/mint_health.c
@@ -0,0 +1,235 @@
+#include "mint_health.h"
+#include "esp_log.h"
+#include "esp_http_client.h"
+#include "esp_crt_bundle.h"
+#include "freertos/FreeRTOS.h"
+#include "freertos/task.h"
+#include "freertos/semphr.h"
+#include <string.h>
+#include <stdlib.h>
+
+static const char *TAG = "mint_health";
+
+static mint_status_t s_mints[MINT_HEALTH_MAX];
+static int s_mint_count = 0;
+static bool s_running = false;
+static TaskHandle_t s_task_handle = NULL;
+static SemaphoreHandle_t s_mutex = NULL;
+
+#define MAX_CALLBACKS 4
+static mint_health_changed_cb s_callbacks[MAX_CALLBACKS];
+static int s_callback_count = 0;
+
+static void fire_callbacks(void)
+{
+    for (int i = 0; i < s_callback_count; i++) {
+        if (s_callbacks[i]) s_callbacks[i]();
+    }
+}
+
+esp_err_t mint_health_init(const char urls[][256], int count)
+{
+    if (count > MINT_HEALTH_MAX) count = MINT_HEALTH_MAX;
+    s_mint_count = count;
+    s_callback_count = 0;
+
+    if (!s_mutex) s_mutex = xSemaphoreCreateMutex();
+
+    memset(s_mints, 0, sizeof(s_mints));
+    for (int i = 0; i < count; i++) {
+        strncpy(s_mints[i].url, urls[i], sizeof(s_mints[i].url) - 1);
+        s_mints[i].reachable = false;
+        s_mints[i].consecutive_successes = 0;
+        s_mints[i].last_probe_ms = 0;
+        s_mints[i].last_http_status = 0;
+    }
+
+    ESP_LOGI(TAG, "Initialized with %d mints", count);
+    return ESP_OK;
+}
+
+static bool probe_mint(const char *url)
+{
+    char probe_url[512];
+    snprintf(probe_url, sizeof(probe_url), "%s/v1/info", url);
+
+    esp_http_client_config_t config = {
+        .url = probe_url,
+        .method = HTTP_METHOD_GET,
+        .timeout_ms = MINT_HEALTH_PROBE_TIMEOUT_MS,
+        .crt_bundle_attach = esp_crt_bundle_attach,
+    };
+    esp_http_client_handle_t client = esp_http_client_init(&config);
+    if (!client) return false;
+
+    esp_err_t err = esp_http_client_open(client, 0);
+    if (err != ESP_OK) {
+        esp_http_client_cleanup(client);
+        return false;
+    }
+
+    int content_length = esp_http_client_fetch_headers(client);
+    int status = esp_http_client_get_status_code(client);
+
+    char *resp = NULL;
+    if (content_length > 0 && content_length < 8192) {
+        resp = malloc(content_length + 1);
+        if (resp) {
+            int read = esp_http_client_read(client, resp, content_length);
+            if (read > 0) resp[read] = '\0';
+        }
+    }
+    if (resp) free(resp);
+
+    esp_http_client_cleanup(client);
+    return (status >= 200 && status < 300);
+}
+
+static void run_probes(void)
+{
+    int old_reachable = 0;
+    int new_reachable = 0;
+
+    if (xSemaphoreTake(s_mutex, pdMS_TO_TICKS(5000)) != pdTRUE) return;
+
+    for (int i = 0; i < s_mint_count; i++) {
+        if (s_mints[i].reachable) old_reachable++;
+    }
+
+    for (int i = 0; i < s_mint_count; i++) {
+        bool ok = probe_mint(s_mints[i].url);
+        s_mints[i].last_probe_ms = (int64_t)xTaskGetTickCount() * portTICK_PERIOD_MS;
+        s_mints[i].last_http_status = ok ? 200 : 0;
+
+        if (ok) {
+            s_mints[i].consecutive_successes++;
+            if (s_mints[i].consecutive_successes >= MINT_HEALTH_RECOVERY_THRESHOLD) {
+                if (!s_mints[i].reachable) {
+                    ESP_LOGI(TAG, "Mint RECOVERED: %s", s_mints[i].url);
+                }
+                s_mints[i].reachable = true;
+            }
+        } else {
+            if (s_mints[i].reachable) {
+                ESP_LOGW(TAG, "Mint UNREACHABLE: %s", s_mints[i].url);
+            }
+            s_mints[i].reachable = false;
+            s_mints[i].consecutive_successes = 0;
+        }
+
+        if (s_mints[i].reachable) new_reachable++;
+    }
+
+    bool changed = (old_reachable != new_reachable);
+    xSemaphoreGive(s_mutex);
+
+    if (changed) {
+        ESP_LOGI(TAG, "Reachable set changed: %d -> %d", old_reachable, new_reachable);
+        fire_callbacks();
+    }
+}
+
+static void run_initial_probes(void)
+{
+    if (xSemaphoreTake(s_mutex, pdMS_TO_TICKS(5000)) != pdTRUE) return;
+
+    for (int i = 0; i < s_mint_count; i++) {
+        bool ok = probe_mint(s_mints[i].url);
+        s_mints[i].last_probe_ms = (int64_t)xTaskGetTickCount() * portTICK_PERIOD_MS;
+        s_mints[i].last_http_status = ok ? 200 : 0;
+
+        if (ok) {
+            s_mints[i].consecutive_successes = MINT_HEALTH_RECOVERY_THRESHOLD;
+            s_mints[i].reachable = true;
+            ESP_LOGI(TAG, "Initial probe OK: %s (reachable)", s_mints[i].url);
+        } else {
+            s_mints[i].consecutive_successes = 0;
+            s_mints[i].reachable = false;
+            ESP_LOGW(TAG, "Initial probe FAIL: %s (unreachable)", s_mints[i].url);
+        }
+    }
+
+    xSemaphoreGive(s_mutex);
+    fire_callbacks();
+}
+
+static void health_task(void *pvParameters)
+{
+    ESP_LOGI(TAG, "Health probe task started, waiting for DNS to stabilize...");
+    vTaskDelay(pdMS_TO_TICKS(5000));
+    run_initial_probes();
+
+    while (s_running) {
+        vTaskDelay(pdMS_TO_TICKS(MINT_HEALTH_PROBE_INTERVAL_S * 1000));
+        if (!s_running) break;
+        run_probes();
+    }
+
+    s_task_handle = NULL;
+    vTaskDelete(NULL);
+}
+
+void mint_health_start(void)
+{
+    if (s_running) return;
+    s_running = true;
+    xTaskCreate(health_task, "mint_health", 16384, NULL, 3, &s_task_handle);
+}
+
+void mint_health_stop(void)
+{
+    s_running = false;
+    if (s_task_handle) {
+        vTaskDelay(pdMS_TO_TICKS(100));
+    }
+}
+
+const mint_status_t *mint_health_get_all(int *out_count)
+{
+    if (xSemaphoreTake(s_mutex, pdMS_TO_TICKS(1000)) != pdTRUE) {
+        *out_count = 0;
+        return s_mints;
+    }
+    *out_count = s_mint_count;
+    xSemaphoreGive(s_mutex);
+    return s_mints;
+}
+
+bool mint_health_is_reachable(const char *url)
+{
+    if (!url) return false;
+    if (xSemaphoreTake(s_mutex, pdMS_TO_TICKS(1000)) != pdTRUE) return false;
+    bool result = false;
+    for (int i = 0; i < s_mint_count; i++) {
+        if (strcmp(s_mints[i].url, url) == 0 || strstr(url, s_mints[i].url) != NULL) {
+            result = s_mints[i].reachable;
+            break;
+        }
+    }
+    xSemaphoreGive(s_mutex);
+    return result;
+}
+
+void mint_health_mark_unreachable(const char *url)
+{
+    if (!url) return;
+    if (xSemaphoreTake(s_mutex, pdMS_TO_TICKS(1000)) != pdTRUE) return;
+    for (int i = 0; i < s_mint_count; i++) {
+        if (strcmp(s_mints[i].url, url) == 0 || strstr(url, s_mints[i].url) != NULL) {
+            if (s_mints[i].reachable) {
+                s_mints[i].reachable = false;
+                s_mints[i].consecutive_successes = 0;
+                ESP_LOGW(TAG, "Reactively marked unreachable: %s", url);
+            }
+            break;
+        }
+    }
+    xSemaphoreGive(s_mutex);
+}
+
+void mint_health_register_callback(mint_health_changed_cb cb)
+{
+    if (s_callback_count < MAX_CALLBACKS && cb) {
+        s_callbacks[s_callback_count++] = cb;
+    }
+}