#include "bme280.h"
#include "dhcp_server.h"
#include "hardware/i2c.h"
#include "lwip/apps/httpd.h"
#include "lwip/apps/mqtt.h"
#include "lwip/apps/sntp.h"
#include "pico/cyw43_arch.h"
#include "pico/stdlib.h"
#include "webserver.h"
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <stdint.h>

static dhcp_server_t dhcp_server{};

void ap_init() {
  cyw43_arch_enable_ap_mode("SensorAP", "passwort123", CYW43_AUTH_WPA2_AES_PSK);

  ip_addr_t gw{};
  ip_addr_t mask{};
  IP4_ADDR(&gw, 192, 168, 4, 1);
  IP4_ADDR(&mask, 255, 255, 255, 0);

  dhcp_server_deinit(&dhcp_server);
  dhcp_server_init(&dhcp_server, &gw, &mask);
}

void reset_mqtt_config() {
  memset(saved_mqtt_address, 0, sizeof(saved_mqtt_address));
  memset(saved_mqtt_user, 0, sizeof(saved_mqtt_user));
  memset(saved_mqtt_password, 0, sizeof(saved_mqtt_password));
  saved_measure_frequency = 0;
  saved_post_frequency = 0;
}

int connect_to_wifi() {
  int ret{};
  memset(saved_ssid, 0, sizeof(saved_ssid));
  memset(saved_password, 0, sizeof(saved_password));
  ap_init();
  while (saved_ssid[0] == '\0') {
    cyw43_arch_poll();
    sleep_ms(100);
  }
  dhcp_server_deinit(&dhcp_server);
  cyw43_arch_disable_ap_mode();
  cyw43_arch_disable_sta_mode();
  sleep_ms(500);
  cyw43_arch_enable_sta_mode();

  ret = cyw43_arch_wifi_connect_timeout_ms(saved_ssid, saved_password,
                                           CYW43_AUTH_WPA2_MIXED_PSK, 30000);
  if (ret == 0) {
    return 0;
  }
  return -1;
}

void mqtt_cb(mqtt_client_t *client, void *arg,
             mqtt_connection_status_t status) {
  int *mqtt_status{static_cast<int *>(arg)};
  *mqtt_status = (status == MQTT_CONNECT_ACCEPTED) ? 0 : 1;
}

mqtt_client_t *connect_to_mqtt() {
  static int mqtt_status{-1};
  ip_addr_t broker_ip;
  static mqtt_client_t *client{};
  static mqtt_connect_client_info_t info{};

  if (!ipaddr_aton(saved_mqtt_address, &broker_ip)) {
    return nullptr;
  }
  if (!client) {
    client = mqtt_client_new();
  }
  info.client_id = "sensor-pico";
  info.client_user = saved_mqtt_user;
  info.client_pass = saved_mqtt_password;

  mqtt_status = -1;
  mqtt_client_connect(client, &broker_ip, saved_mqtt_port, mqtt_cb,
                      &mqtt_status, &info);
  while (mqtt_status == -1) {
    cyw43_arch_poll();
    sleep_ms(100);
  }
  if (mqtt_status == 0) {
    return client;
  }
  return nullptr;
}

BME280_READING_INTERVALS_MS convert_Interval(int interval) {
  if (interval < 1) {
    return INTERVAL_0_5MS;
  } else if (interval < 20 && interval > 1) {
    return INTERVAL_10MS;
  } else if (interval < 30 && interval > 10) {
    return INTERVAL_20MS;
  } else if (interval < 125 && interval > 20) {
    return INTERVAL_62_5MS;
  } else if (interval < 250 && interval > 62.5) {
    return INTERVAL_125MS;
  } else if (interval < 500 && interval > 125) {
    return INTERVAL_250MS;
  } else if (interval < 1000 && interval > 250) {
    return INTERVAL_500MS;
  } else if (interval > 1000) {
    return INTERVAL_1000MS;
  } else {
    return INTERVAL_500MS;
  }
}

void publish_cb(void *arg, err_t err) { printf("Publish succesfull!\n"); }

void publish_mqtt(mqtt_client_t *client, const char *payload) {
  uint payload_len{strlen(payload)};
  mqtt_publish(client, "tele/sensor-pico/SENSOR", payload, payload_len, 1, 1,
               publish_cb, nullptr);
}

bool parse_json(const char *raw, float &temperature, float &humidity,
                float &pressure) {
  if (!raw)
    return false;

  const char *t_ptr = std::strstr(raw, "\"temperature\":");
  const char *h_ptr = std::strstr(raw, "\"humidity\":");
  const char *p_ptr = std::strstr(raw, "\"pressure\":");

  if (!t_ptr || !h_ptr || !p_ptr)
    return false;

  long t_raw = std::strtol(t_ptr + 14, nullptr, 10);
  long h_raw = std::strtol(h_ptr + 11, nullptr, 10);
  long p_raw = std::strtol(p_ptr + 11, nullptr, 10);

  temperature = t_raw / 100.0f;
  humidity = h_raw / 1024.0f;
  pressure = p_raw / 25600.0f;

  return true;
}

void build_sensor_payload(char *buffer, size_t size, bme280_handle_t handle,
                          const char *sensor_name) {
  bme280_read_data(handle);
  const char *raw = bme280_get_json(handle);

  if (!raw) {
    snprintf(buffer, size, "{\"error\":\"no data\"}");
    return;
  }

  float temperature, humidity, pressure;
  parse_json(raw, temperature, humidity, pressure);

  time_t now;
  time(&now);
  struct tm *timeinfo = localtime(&now);

  char time_str[32];
  strftime(time_str, sizeof(time_str), "%Y-%m-%dT%H:%M:%S", timeinfo);

  snprintf(buffer, size,
           "{"
           "\"Time\":\"%s\","
           "\"%s\":{"
           "\"Temperature\":%.2f,"
           "\"Humidity\":%.2f,"
           "\"Pressure\":%.2f"
           "},"
           "\"TempUnit\":\"C\""
           "}",
           time_str, sensor_name, temperature, humidity, pressure);
}
bool is_time_synced() {
  time_t now = time(NULL);
  struct tm *timeinfo = localtime(&now);
  return timeinfo->tm_year > 70;
}

void start_sntp() {
  cyw43_arch_lwip_begin();
  if (sntp_enabled()) {
    sntp_stop();
  }
  sntp_setoperatingmode(SNTP_OPMODE_POLL);
#if SNTP_SERVER_DNS
  sntp_setservername(0, "de.pool.ntp.org");
#endif
  sntp_init();
  cyw43_arch_lwip_end();
}

int main() {
  uint32_t last_publish{};
  uint32_t last_sntp_retry_ms{};
  int mqtt_ret{-1};
  int wifi_status{1};
  int bme_status{-1};
  char payload[256];
  mqtt_client_t *client{};
  bme280_handle_t handle{};
  stdio_init_all();
  setenv("TZ", "CET-1CEST,M3.5.0,M10.5.0", 1);
  tzset();
  sleep_ms(3000);
  cyw43_arch_init();
  httpd_init();

  while (wifi_status != 0) {
    wifi_status = (connect_to_wifi() == 0) ? 0 : 1;
    printf("Wifi status: %d\n", wifi_status);
  }
  printf("Connected to wifi!\n");
  printf("IP: %s\n", ip4addr_ntoa(netif_ip4_addr(netif_default)));
  start_sntp();
  last_sntp_retry_ms = to_ms_since_boot(get_absolute_time());

  while (true) {
    while (saved_mqtt_address[0] == '\0') {
      cyw43_arch_poll();
      sleep_ms(200);
    }
    client = connect_to_mqtt();
    if (client == nullptr) {
      printf("Mqtt Status: %d\n", mqtt_ret);
      reset_mqtt_config();
    } else {
      printf("Connected to mqtt!\n");
      break;
    }
  }
  bme_status =
      bme280_init(&handle, 0x76, convert_Interval(saved_measure_frequency));
  if (!bme_status) {
    last_publish = to_ms_since_boot(get_absolute_time());
    while (true) {
      if ((to_ms_since_boot(get_absolute_time()) - last_publish) >=
          saved_post_frequency * 1000) {
        if (is_time_synced()) {
          build_sensor_payload(payload, sizeof(payload), handle, "BME280");
          publish_mqtt(client, payload);
          printf("Payload: %s\n", payload);
          last_publish = to_ms_since_boot(get_absolute_time());
        } else {
          printf("Waiting for SNTP sync (Current year: 1970)...\n");
          uint32_t now_ms = to_ms_since_boot(get_absolute_time());
          if (now_ms - last_sntp_retry_ms > 30000) {
            printf("Retrying SNTP...\n");
            start_sntp();
            last_sntp_retry_ms = now_ms;
          }
          last_publish = to_ms_since_boot(get_absolute_time()) -
                         (saved_post_frequency * 1000) + 5000;
        }
      }
      cyw43_arch_poll();
      sleep_ms(100);
    }
  }
}