#pragma once

#include <string>
#include <vector>

#include "peary/config/configuration.hpp"
#include "peary/interfaces/Interface.hpp"
#include "peary/interfaces/InterfaceManager.hpp"

#include "Device.hpp"

namespace peary::device {

    template <typename T> class AuxiliaryDevice : public Device {

    public:
        AuxiliaryDevice(const config::Configuration config, const typename T::configuration_type interfaceConfig);

        virtual ~AuxiliaryDevice();

        virtual std::string getName() override { return getType(); };

        std::string getType() override;

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

        utils::pearyRawData getRawData() override;

        utils::pearyRawDataVector getRawData(const unsigned int noFrames) override;

        utils::pearydata getData() override;

        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(std::string, uintptr_t) override {};

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

        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>>();
        };

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

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

        std::pair<typename T::reg_type, typename T::data_type>
        send(const std::pair<typename T::reg_type, typename T::data_type>& data);

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

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

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

        typename T::dataVector_type receive(const typename T::reg_type reg, const unsigned int length = 1);

        config::Configuration _config;

        const typename T::configuration_type _interfaceConfig;
    }; // class AuxiliaryDevice

} // namespace peary::device

#include "AuxiliaryDevice.tcc"