#include "include/serial.h"
#include <algorithm>
#include <chrono>
#include <cstdio>
#include <iostream>
#include <limits>
#include <ranges>
#include <string_view>
#undef max
using namespace std::literals::chrono_literals;
using namespace std::literals::string_view_literals;
using namespace std::literals::string_literals;
using namespace serial;
namespace ranges = std::ranges;
namespace views = std::views;

void PrintLog(const std::string &msg) { std::cout << msg << std::endl; }

template <typename T>
    requires std::is_same_v<T, std::string> ||
             std::is_same_v<T, std::string_view>
std::vector<T> split(T str, T d) {
    auto v = views::split(str, d) | views::transform([](auto word) {
                 return T(word.begin(), word.end());
             });
    return std::vector<T>(v.begin(), v.end());
}

int main() {
    Serial ser;
    ser.OpenDevice("COM11", 115200);
    ser.SetLogCallBack(PrintLog);
    ser.GetAtUntilRepeat<5>("AT", "OK");
    return 0;
}

/*
int main(int argc, char **const argv) {
    Serial serial;
    auto ports = serial::GetUsbPorts();
    ranges::for_each(ports,
                     [](const auto &port) { std::cout << port << std::endl; });
    std::string portName;
    std::string command;
    std::cin >> portName;
    std::cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n');
    serial.OpenDevice(portName);
    serial.SetLogCallBack(PrintLog);
    while (true) {
        command.clear();
        std::getline(std::cin, command);
        system("cls");
        auto startTime = std::chrono::system_clock::now();
        if (command.at(0) == ':') {
            command = command.substr(1, command.length() - 1);
            auto sp = split(command, " "s);
            auto reallyCommand = sp[0];
            auto expect = sp[1];
            auto res = serial.GetAtUntil(reallyCommand, 2000, expect);
            auto endTime = std::chrono::system_clock::now();
            res ? std::cout
                      << "dura: "
                      << std::chrono::duration_cast<std::chrono::milliseconds>(
                             endTime - startTime)
                             .count()
                      << std::endl
                : std::cout << "Recive Error";
        } else {
            auto resp = serial.GetAtResponse(command);
            auto endTime = std::chrono::system_clock::now();
            std::cout << "dura: "
                      << std::chrono::duration_cast<std::chrono::milliseconds>(
                             endTime - startTime)
                             .count()
                      << std::endl;
            std::cout << resp.value_or("Send Command Fail") << std::endl;
        }
    }
    return 0;
}
*/