#include "utils.h"

#include <algorithm>
#include <iostream>
#include <sstream>

using std::istringstream;
using std::string;
using namespace std::chrono;

std::vector<WasteDate> parseCsv(const std::string &csv) {
    istringstream stream(csv);
    string line;
    std::vector<WasteDate> dates;

    // Get rid of the first line
    std::getline(stream, line);

    while (std::getline(stream, line)) {
        string delimiter = ";";
        size_t pos = 0;
        string token;
        uint tokenPos = 0;
        while ((pos = line.find(delimiter)) != std::string::npos) {
            token = line.substr(0, pos);
            // std::cout << token << std::endl;

            if (token.length() > 0) {
                istringstream liness(token);
                string day_str, month_str, year_str;
                getline(liness, day_str, '.');
                getline(liness, month_str, '.');
                getline(liness, year_str, '.');
                int day = atoi(day_str.c_str());
                int month = atoi(month_str.c_str());
                int year = atoi(year_str.c_str());
                year_month_day date{std::chrono::year{year}, std::chrono::month{(uint)month},
                                    std::chrono::day{(uint)day}};

                std::vector<WasteDate>::iterator it;
                WasteDate wd;
                it = std::find_if(dates.begin(), dates.end(),
                                  [&date](const WasteDate &x) { return date == x.date; });
                if (it == dates.end()) {
                    wd.date = date;
                    dates.push_back(wd);
                    wd = dates.back();
                } else {
                    wd = *it;
                }

                switch (tokenPos) {
                case 0:
                    // printf("Gelber Sack: %s\n", token.c_str());
                    wd.wasteTypes.push_back(Waste::GelberSack);
                    break;
                case 1:
                    // printf("Papiertonne: %s\n", token.c_str());
                    wd.wasteTypes.push_back(Waste::Papiertonne);
                    break;
                case 2:
                    // printf("Biotonne: %s\n", token.c_str());
                    wd.wasteTypes.push_back(Waste::Biotonne);
                    break;
                case 3:
                    // printf("Restmüll: %s\n", token.c_str());
                    wd.wasteTypes.push_back(Waste::Restmuell);
                    break;
                case 4:
                    // printf("Problemstoffmobil: %s\n", token.c_str());
                    wd.wasteTypes.push_back(Waste::Problemstoffmobil);
                    break;
                default:
#ifdef DEBUG
                    printf("Unknown waste token detected.\n");
#endif
                    break;
                }
            }

            line.erase(0, pos + delimiter.length());
            ++tokenPos;
        }
    }

    // for(const auto& ymd: dates) {
    //     std::cout << "Current Year: " << static_cast<int>(ymd.date.year())
    //           << ", Month: " << static_cast<unsigned>(ymd.date.month())
    //           << ", Day: " << static_cast<unsigned>(ymd.date.day()) << '\n';
    // }

    return dates;
}

int wifi_setup_impl(uint32_t country, const string &ssid, const string &pw, bool firstTry) {
    if (firstTry) {
        if (cyw43_arch_init_with_country(country)) {
            return 1;
        }
    }

    cyw43_arch_enable_sta_mode();

    netif_set_hostname(netif_default, "AbfallPicoW");

    if (cyw43_arch_wifi_connect_async(ssid.c_str(), pw.c_str(), CYW43_AUTH_WPA2_MIXED_PSK)) {
        return 2;
    }

    int flashrate = 1000;
    int status = CYW43_LINK_UP + 1;

    while (status >= 0 && status != CYW43_LINK_UP) {
        int status_new = cyw43_tcpip_link_status(&cyw43_state, CYW43_ITF_STA);

        if (status_new != status) {
            status = status_new;
            if (status < 0) {
                continue;
            }
            flashrate = flashrate / (status + 1);
            // printf("Connect status: %d %d\n", status, flashrate);
        }
        cyw43_arch_gpio_put(CYW43_WL_GPIO_LED_PIN, 1);
        sleep_ms(flashrate);
        cyw43_arch_gpio_put(CYW43_WL_GPIO_LED_PIN, 0);
        sleep_ms(flashrate);
    }

    if (status < 0) {
        cyw43_arch_gpio_put(CYW43_WL_GPIO_LED_PIN, 0);
    } else {
        cyw43_arch_gpio_put(CYW43_WL_GPIO_LED_PIN, 1);
#ifdef DEBUG
        printf("IP: %s\n", ip4addr_ntoa(netif_ip_addr4(netif_default)));
#endif
    }

    return status;
}

void wifi_setup() {
    const string ssid{"Apis cerana"};
    const string pw{"2JkJEh2vptVT"};
    const uint32_t country{CYW43_COUNTRY_GERMANY};

    bool firstTry = true;
    int res = -1;
    do {
        if (firstTry) {
            res = wifi_setup_impl(country, ssid, pw, true);
            firstTry = false;
        } else {
#ifdef DEBUG
            printf("Setting up connection failed. Trying again after 5 sec...\n");
#endif
            sleep_ms(5000);
            res = wifi_setup_impl(country, ssid, pw, false);
        }

    } while (res != CYW43_LINK_UP);
}