#pragma once

#include <optional>
#include <string>
#include <string_view>
#include <vector>

#include "peary/config/configuration.hpp"

#include "Device.hpp"

namespace peary::device {

    template <typename T> class AuxiliaryDevice : public Device {

    public:
        template <typename... Args>
        AuxiliaryDevice(std::string_view name, const config::Configuration& config, Args&&... args);

        virtual ~AuxiliaryDevice();

        std::string getType() override;

        virtual std::string getFirmwareVersion() override { return std::string(); };

        std::optional<utils::pearyRawData> getRawData() override;

        std::optional<utils::pearyRawDataVector> getRawData(const unsigned int noFrames) override;

        std::optional<utils::pearydata> getData() override;

        std::optional<utils::pearydataVector> getData(const unsigned int noFrames) override;

        virtual void powerOn() override {};

        virtual void powerOff() override {};

        virtual void daqStart() override {};

        virtual void daqStop() override {};

        virtual void setRegister(const std::string&, uintptr_t) override {};

        virtual uintptr_t getRegister(const std::string&) override { return uintptr_t(); };

        virtual bool hasRegister(const std::string&) const override { return false; }

        virtual std::vector<std::pair<std::string, uintptr_t>> getRegisters() override {
            return std::vector<std::pair<std::string, uintptr_t>>();
        };

        virtual std::vector<std::string> listMemories() override { return std::vector<std::string>(); }

        virtual std::vector<std::string> listRegisters() override { return std::vector<std::string>(); }

        virtual std::vector<std::pair<std::string, std::string>> listResources() override {
            return std::vector<std::pair<std::string, std::string>>();
        };

        virtual void configureClock(const std::string&, const std::any&) override {};

        virtual void disableClock(const std::string&) override {};

        virtual bool isClockLocked(const std::string&) override { return bool(); };

        virtual void setClockFrequency(const std::string&, uint64_t) override {};

        virtual void setVoltage(const std::string&, double) override {};

        virtual void setCurrentLimit(const std::string&, double) override {};

        virtual void setCurrent(const std::string&, double, utils::Polarity) override {};

        virtual void switchOn(const std::string&) override {};

        virtual void switchOff(const std::string&) override {};

        virtual double getVoltage(const std::string&) override { return double(); };

        virtual double getCurrent(const std::string&) override { return double(); };

        virtual double getPower(const std::string&) override { return double(); };

        virtual void configure() override {};

        virtual void set(std::string, uintptr_t) {};

        virtual double get(std::string) { return double(); };

        virtual void reset() override {};

        virtual void setMemory(const std::string&, size_t, uintptr_t) override {};

        virtual void setMemory(const std::string&, uintptr_t) override {};

        virtual uintptr_t getMemory(const std::string&, size_t) override { return uintptr_t(); };

        virtual uintptr_t getMemory(const std::string&) override { return uintptr_t(); };

        virtual std::vector<std::pair<std::string, uintptr_t>> getMemories() override {
            return std::vector<std::pair<std::string, uintptr_t>>();
        };

        bool hasMemory(const std::string&) const override { return false; };

    protected:
        typename T::data_t send(const typename T::data_t& data);

        std::vector<typename T::data_t> send(const std::vector<typename T::data_t>& data);

        std::pair<typename T::reg_t, typename T::data_t> send(const std::pair<typename T::reg_t, typename T::data_t>& data);

        std::vector<typename T::data_t> send(const typename T::reg_t& reg, const std::vector<typename T::data_t>& data);

        std::vector<std::pair<typename T::reg_t, typename T::data_t>>
        send(const std::vector<std::pair<typename T::reg_t, typename T::data_t>>& data);

        typename T::vector_t receive(const unsigned int length = 1);

        typename T::vector_t receive(const typename T::reg_t reg, const unsigned int length = 1);

        config::Configuration _config;

        T _interface;
    }; // class AuxiliaryDevice

} // namespace peary::device

#include "AuxiliaryDevice.tcc"