#pragma once

#include <filesystem>


#include <mcc/mcc_keyvalue.h>
#include <mcc/mcc_pcm.h>
#include "mcc/mcc_pzone.h"

#include "asibfm700_common.h"
#include "asibfm700_servocontroller.h"

namespace asibfm700
{

static constexpr double SAORAS_LATITUDE = 43.646711_degs;
static constexpr double SAORAS_LONGITUDE = 41.440732_degs;


template <mcc::impl::mcc_record_value_c T>
struct config_record_t : mcc::impl::mcc_simple_kv_record_t<T> {
    std::vector<std::string_view> head_comment;
    std::string_view inline_comment;
};


template <mcc::impl::mcc_record_value_c T>
static config_record_t<T> make_config_record(
    std::string_view key,
    T value,
    std::vector<std::string_view> hcomm = {},
    std::string_view icomm = {},
    mcc::impl::mcc_serialization_params_t const& spars = mcc::impl::mcc_serialization_params_t{})
{
    return config_record_t<T>{{key, value, value, spars}, hcomm, icomm};
}


static auto Asibfm700MountConfigurationDefaults = std::make_tuple(

    /*    geographic coordinates of the observation site    */

    make_config_record("siteLatitude", mcc::impl::MccAngle(SAORAS_LATITUDE), {" site latitude in degrees"}),
    make_config_record("siteLongitude", mcc::impl::MccAngle(SAORAS_LONGITUDE), {" site longitude  in degrees"}),
    make_config_record("siteElevation", 2070.0, {" site elevation in meters"}),

    /*    celestial coordinate transformation    */

    make_config_record("refractWavelength", 0.55, {" wavelength at which refraction is calculated (in mkm)"}),
    make_config_record("leapSecondFilename", std::string(), {" an empty filename means default precompiled string"}),
    make_config_record("bulletinAFilename", std::string(), {" an empty filename means default precompiled string"}),

    /*    pointing correction model    */

    // PCM type
    make_config_record(
        "pcmType",
        mcc::impl::MccDefaultPCMType::PCM_TYPE_GEOMETRY,
        {" PCM type:", " a case-sensitive string:", "   GEOMETRY - 'classic' geometry-based correction coefficients",
         "   GEOMETRY-BSPLINE - previous one and additional 2D B-spline corrections",
         "   BSPLINE - pure 2D B-spline corrections"}),

    // PCM geometrical coefficients
    make_config_record("pcmGeomCoeffs",
                       std::vector<double>{0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0},
                       {" PCM geometrical coefficients"}),

    // make_config_record("pcmBsplineDegree", std::vector<size_t>{3, 3}, {"PCM B-spline degrees"}),

    // PCM B-spline knots along X-axis (HA-angle or azimuth). By default from 0 to 2*PI radians
    // NOTE: The first and last values are interpretated as border knots!!!
    //       Thus the array length must be equal to or greater than 2!
    make_config_record(
        "pcmBsplineXknots",
        mcc::impl::mccGenerateBsplineKnots(0.0, 360.0_degs, 8),
        {" PCM B-spline knots along X-axis (HA-angle or azimuth).", " By default from 0 to 2*PI radians.",
         " NOTE: The first and last values are interpretated as border knots!!!",
         "       Thus the array length must be equal to or greater than 2!"}),

    // PCM B-spline knots along Y-axis (declination or zenithal distance).
    // By default from -SAORAS-latitude to PI/2 radians
    // NOTE: The first and last values are interpretated as border knots!!!
    //       Thus the array length must be equal to or greater than 2!
    make_config_record("pcmBsplineYknots",
                       mcc::impl::mccGenerateBsplineKnots(-SAORAS_LATITUDE, 90.0_degs, 8),
                       {" PCM B-spline knots along Y-axis (declination or zenithal distance).",
                        " By default from -SAORAS-latitude to PI/2 radians.",
                        " NOTE: The first and last values are interpretated as border knots!!!",
                        "       Thus the array length must be equal to or greater than 2!"}),

    // PCM B-spline coeffs for along X-axis (HA-angle or azimuth)
    make_config_record("pcmBsplineXcoeffs",
                       std::vector<double>{},
                       {" PCM B-spline coeffs for along X-axis (HA-angle)"}),

    // PCM B-spline coeffs for along Y-axis (declination or zenithal distance)
    make_config_record("pcmBsplineYcoeffs",
                       std::vector<double>{},
                       {" PCM B-spline coeffs for along Y-axis (declination angle)"}),

    // inverse PCM B-spline coeffs for along X-axis (HA-angle or azimuth)
    make_config_record("pcmInverseBsplineXcoeffs",
                       std::vector<double>{},
                       {" Inverse PCM B-spline coeffs for along X-axis (HA-angle)"}),

    // inverse PCM B-spline coeffs for along Y-axis (declination or zenithal distance)
    make_config_record("pcmInverseBsplineYcoeffs",
                       std::vector<double>{},
                       {" Inverse PCM B-spline coeffs for along Y-axis (declination angle)"}),


    /*    prohibited zones    */

    // minimal altitude (default: 10.0 degrees and SAO RAS latitude)
    make_config_record("altLimPZ",
                       mcc::impl::MccAltLimitPZ<mcc::impl::MccAltLimitKind::MIN_ALT_LIMIT>{10.0_degs, SAORAS_LATITUDE},
                       {" minimal altitude prohibited zone"}),

    // HA-axis limit switch
    make_config_record(
        "axisLimitSwitchHA",
        mcc::impl::MccAxisLimitSwitchPZ<mcc::impl::MccCoordKind::COORDS_KIND_HA_OBS>{-170.0_degs, 170.0_degs, nullptr},
        {" HA-axis limit switch stop angles"}),

    // DEC-axis limit switch
    make_config_record(
        "axisLimitSwitchDEC",
        mcc::impl::MccAxisLimitSwitchPZ<mcc::impl::MccCoordKind::COORDS_KIND_DEC_OBS>{-90.0_degs, 90.0_degs, nullptr},
        {" DEC-axis limit switch stop angles"}),


    /*    hardware-related    */

    // hardware polling period in millisecs (used in hardwareSetState method; see asibfm700_servocontroller.cpp)
    make_config_record("hardwarePollingPeriod",
                       std::chrono::milliseconds{300},
                       {"hardware driver polling period in millisecs"}),

    // hardware polling timeout in millisecs (used in hardwareSetState method; see asibfm700_servocontroller.cpp)
    make_config_record("hardwarePollingTimeout",
                       std::chrono::milliseconds{30000},
                       {"hardware driver polling timeout in millisecs"}),


    // hardware mode: 1 - model mode, otherwise real mode
    make_config_record("RunModel", 0, {" hardware mode: 1 - model mode, otherwise real mode"}),

    // mount serial device paths
    make_config_record("MountDevPath", std::string("/dev/ttyUSB0"), {" mount serial device paths"}),

    // mount serial device speed
    make_config_record("MountDevSpeed", 19200, {" mount serial device speed"}),

    // motor encoders serial device path
    make_config_record("EncoderDevPath", std::string(""), {" motor encoders serial device path"}),

    //  X-axis encoder serial device path
    make_config_record("EncoderXDevPath", std::string("/dev/encoder_X0"), {" X-axis encoder serial device path"}),

    //  Y-axis encoder serial device path
    make_config_record("EncoderYDevPath", std::string("/dev/encoder_Y0"), {" Y-axis encoder serial device path"}),

    // encoders serial device speed
    make_config_record("EncoderDevSpeed", 153000, {" encoders serial device speed"}),

    // ==1 if encoder works as separate serial device, ==2 if there's new version with two devices
    make_config_record(
        "SepEncoder",
        2,
        {" ==1 if encoder works as separate serial device, ==2 if there's new version with two devices"}),


    // mount polling interval in millisecs
    make_config_record("MountReqInterval", std::chrono::milliseconds(100), {" mount polling interval in millisecs"}),

    // encoders polling interval in millisecs
    make_config_record("EncoderReqInterval", std::chrono::milliseconds(1), {" encoders polling interval in millisecs"}),

    // mount axes rate calculation interval in millisecs
    make_config_record("EncoderSpeedInterval",
                       std::chrono::milliseconds(50),
                       {" mount axes rate calculation interval in millisecs"}),

    make_config_record("PIDMaxDt",
                       std::chrono::milliseconds(1000),
                       {" maximal PID refresh time interval in millisecs",
                        " NOTE: if PID data will be refreshed with interval longer than this value (e.g. user polls "
                        " encoder data too rarely)",
                        " then the PID 'expired' data will be cleared and new computing loop is started"}),

    make_config_record("PIDRefreshDt", std::chrono::milliseconds(100), {" PID refresh interval"}),

    make_config_record("PIDCycleDt",
                       std::chrono::milliseconds(5000),
                       {" PID I cycle time (analog of 'RC' for PID on opamps)"}),



    // // X-axis coordinate PID P,I,D-params
    // make_config_record("XPIDC", std::vector<double>{0.5, 0.1, 0.2}, {" X-axis coordinate PID P,I,D-params"}),

    // X-axis rate PID P,I,D-params
    make_config_record("XPIDV", std::vector<double>{0.09, 0.0, 0.05}, {" X-axis rate PID P,I,D-params"}),

    // // Y-axis coordinate PID P, I, D-params
    // make_config_record("YPIDC", std::vector<double>{0.5, 0.1, 0.2}, {" Y-axis coordinate PID P, I, D-params"}),

    // Y-axis rate PID P,I,D-params
    make_config_record("YPIDV", std::vector<double>{0.09, 0.0, 0.05}, {" Y-axis rate PID P,I,D-params"}),


    // maximal moving rate (degrees per second) along HA-axis  (Y-axis of Sidereal servo microcontroller)
    make_config_record(
        "hwMaxRateHA",
        mcc::impl::MccAngle(8.0_degs),
        {" maximal moving rate (degrees per second) along HA-axis  (Y-axis of Sidereal servo microcontroller)"}),

    // maximal moving rate (degrees per second) along DEC-axis (X-axis of Sidereal servo microcontroller)
    make_config_record(
        "hwMaxRateDEC",
        mcc::impl::MccAngle(10.0_degs),
        {" maximal moving rate (degrees per second) along DEC-axis (X-axis of Sidereal servo microcontroller)"}),

    make_config_record("MaxPointingErr",
                       mcc::impl::MccAngle(8.0_degs),
                       {" slewing-to-pointing mode angular limit in degrees"}),

    make_config_record("MaxFinePointingErr",
                       mcc::impl::MccAngle(1.5_degs),
                       {" pointing-to-guiding mode angular limit in degrees"}),

    make_config_record("MaxGuidingErr",
                       mcc::impl::MccAngle(0.5_arcsecs),
                       {" guiding 'good'-flag error cirle radius (mount-to-target distance) in degrees"}),

    make_config_record("XEncZero", (int64_t)0, {" X-axis encoder zero-point in ticks"}),

    make_config_record("YEncZero", (int64_t)0, {" Y-axis encoder zero-point in ticks"}),


    /*    movement related common parameters    */

    // timeout for telemetry updating in milliseconds
    make_config_record("telemetryTimeout",
                       std::chrono::milliseconds(3000),
                       {" timeout for telemetry updating in milliseconds"}),

    // mount stopping process timeout in seconds
    make_config_record("stopTimeout", std::chrono::seconds(30), {" mount stopping process timeout in seconds"}),

    // minimal allowed time in seconds to prohibited zone
    make_config_record("minTimeToPZone",
                       std::chrono::seconds(10),
                       {" minimal allowed time in seconds to prohibited zone"}),

    /*    slewing and tracking parameters    */

    // telemetry request interval (in millisecs) in slewing mode
    make_config_record("slewingTelemetryInterval",
                       std::chrono::milliseconds(100),
                       {" telemetry request interval (in millisecs) in slewing mode"}),


    // slew process timeout in seconds
    make_config_record("slewTimeout", std::chrono::seconds(3600), {" slew process timeout in seconds"}),

    // coordinates difference in arcsecs to stop slewing
    make_config_record("slewToleranceRadius", 5.0, {"coordinates difference in arcsecs to stop slewing"}),

    // slewing trajectory filename (used for debugging purposes)
    // if it is an empty - just skip saving
    make_config_record("slewingPathFilename",
                       std::string(),
                       {" slewing trajectory filename", "if it is an empty - just skip saving"}),


    make_config_record("trackingTelemetryInterval",
                       std::chrono::milliseconds(100),
                       {" telemetry request interval (in millisecs) in tracking mode"}),


    // maximal valid target-to-mount distance for tracking process (arcsecs)
    // if current distance is greater than assume current mount coordinate as target point
    make_config_record("trackingMaxCoordDiff",
                       20.0,
                       {" maximal valid target-to-mount distance for tracking process (arcsecs)",
                        " if current distance is greater than assume current mount coordinate as target point"}),

    make_config_record("trackingPathFilename",
                       std::string(),
                       {" tracking trajectory filename", "if it is an empty - just skip saving"})


);

static_assert(std::is_copy_assignable_v<mcc::impl::MccAxisLimitSwitchPZ<mcc::impl::MccCoordKind::COORDS_KIND_HA_OBS>>);
static_assert(std::is_copy_assignable_v<mcc::impl::MccAltLimitPZ<mcc::impl::MccAltLimitKind::MIN_ALT_LIMIT>>);

// static_assert(std::is_copy_assignable_v<decltype(Asibfm700MountConfigurationDefaults)>);

class Asibfm700MountConfiguration : public mcc::impl::MccKeyValueHolder<decltype(Asibfm700MountConfigurationDefaults)>
{
    using base_t = mcc::impl::MccKeyValueHolder<decltype(Asibfm700MountConfigurationDefaults)>;

public:
    Asibfm700MountConfiguration() : base_t(Asibfm700MountConfigurationDefaults)
    {
        // fill comments

        auto get_comm = [this]<size_t I>() {
            auto& rec = std::get<I>(Asibfm700MountConfigurationDefaults);
            for (auto const& comm : rec.head_comment) {
                if (comm.size()) {
                    _headComment[_hashes[I]].emplace_back(std::string{comm.begin(), comm.end()});
                } else {
                    _headComment[_hashes[I]].emplace_back(std::nullopt);
                }
            }
            _inlineComment[_hashes[I]] = rec.inline_comment;
        };

        [&]<size_t... Is>(std::index_sequence<Is...>) {
            (get_comm.template operator()<Is>(), ...);
        }(std::make_index_sequence<Asibfm700MountConfiguration::NUMBER_OF_RECORDS>{});
    }

    ~Asibfm700MountConfiguration() = default;

    Asibfm700MountConfiguration(const Asibfm700MountConfiguration&) = default;
    Asibfm700MountConfiguration(Asibfm700MountConfiguration&&) = default;

    Asibfm700MountConfiguration& operator=(const Asibfm700MountConfiguration&) = default;
    Asibfm700MountConfiguration& operator=(Asibfm700MountConfiguration&&) = default;

    std::error_code load(const std::filesystem::path& path)
    {
        std::string buffer;

        std::error_code ec;
        auto sz = std::filesystem::file_size(path, ec);

        if (!ec && sz) {
            std::ifstream fst(path);

            try {
                buffer.resize(sz);

                fst.read(buffer.data(), sz);

                fst.close();

                // remove possible header (see "save" method)
                size_t nskip = headerLines;
                if (!std::regex_match(buffer, headerRx)) {
                    nskip = 0;
                }
                ec = base_t::fromCharRange(buffer, nskip);
                if (!ec) {
                    // remove possible spaces in filenames

                    std::string val = getValue<std::string>("leapSecondFilename").value_or("");
                    auto fname = mcc::utils::trimSpaces(val);
                    setValue("leapSecondFilename", fname);


                    val = getValue<std::string>("bulletinAFilename").value_or("");
                    fname = mcc::utils::trimSpaces(val);
                    setValue("bulletinAFilename", fname);

                    val = getValue<std::string>("MountDevPath").value_or(std::string{});
                    fname = mcc::utils::trimSpaces(val);
                    setValue("MountDevPath", fname);

                    val = getValue<std::string>("EncoderDevPath").value_or(std::string{});
                    fname = mcc::utils::trimSpaces(val);
                    setValue("EncoderDevPath", fname);

                    val = getValue<std::string>("EncoderXDevPath").value_or(std::string{});
                    fname = mcc::utils::trimSpaces(val);
                    setValue("EncoderXDevPath", fname);

                    val = getValue<std::string>("EncoderYDevPath").value_or(std::string{});
                    fname = mcc::utils::trimSpaces(val);
                    setValue("EncoderYDevPath", fname);

                    val = getValue<std::string>("slewingPathFilename").value_or(std::string{});
                    fname = mcc::utils::trimSpaces(val);
                    setValue("slewingPathFilename", fname);

                    val = getValue<std::string>("trackingPathFilename").value_or(std::string{});
                    fname = mcc::utils::trimSpaces(val);
                    setValue("trackingPathFilename", fname);
                }
            } catch (std::ios_base::failure const& ex) {
                ec = ex.code();
            } catch (std::length_error const& ex) {
                ec = std::make_error_code(std::errc::no_buffer_space);
            } catch (std::bad_alloc const& ex) {
                ec = std::make_error_code(std::errc::not_enough_memory);
            } catch (...) {
                ec = std::make_error_code(std::errc::operation_canceled);
            }

            _lastConfigPath = path;
        }

        return ec;
    }

    std::error_code reloadCurrentConfig()
    {
        return load(_lastConfigPath);
    }


    std::error_code save(const std::filesystem::path& path)
    {
        std::error_code ec;
        std::string buff;

        ec = toCharRange(buff);
        if (ec) {
            return ec;
        }

        std::ofstream fst(path, std::ios_base::trunc);
        if (!fst.is_open()) {
            ec = std::make_error_code(std::errc::io_error);
        } else {
            try {
                fst << generateHeader();
                fst << buff;
            } catch (std::ios_base::failure const& ex) {
                ec = ex.code();
            } catch (...) {
                ec = std::make_error_code(std::errc::operation_canceled);
            }
        }

        return ec;
    }

    std::error_code save()
    {
        return save(_lastConfigPath);
    }

    std::error_code dumpDefaultsToFile(const std::filesystem::path& path)
    {
        std::error_code ec{};
        std::string output_buffer;

#ifdef __GNUG__
// to fix GCC compilation crash for the versions < 16
#if GCC_VERSION < 160000
        auto write_rec = [&output_buffer, &ec, obj_ptr = this]<size_t I = 0>(this auto& self) -> void {
#else
        auto write_rec = [&output_buffer, &ec, this]<size_t I = 0>(this auto& self) -> void {
#endif
#endif
            if constexpr (I < NUMBER_OF_RECORDS) {
                // add an empty string within records
                std::format_to(std::back_inserter(output_buffer), "{}", DEFAULT_RECORD_DELIMITER);

#ifdef __GNUG__
// to fix GCC compilation crash for the versions < 16
#if GCC_VERSION < 160000
                ec = obj_ptr->template formatRecord<I>(output_buffer, DEFAULT_RECORD_DELIMITER, true);
#else
                ec = formatRecord<I>(output_buffer, DEFAULT_RECORD_DELIMITER, true);
#endif
#endif
                if (ec) {
                    return;
                }


                self.template operator()<I + 1>();
            }
        };

        write_rec();

        // [&output_buffer, &ec, this]<size_t... Is>(std::index_sequence<Is...>) {
        //     ((std::format_to(std::back_inserter(output_buffer), "{}", DEFAULT_RECORD_DELIMITER),
        //       ec = formatRecord<Is>(output_buffer, DEFAULT_RECORD_DELIMITER, true)),
        //      ...);
        // }(std::make_index_sequence<NUMBER_OF_RECORDS>());

        if (!ec) {
            std::ofstream fst(path, std::ios_base::trunc);
            if (!fst.is_open()) {
                ec = std::make_error_code(std::errc::io_error);
            } else {
                try {
                    fst << generateHeader();
                    fst << output_buffer;
                } catch (std::ios_base::failure const& ex) {
                    ec = ex.code();
                } catch (...) {
                    ec = std::make_error_code(std::errc::operation_canceled);
                }
            }
        }

        return ec;
    }


    std::filesystem::path configFilename() const
    {
        return _lastConfigPath;
    }


    /*  some most often used quantities  */

    template <mcc::mcc_angle_c T>
    T siteLatitude() const
    {
        return static_cast<double>(getValue<mcc::impl::MccAngle>("siteLatitude").value_or(mcc::impl::MccAngle{}));
    };

    mcc::impl::MccAngle siteLatitude() const
    {
        return siteLatitude<mcc::impl::MccAngle>();
    };

    template <mcc::mcc_angle_c T>
    T siteLongitude() const
    {
        return static_cast<double>(getValue<mcc::impl::MccAngle>("siteLongitude").value_or(mcc::impl::MccAngle{}));
    };

    mcc::impl::MccAngle siteLongitude() const
    {
        return siteLongitude<mcc::impl::MccAngle>();
    };

    template <typename T>
    T siteElevation() const
        requires std::is_arithmetic_v<T>
    {
        return getValue<double>("siteElevation").value_or(0.0);
    }

    double siteElevation() const
    {
        return getValue<double>("siteElevation").value_or(0.0);
    };

    template <typename T>
    T refractWavelength() const
        requires std::is_arithmetic_v<T>
    {
        return getValue<double>("refractWavelength").value_or(0.0);
    }

    double refractWavelength() const
    {
        return getValue<double>("refractWavelength").value_or(0.0);
    };

    template <mcc::traits::mcc_output_char_range R>
    R leapSecondFilename() const
    {
        R r;

        std::string val = getValue<std::string>("leapSecondFilename").value_or("");
        std::ranges::copy(val, std::back_inserter(r));

        return r;
    }

    std::string leapSecondFilename() const
    {
        return leapSecondFilename<std::string>();
    };

    template <mcc::traits::mcc_output_char_range R>
    R bulletinAFilename() const
    {
        R r;
        std::string val = getValue<std::string>("bulletinAFilename").value_or("");
        std::ranges::copy(val, std::back_inserter(r));

        return r;
    }

    std::string bulletinAFilename() const
    {
        return bulletinAFilename<std::string>();
    };

    AsibFM700ServoController::hardware_config_t servoControllerConfig() const
    {
        AsibFM700ServoController::hardware_config_t hw_cfg;

        hw_cfg.hwConfig = {};

        hw_cfg.pollingInterval =
            getValue<std::chrono::milliseconds>("hardwarePollingPeriod").value_or(std::chrono::milliseconds(300));

        hw_cfg.pollingInterval =
            getValue<std::chrono::milliseconds>("hardwarePollingTimeout").value_or(std::chrono::milliseconds(30000));

        hw_cfg.MountDevPath = getValue<std::string>("MountDevPath").value_or(std::string{});
        hw_cfg.EncoderDevPath = getValue<std::string>("EncoderDevPath").value_or(std::string{});
        hw_cfg.EncoderXDevPath = getValue<std::string>("EncoderXDevPath").value_or(std::string{});
        hw_cfg.EncoderYDevPath = getValue<std::string>("EncoderYDevPath").value_or(std::string{});

        hw_cfg.devConfig.MountDevPath = hw_cfg.MountDevPath.data();
        hw_cfg.devConfig.EncoderDevPath = hw_cfg.EncoderDevPath.data();
        hw_cfg.devConfig.EncoderXDevPath = hw_cfg.EncoderXDevPath.data();
        hw_cfg.devConfig.EncoderYDevPath = hw_cfg.EncoderYDevPath.data();

        hw_cfg.devConfig.RunModel = getValue<int>("RunModel").value_or(int{});
        hw_cfg.devConfig.MountDevSpeed = getValue<int>("MountDevSpeed").value_or(int{});
        hw_cfg.devConfig.EncoderDevSpeed = getValue<int>("EncoderDevSpeed").value_or(int{});
        hw_cfg.devConfig.SepEncoder = getValue<int>("SepEncoder").value_or(int{});

        std::chrono::duration<double> secs;  // seconds as floating-point

        secs = getValue<std::chrono::milliseconds>("MountReqInterval").value_or(std::chrono::milliseconds{});
        hw_cfg.devConfig.MountReqInterval = secs.count();

        secs = getValue<std::chrono::milliseconds>("EncoderReqInterval").value_or(std::chrono::milliseconds{});
        hw_cfg.devConfig.EncoderReqInterval = secs.count();

        secs = getValue<std::chrono::milliseconds>("EncoderSpeedInterval").value_or(std::chrono::milliseconds{});
        hw_cfg.devConfig.EncoderSpeedInterval = secs.count();

        secs = getValue<std::chrono::milliseconds>("PIDMaxDt").value_or(std::chrono::milliseconds{1000});
        hw_cfg.devConfig.PIDMaxDt = secs.count();

        secs = getValue<std::chrono::milliseconds>("PIDRefreshDt").value_or(std::chrono::milliseconds{100});
        hw_cfg.devConfig.PIDRefreshDt = secs.count();

        secs = getValue<std::chrono::milliseconds>("PIDCycleDt").value_or(std::chrono::milliseconds{5000});
        hw_cfg.devConfig.PIDCycleDt = secs.count();


        std::vector<double> pid = getValue<std::vector<double>>("XPIDV").value_or(std::vector<double>{});
        if (pid.size() > 2) {
            hw_cfg.devConfig.XPIDV.P = pid[0];
            hw_cfg.devConfig.XPIDV.I = pid[1];
            hw_cfg.devConfig.XPIDV.D = pid[2];
        }

        pid = getValue<std::vector<double>>("YPIDV").value_or(std::vector<double>{});
        if (pid.size() > 2) {
            hw_cfg.devConfig.YPIDV.P = pid[0];
            hw_cfg.devConfig.YPIDV.I = pid[1];
            hw_cfg.devConfig.YPIDV.D = pid[2];
        }

        double ang = getValue<mcc::impl::MccAngle>("MaxPointingErr").value_or(mcc::impl::MccAngle(8.0_degs));
        hw_cfg.devConfig.MaxPointingErr = ang;

        ang = getValue<mcc::impl::MccAngle>("MaxFinePointingErr").value_or(mcc::impl::MccAngle(1.5_degs));
        hw_cfg.devConfig.MaxFinePointingErr = ang;

        ang = getValue<mcc::impl::MccAngle>("MaxGuidingErr").value_or(mcc::impl::MccAngle(0.5_arcsecs));
        hw_cfg.devConfig.MaxGuidingErr = ang;

        ang = getValue<int64_t>("XEncZero").value_or(0);
        hw_cfg.devConfig.XEncZero = ang;


        ang = getValue<int64_t>("YEncZero").value_or(0);
        hw_cfg.devConfig.YEncZero = ang;



        return hw_cfg;
    }


    Asibfm700PCM::pcm_data_t pcmData() const
    {
        Asibfm700PCM::pcm_data_t pcm_data;

        std::vector<double> empty_vec;

        pcm_data.type = getValue<decltype(pcm_data.type)>("pcmType").value_or(pcm_data.type);

        pcm_data.siteLatitude = getValue<mcc::impl::MccAngle>("siteLatitude").value_or(pcm_data.siteLatitude);

        std::vector<double> vec = getValue<std::vector<double>>("pcmGeomCoeffs").value_or(empty_vec);
        if (vec.size() >= 9) {  // must be 9 coefficients
            pcm_data.geomCoefficients = {.zeroPointX = vec[0],
                                         .zeroPointY = vec[1],
                                         .collimationErr = vec[2],
                                         .nonperpendErr = vec[3],
                                         .misalignErr1 = vec[4],
                                         .misalignErr2 = vec[5],
                                         .tubeFlexure = vec[6],
                                         .DECaxisFlexure = vec[7],
                                         .forkFlexure = vec[8]};
        }

#ifdef USE_BSPLINE_PCM
        // std::vector<size_t> dd = getValue<decltype(dd)>("pcmBsplineDegree").value_or(dd);
        // if (dd.size() >= 2) {
        //     pcm_data.bspline.bsplDegreeX = dd[0] > 0 ? dd[0] : 3;
        //     pcm_data.bspline.bsplDegreeY = dd[1] > 0 ? dd[1] : 3;
        // }

        vec = getValue<std::vector<double>>("pcmBsplineXknots").value_or(empty_vec);
        // pid must contains interior and border (single point for each border) knots so minimal length must be 2
        if (vec.size() >= 2) {
            // generate full knots array (with border knots)
            size_t Nknots = vec.size() + pcm_data.bspline.bsplDegreeX * 2 - 2;
            pcm_data.bspline.knotsX.resize(Nknots);

            for (size_t i = 0; i <= pcm_data.bspline.bsplDegreeX; ++i) {  // border knots
                pcm_data.bspline.knotsX[i] = vec[0];
                pcm_data.bspline.knotsX[Nknots - i - 1] = vec.back();
            }
            for (size_t i = 0; i < (vec.size() - 2); ++i) {  // interior knots
                pcm_data.bspline.knotsX[i + pcm_data.bspline.bsplDegreeX] = vec[1 + i];
            }
        }

        vec = getValue<std::vector<double>>("pcmBsplineYknots").value_or(empty_vec);
        // pid must contains interior and border (single point for each border) knots so minimal length must be 2
        if (vec.size() >= 2) {
            // generate full knots array (with border knots)
            size_t Nknots = vec.size() + pcm_data.bspline.bsplDegreeY * 2 - 2;
            pcm_data.bspline.knotsY.resize(Nknots);

            for (size_t i = 0; i <= pcm_data.bspline.bsplDegreeY; ++i) {  // border knots
                pcm_data.bspline.knotsY[i] = vec[0];
                pcm_data.bspline.knotsY[Nknots - i - 1] = vec.back();
            }
            for (size_t i = 0; i < (vec.size() - 2); ++i) {  // interior knots
                pcm_data.bspline.knotsY[i + pcm_data.bspline.bsplDegreeY] = vec[1 + i];
            }
        }

        // minimal allowed number of B-spline coefficients
        size_t Ncoeffs = pcm_data.type == mcc::impl::MccDefaultPCMType::PCM_TYPE_GEOMETRY
                             ? 0
                             : (pcm_data.bspline.knotsX.size() - pcm_data.bspline.bsplDegreeX - 1) *
                                   (pcm_data.bspline.knotsY.size() - pcm_data.bspline.bsplDegreeY - 1);

        vec = getValue<std::vector<double>>("pcmBsplineXcoeffs").value_or(empty_vec);

        if (vec.size() >= Ncoeffs) {
            pcm_data.bspline.coeffsX.clear();
            std::ranges::copy_n(vec.begin(), Ncoeffs, std::back_inserter(pcm_data.bspline.coeffsX));
            // pcm_data.bspline.coeffsX.resize(Ncoeffs);
            // for (size_t i = 0; i < Ncoeffs; ++i) {
            //     pcm_data.bspline.coeffsX[i] = vec[i];
            // }
        }

        vec = getValue<std::vector<double>>("pcmBsplineYcoeffs").value_or(empty_vec);

        if (vec.size() >= Ncoeffs) {
            pcm_data.bspline.coeffsY.clear();
            std::ranges::copy_n(vec.begin(), Ncoeffs, std::back_inserter(pcm_data.bspline.coeffsY));
            // pcm_data.bspline.coeffsY.resize(Ncoeffs);
            // for (size_t i = 0; i < Ncoeffs; ++i) {
            //     pcm_data.bspline.coeffsY[i] = vec[i];
            // }
        }

        vec = getValue<std::vector<double>>("pcmInverseBsplineXcoeffs").value_or(empty_vec);

        if (vec.size() >= Ncoeffs) {
            pcm_data.bspline.inverseCoeffsX.clear();
            std::ranges::copy_n(vec.begin(), Ncoeffs, std::back_inserter(pcm_data.bspline.inverseCoeffsX));
        }

        vec = getValue<std::vector<double>>("pcmInverseBsplineYcoeffs").value_or(empty_vec);

        if (vec.size() >= Ncoeffs) {
            pcm_data.bspline.inverseCoeffsY.clear();
            std::ranges::copy_n(vec.begin(), Ncoeffs, std::back_inserter(pcm_data.bspline.inverseCoeffsY));
        }
#endif
        return pcm_data;
    }


    mcc::impl::MccAltLimitPZ<mcc::impl::MccAltLimitKind::MIN_ALT_LIMIT> minAltPZone()
    {
        return getValue<mcc::impl::MccAltLimitPZ<mcc::impl::MccAltLimitKind::MIN_ALT_LIMIT>>("altLimPZ")
            .value_or(mcc::impl::MccAltLimitPZ<mcc::impl::MccAltLimitKind::MIN_ALT_LIMIT>{10.0, SAORAS_LATITUDE});
    }


    mcc::impl::MccAxisLimitSwitchPZ<mcc::impl::MccCoordKind::COORDS_KIND_HA_OBS> axisLimitSwitchHA()
    {
        return getValue<mcc::impl::MccAxisLimitSwitchPZ<mcc::impl::MccCoordKind::COORDS_KIND_HA_OBS>>(
                   "axisLimitSwitchHA")
            .value_or(mcc::impl::MccAxisLimitSwitchPZ<mcc::impl::MccCoordKind::COORDS_KIND_HA_OBS>{
                -170.0_degs, 170.0_degs, nullptr});
    }

    mcc::impl::MccAxisLimitSwitchPZ<mcc::impl::MccCoordKind::COORDS_KIND_DEC_OBS> axisLimitSwitchDEC()
    {
        return getValue<mcc::impl::MccAxisLimitSwitchPZ<mcc::impl::MccCoordKind::COORDS_KIND_DEC_OBS>>(
                   "axisLimitSwitchDEC")
            .value_or(mcc::impl::MccAxisLimitSwitchPZ<mcc::impl::MccCoordKind::COORDS_KIND_DEC_OBS>{
                -90.0_degs, 90.0_degs, nullptr});
    }


    details::movement_pars_t movingModelParams() const
    {
        details::movement_pars_t pars;

        auto get_value = [this]<typename VT>(std::string_view name, VT& val) {
            val = getValue<VT>(name).value_or(val);
        };

        pars.telemetryTimeout =
            getValue<decltype(pars.telemetryTimeout)>("telemetryTimeout").value_or(pars.telemetryTimeout);

        pars.minTimeToPZone = getValue<decltype(pars.minTimeToPZone)>("minTimeToPZone").value_or(pars.minTimeToPZone);


        pars.slewToleranceRadius =
            getValue<decltype(pars.slewToleranceRadius)>("slewToleranceRadius").value_or(pars.slewToleranceRadius) *
            mcc::MCC_ARCSECS_TO_RADS;

        get_value("slewingTelemetryInterval", pars.slewingTelemetryInterval);

        pars.slewRateX = getValue<decltype(pars.slewRateX)>("hwMaxRateHA").value_or(pars.slewRateX);
        pars.slewRateY = getValue<decltype(pars.slewRateY)>("hwMaxRateDEC").value_or(pars.slewRateY);

        pars.adjustCoordDiff =
            getValue<decltype(pars.adjustCoordDiff)>("adjustCoordDiff").value_or(pars.adjustCoordDiff) *
            mcc::MCC_DEGRESS_TO_RADS;

        pars.slewTimeout = getValue<decltype(pars.slewTimeout)>("slewTimeout").value_or(pars.slewTimeout);

        pars.slewingPathFilename =
            getValue<decltype(pars.slewingPathFilename)>("slewingPathFilename").value_or(std::string());

        get_value("trackingTelemetryInterval", pars.trackingTelemetryInterval);


        pars.trackingCycleInterval = getValue<decltype(pars.trackingCycleInterval)>("trackingCycleInterval")
                                         .value_or(pars.trackingCycleInterval);

        pars.trackingMaxCoordDiff =
            getValue<decltype(pars.trackingMaxCoordDiff)>("trackingMaxCoordDiff").value_or(pars.trackingMaxCoordDiff) *
            mcc::MCC_ARCSECS_TO_RADS;

        pars.trackingPathFilename =
            getValue<decltype(pars.trackingPathFilename)>("trackingPathFilename").value_or(std::string());

        return pars;
    }

private:
    std::filesystem::path _lastConfigPath{};

    static constexpr size_t headerLines = 5;  // number of lines in the header

    static std::string generateHeader()
    {
        std::string s{
            "#\n"
            "# ASTROSIB FM-700 MOUNT CONFIGURATION\n"
            "#\n"};

        std::format_to(
            std::back_inserter(s), "# (created at {:%FT%T} UTC)\n#\n",
            std::chrono::round<std::chrono::duration<int64_t, std::ratio<1, 10>>>(std::chrono::system_clock::now()));

        // auto time_stamp =
        //     std::chrono::round<std::chrono::duration<int64_t, std::ratio<1, 10>>>(std::chrono::system_clock::now());
        // std::string s = std::format(
        //     "{0:}{1:}{0:} ASTROSIB FM-700 MOUNT CONFIGURATION{1:}{0:}{1:}{0:} (created at {2:%FT%T}
        //     UTC){1:}{0:}{1:}", COMMENT_SEQ, rec_delim, time_stamp);

        return s;
    }

    // regex for buffer started with standard header
    inline static const std::regex headerRx{
        "^[ \\n]*"
        "# *\\n"
        "# *ASTROSIB FM-700 MOUNT CONFIGURATION *\\n"
        "# *\\n"
        "# *\\(created at 20[0-9][0-9]-[0-9][0-9]-[0-9][0-9]T[0-9][0-9]:[0-9][0-9]:[0-9][0-9]\\.[0-9] UTC\\) *\\n"
        "# *\\n"
        "[\\s\\S]*"};
};

}  // namespace asibfm700