#include <iostream>

#include <random>

#include "mcc_pcm.h"
#include "mcc_serializer.h"
#include "mcc_telemetry.h"

static std::random_device rd;
static std::mt19937 gen(rd());
static std::uniform_int_distribution<long> tm_distrib(100, 700);
static std::uniform_real_distribution<double> x_distrib(1000, 7000);
static std::uniform_real_distribution<double> y_distrib(1000, 7000);
static std::uniform_real_distribution<double> xs_distrib(100, 700);
static std::uniform_real_distribution<double> ys_distrib(100, 700);

struct hw_t {
    static constexpr std::string_view hardwareName{"HW-TEST"};

    typedef int error_t;

    enum class hardware_movement_state_t : int {
        HW_MOVE_ERROR = -1,
        HW_MOVE_STOPPED = 0,
        HW_MOVE_STOPPING,
        HW_MOVE_SLEWING,
        HW_MOVE_ADJUSTING,
        HW_MOVE_TRACKING,
        HW_MOVE_GUIDING
    };

    struct hardware_state_t {
        mcc::impl::MccGenXY XY{1.0, 1.0}, speedXY{2.0, 2.0};
        hardware_movement_state_t movementState{hardware_movement_state_t::HW_MOVE_STOPPED};
    };


    error_t hardwareSetState(hardware_state_t const&)
    {
        return 0;
    }


    error_t hardwareGetState(hardware_state_t* state)
    {
        auto ms = std::chrono::milliseconds(tm_distrib(gen));
        std::cout << "\tgetState running " << ms << " ...";

        std::this_thread::sleep_for(ms);

        std::cout << "\tdone!\n";

        *state = hardware_state_t{.XY{x_distrib(gen), y_distrib(gen)}, .speedXY{xs_distrib(gen), ys_distrib(gen)}};

        return 0;
    }

    error_t hardwareInit()
    {
        return 0;
    }
};

template <>
struct std::formatter<hw_t::hardware_movement_state_t, char> : std::formatter<std::string_view> {
    auto format(hw_t::hardware_movement_state_t e, auto& ctx) const
    {
        return formatter<std::string_view>::format(e == hw_t::hardware_movement_state_t::HW_MOVE_ERROR      ? "ERROR"
                                                   : e == hw_t::hardware_movement_state_t::HW_MOVE_STOPPED  ? "STOPPED"
                                                   : e == hw_t::hardware_movement_state_t::HW_MOVE_STOPPING ? "STOPPING"
                                                   : e == hw_t::hardware_movement_state_t::HW_MOVE_SLEWING  ? "SLEWING"
                                                   : e == hw_t::hardware_movement_state_t::HW_MOVE_TRACKING ? "TRACKING"
                                                                                                            : "UNKNOWN",
                                                   ctx);
    }
};


// template <>
// struct std::formatter<hw_t::hardware_movement_state_t, char>
//     : std::formatter<std::underlying_type_t<hw_t::hardware_movement_state_t>, char> {
//     auto format(hw_t::hardware_movement_state_t e, auto& ctx) const
//     {
//         return formatter<std::underlying_type_t<hw_t::hardware_movement_state_t>>::format(
//             std::underlying_type_t<hw_t::hardware_movement_state_t>(e), ctx);
//     }
// };



static_assert(mcc::mcc_hardware_c<hw_t>, "!!!!!");


typedef mcc::impl::MccTelemetry<hw_t> t_t;

int main()
{
    hw_t hw;
    mcc::impl::MccMountDefaultForkPec pcm;

    t_t tlm(&hw, &pcm);
    typename t_t::telemetry_data_t tdata;

    for (int i = 0; i < 20; ++i) {
        std::cout << std::format("{}-th run\n", i + 1);

        auto err = tlm.telemetryData(&tdata);
        std::cout << "\tgot hw: XY = {" << tdata.hwState.XY.x() << ", " << tdata.hwState.XY.y() << "};  speedXY = {"
                  << tdata.hwState.speedXY.x() << ", " << tdata.hwState.speedXY.y() << "}\n";
        if (err) {
            std::cout << "ERR: " << err.message() << "\n";
        }
    }


    mcc::impl::MccSerializer<typename t_t::telemetry_data_t> ser;

    std::string str;

    auto err = ser(str, tdata);
    if (err) {
        std::cout << "ERR: " << err.message() << "\n";
    } else {
        std::cout << "\n\n";
        std::cout << str << "\n";
    }

    return 0;
}