1 files changed, 237 insertions, 0 deletions

diff --git a/main/market.c b/main/market.c
new file mode 100644
index 0000000..c8a0b6d
--- /dev/null
+++ b/main/market.c
@@ -0,0 +1,237 @@
+#include "market.h"
+#include "beacon_price.h"
+#include "config.h"
+#include "identity.h"
+#include "esp_log.h"
+#include "esp_wifi.h"
+#include "freertos/FreeRTOS.h"
+#include "freertos/task.h"
+#include <string.h>
+
+static const char *TAG = "market";
+static market_t s_market;
+static bool s_initialized = false;
+
+static int64_t get_time_ms(void)
+{
+    return (int64_t)xTaskGetTickCount() * portTICK_PERIOD_MS;
+}
+
+static bool oui_matches(const uint8_t oui[3])
+{
+    return oui[0] == TOLLGATE_OUI_0 && oui[1] == TOLLGATE_OUI_1 && oui[2] == TOLLGATE_OUI_2;
+}
+
+static int find_entry_by_bssid(const uint8_t bssid[6])
+{
+    for (int i = 0; i < MARKET_MAX_ENTRIES; i++) {
+        if (s_market.entries[i].valid && memcmp(s_market.entries[i].bssid, bssid, 6) == 0) {
+            return i;
+        }
+    }
+    return -1;
+}
+
+static int find_free_slot(void)
+{
+    for (int i = 0; i < MARKET_MAX_ENTRIES; i++) {
+        if (!s_market.entries[i].valid) return i;
+    }
+    int oldest = 0;
+    int64_t oldest_time = s_market.entries[0].discovered_ms;
+    for (int i = 1; i < MARKET_MAX_ENTRIES; i++) {
+        if (s_market.entries[i].discovered_ms < oldest_time) {
+            oldest_time = s_market.entries[i].discovered_ms;
+            oldest = i;
+        }
+    }
+    return oldest;
+}
+
+void market_parse_vendor_ie(const uint8_t sa[6], const vendor_ie_data_t *ie, int rssi)
+{
+    if (!ie || ie->length < 4 + TOLLGATE_IE_PAYLOAD_SIZE) return;
+    if (!oui_matches(ie->vendor_oui)) return;
+    if (ie->vendor_oui_type != TOLLGATE_IE_TYPE) return;
+
+    const tollgate_price_payload_t *payload = (const tollgate_price_payload_t *)ie->payload;
+    if (payload->version != TOLLGATE_IE_VERSION) return;
+
+    const tollgate_identity_t *id = identity_get();
+    if (id && id->initialized) {
+        uint8_t my_npub_hash[4];
+        beacon_price_hash_npub(id->npub_hex, my_npub_hash);
+        if (memcmp(payload->npub_hash, my_npub_hash, 4) == 0) return;
+    }
+
+    int idx = find_entry_by_bssid(sa);
+    if (idx < 0) {
+        idx = find_free_slot();
+        if (s_market.count < MARKET_MAX_ENTRIES) s_market.count++;
+    }
+
+    market_entry_t *entry = &s_market.entries[idx];
+    memcpy(entry->bssid, sa, 6);
+    entry->rssi = (int8_t)rssi;
+    entry->price_per_step = payload->price_per_step;
+    entry->step_size = payload->step_size;
+    entry->metric = payload->metric;
+    memcpy(entry->mint_hash, payload->mint_hash, 4);
+    memcpy(entry->npub_hash, payload->npub_hash, 4);
+
+    uint8_t gh_len = payload->geohash_len;
+    if (gh_len > TOLLGATE_IE_GEOHASH_MAX) gh_len = TOLLGATE_IE_GEOHASH_MAX;
+    memcpy(entry->geohash, payload->geohash, gh_len);
+    entry->geohash[gh_len] = '\0';
+
+    entry->discovered_ms = get_time_ms();
+    entry->valid = true;
+    entry->ssid[0] = '\0';
+
+    ESP_LOGI(TAG, "Discovered TollGate %02X:%02X:%02X:%02X:%02X:%02X price=%lu sats step=%lu metric=%s RSSI=%d",
+             sa[0], sa[1], sa[2], sa[3], sa[4], sa[5],
+             (unsigned long)payload->price_per_step, (unsigned long)payload->step_size,
+             payload->metric ? "bytes" : "milliseconds", rssi);
+}
+
+static void vendor_ie_cb(void *ctx, wifi_vendor_ie_type_t type,
+                          const uint8_t sa[6], const vendor_ie_data_t *vnd_ie, int rssi)
+{
+    (void)ctx;
+    (void)type;
+    if (!vnd_ie) return;
+    market_parse_vendor_ie(sa, vnd_ie, rssi);
+}
+
+static void scan_done_cb(void *arg, esp_event_base_t event_base,
+                          int32_t event_id, void *event_data)
+{
+    (void)arg;
+    (void)event_base;
+    (void)event_id;
+    (void)event_data;
+
+    s_market.scanning = false;
+
+    uint16_t ap_count = 0;
+    esp_wifi_scan_get_ap_num(&ap_count);
+    if (ap_count == 0) return;
+
+    uint16_t max_aps = ap_count > 20 ? 20 : ap_count;
+    wifi_ap_record_t *ap_records = malloc(max_aps * sizeof(wifi_ap_record_t));
+    if (!ap_records) return;
+
+    esp_wifi_scan_get_ap_records(&max_aps, ap_records);
+
+    for (int i = 0; i < max_aps; i++) {
+        for (int j = 0; j < MARKET_MAX_ENTRIES; j++) {
+            if (!s_market.entries[j].valid) continue;
+            if (memcmp(s_market.entries[j].bssid, ap_records[i].bssid, 6) == 0) {
+                memcpy(s_market.entries[j].ssid, ap_records[i].ssid, 32);
+                s_market.entries[j].ssid[32] = '\0';
+                s_market.entries[j].rssi = ap_records[i].rssi;
+                break;
+            }
+        }
+    }
+    free(ap_records);
+    s_market.last_scan_ms = get_time_ms();
+
+    ESP_LOGI(TAG, "Scan complete: %d APs, %d TollGates found", max_aps, s_market.count);
+}
+
+static esp_event_handler_instance_t s_scan_done_handler = NULL;
+
+esp_err_t market_init(void)
+{
+    memset(&s_market, 0, sizeof(s_market));
+
+    esp_err_t ret = esp_wifi_set_vendor_ie_cb(vendor_ie_cb, NULL);
+    if (ret != ESP_OK) {
+        ESP_LOGE(TAG, "Failed to register vendor IE callback: %s", esp_err_to_name(ret));
+        return ret;
+    }
+
+    if (!s_scan_done_handler) {
+        ret = esp_event_handler_instance_register(WIFI_EVENT, WIFI_EVENT_SCAN_DONE,
+                                                   scan_done_cb, NULL, &s_scan_done_handler);
+        if (ret != ESP_OK) {
+            ESP_LOGW(TAG, "Failed to register scan done handler: %s", esp_err_to_name(ret));
+        }
+    }
+
+    s_initialized = true;
+    ESP_LOGI(TAG, "Market scanner initialized");
+    return ESP_OK;
+}
+
+void market_tick(void)
+{
+    if (!s_initialized) return;
+
+    const tollgate_config_t *cfg = tollgate_config_get();
+    if (!cfg->market_enabled) return;
+
+    if (s_market.scanning) return;
+
+    int64_t now = get_time_ms();
+    int64_t elapsed = now - s_market.last_scan_ms;
+    int64_t interval_ms = (int64_t)cfg->market_scan_interval_s * 1000;
+    if (elapsed < interval_ms) return;
+
+    wifi_scan_config_t scan_config = {
+        .ssid = NULL,
+        .bssid = NULL,
+        .channel = 0,
+        .show_hidden = false,
+        .scan_type = WIFI_SCAN_TYPE_PASSIVE,
+        .scan_time.passive = 120,
+    };
+
+    esp_err_t ret = esp_wifi_scan_start(&scan_config, false);
+    if (ret == ESP_OK) {
+        s_market.scanning = true;
+        s_market.last_scan_ms = now;
+        s_market.consecutive_failures = 0;
+        ESP_LOGD(TAG, "Market scan started");
+    } else {
+        s_market.consecutive_failures++;
+        s_market.last_scan_ms = now;
+        if (s_market.consecutive_failures <= 3 || s_market.consecutive_failures % 30 == 0) {
+            ESP_LOGW(TAG, "Scan start failed: %s (failures: %d)", esp_err_to_name(ret), s_market.consecutive_failures);
+        }
+    }
+}
+
+const market_t *market_get(void)
+{
+    return &s_market;
+}
+
+int market_find_cheapest(void)
+{
+    int cheapest = -1;
+    uint32_t best_eff_price = UINT32_MAX;
+
+    for (int i = 0; i < MARKET_MAX_ENTRIES; i++) {
+        if (!s_market.entries[i].valid) continue;
+        if (s_market.entries[i].ssid[0] == '\0') continue;
+
+        uint32_t step = s_market.entries[i].step_size;
+        if (step == 0) continue;
+
+        uint32_t eff;
+        if (s_market.entries[i].metric == 0) {
+            eff = (uint32_t)s_market.entries[i].price_per_step * 60000 / step;
+        } else {
+            uint32_t eff_mb = (uint32_t)s_market.entries[i].price_per_step * 1048576 / step;
+            eff = eff_mb;
+        }
+
+        if (eff < best_eff_price) {
+            best_eff_price = eff;
+            cheapest = i;
+        }
+    }
+    return cheapest;
+}