// #include <Arduino.h>
#include <ESP8266WiFi.h>
// #include <PubSubClient.h>

extern WiFiClient wifi_client;
extern PubSubClient mqtt_client;

namespace diller {
namespace serial {

using diller::utils::tty_status;

template<typename d_core, typename io_t>
void diller_serial<d_core, io_t>::cmd_network() {
  Serial.print("ok ip=");
  WiFi.localIP().printTo(Serial);
  Serial.print(" gateway=");
  WiFi.gatewayIP().printTo(Serial);
  Serial.print(" netmask=");
  WiFi.subnetMask().printTo(Serial);
  Serial.println();
}

template<typename d_core, typename io_t>
void diller_serial<d_core, io_t>::cmd_wlan() {
  Serial.print("ok ssid=");
  tty.quote(WiFi.SSID());
  if (send_wlan_password) {
    Serial.print(" password=");
    Serial.print(WiFi.psk());
  }

  Serial.print(" mac=");
  Serial.println(diller.mac);
}

template<typename d_core, typename io_t>
void diller_serial<d_core, io_t>::cmd_wlan(const char* ssid, const char* password) {
  WiFi.begin(ssid, password);
  Serial.println("ok");
}

template<typename d_core, typename io_t>
void diller_serial<d_core, io_t>::cmd_property(const char *id, const char *value, const char *name) {
  auto ret = diller.cmd_property(id, value, name);

  if (ret != diller_error::OK) {
    Serial.print("fail error=");
    Serial.println(to_string(ret));
  }
}

template<typename d_core, typename io_t>
void diller_serial<d_core, io_t>::cmd_list_properties() {
  Serial.print("ok count=");
  Serial.println(diller.properties.size());
  for (auto i = 0; i < diller.properties.size(); i++) {
    auto p = diller.properties[i];
    Serial.print("property id=");
    Serial.print(p->id());
    Serial.print(" name=");
    Serial.print(p->name());
    Serial.print(" description=");
    Serial.print(p->description());
    Serial.println();
  }
}

template<typename d_core, typename io_t>
void diller_serial<d_core, io_t>::show_status(wl_status_t wl_status) {
  const char *wl_status_s;
  if (wl_status == WL_IDLE_STATUS) {
    wl_status_s = "idle";
  } else if (wl_status == WL_NO_SSID_AVAIL) {
    wl_status_s = "no-ssid";
  } else if (wl_status == WL_SCAN_COMPLETED) {
    wl_status_s = "scan-completed";
  } else if (wl_status == WL_CONNECTED) {
    wl_status_s = "connected";
  } else if (wl_status == WL_CONNECT_FAILED) {
    wl_status_s = "connect-failed";
  } else if (wl_status == WL_CONNECTION_LOST) {
    wl_status_s = "connection-lost";
  } else if (wl_status == WL_DISCONNECTED) {
    wl_status_s = "disconnected";
  } else {
    wl_status_s = "unknown";
  }

  const char *mqtt_status_s;
  if (diller.connected()) {
    mqtt_status_s = "connected";
  } else {
    mqtt_status_s = "disconnected";
  }

  Serial.print("status wlan=");
  Serial.print(wl_status_s);
  Serial.print(" mqtt=");
  Serial.println(mqtt_status_s);
}

template<typename d_core, typename io_t>
void diller_serial<d_core, io_t>::process_command() {
  if (params.is_empty()) {
    return;
  }

  auto cmd = params.key(0);

  if (strcmp("network", cmd) == 0) {
    if (params.size() == 1) {
      cmd_network();
    } else {
      Serial.println("fail error=invalid_argument");
    }
  } else if (strcmp("wlan", cmd) == 0) {
    if (params.size() == 1) {
      cmd_wlan();
    } else if (params.size() == 3) {
      const char* ssid = params.find("ssid");
      const char* password = params.find("password");
      cmd_wlan(ssid, password);
    } else {
      Serial.println("fail error=invalid_argument");
    }
  } else if (strcmp("property", cmd) == 0) {
    auto id = params.find("id");
    auto value = params.find("value");
    auto name = params.find("name");
    cmd_property(id, value, name);
  } else if (strcmp("list-properties", cmd) == 0) {
    cmd_list_properties();
  } else {
    Serial.print("fail error=unknown_command cmd=");
    tty.escape(cmd);
    Serial.println();
  }
}

template<typename d_core, typename io_t>
void diller_serial<d_core, io_t>::setup() {
  diller.set_property_action_listener(this);
}

template<typename d_core, typename io_t>
void diller_serial<d_core, io_t>::loop() {
  if (tty.readline() == tty_status::FULL_LINE) {
    diller_parser.parse(tty.line);

    process_command();
  }

  static auto last_wl_status = WiFi.status();
  auto wl_status = WiFi.status();

  static auto last_status = millis();
  auto now = millis();
  static const auto show_status_interval = 5000;

  if (last_wl_status != wl_status) {
    show_status(wl_status);
    last_wl_status = wl_status;
    last_status = now;
  } else if (now > (last_status + show_status_interval)) {
    show_status(wl_status);
    last_status = now;
  }
}

template<typename d_core, typename io_t>
void diller_serial<d_core, io_t>::on_property_action(const property *p, property_action) {
  Serial.print("property id=");
  tty.quote(p->id());
  Serial.print(" value=");
  tty.quote(p->value());
  Serial.print(" description=");
  tty.quote(p->description());
  Serial.println();
}

} // namespace serial
} // namespace diller