#pragma once

#include <any>
#include <cstdint>
#include <filesystem>
#include <optional>
#include <string>
#include <string_view>
#include <vector>

#include "peary/config/configuration.hpp"
#include "peary/device/exceptions.hpp"
#include "peary/utils/constants.hpp"
#include "peary/utils/datatypes.hpp"
#include "peary/utils/dispatcher.hpp"

namespace peary::device {

    class Device {

    public:
        explicit Device(std::string_view name, const config::Configuration&);

        virtual ~Device();

        bool isManaged() { return managedDevice; };

        std::string getVersion();

        virtual std::string getFirmwareVersion() = 0;

        std::string getName() { return name_; };

        virtual std::string getType() = 0;

        virtual void powerOn() = 0;

        virtual void powerOff() = 0;

        virtual void daqStart() = 0;

        virtual void daqStop() = 0;

        virtual std::optional<utils::pearyRawData> getRawData() = 0;

        virtual std::optional<utils::pearyRawDataVector> getRawData(const unsigned int noFrames) = 0;

        virtual std::optional<utils::pearydata> getData() = 0;

        virtual std::optional<utils::pearydataVector> getData(const unsigned int noFrames) = 0;

        virtual void configure() = 0;

        virtual void setRegister(const std::string& name, uintptr_t value) = 0;

        virtual uintptr_t getRegister(const std::string& name) = 0;

        virtual std::vector<std::pair<std::string, uintptr_t>> getRegisters() = 0;

        virtual bool hasRegister(const std::string& name) const = 0;

        virtual void reset() = 0;

        virtual void setVoltage(const std::string& name, double voltage) = 0;

        virtual void setCurrentLimit(const std::string& name, double current_limit) = 0;

        virtual void switchOn(const std::string& name) = 0;

        virtual void switchOff(const std::string& name) = 0;

        virtual void setCurrent(const std::string& name, double current, utils::Polarity polarity) = 0;

        virtual double getVoltage(const std::string& name) = 0;

        virtual double getCurrent(const std::string& name) = 0;

        virtual double getPower(const std::string& name) = 0;

        virtual void configureClock(const std::string& name, const std::any& config) = 0;

        virtual void disableClock(const std::string& name) = 0;

        virtual bool isClockLocked(const std::string& name) = 0;

        virtual void setClockFrequency(const std::string& name, uint64_t frequency) = 0;

        virtual void setMemory(const std::string& name, size_t offset, uintptr_t value) = 0;

        virtual void setMemory(const std::string& name, uintptr_t value) = 0;

        virtual uintptr_t getMemory(const std::string& name, size_t offset) = 0;

        virtual uintptr_t getMemory(const std::string& name) = 0;

        virtual std::vector<std::pair<std::string, uintptr_t>> getMemories() = 0;

        virtual bool hasMemory(const std::string& name) const = 0;

        virtual std::vector<std::string> listMemories() = 0;

        virtual std::vector<std::string> listRegisters() = 0;

        virtual std::vector<std::pair<std::string, std::string>> listResources() = 0;

        std::vector<std::pair<std::string, std::size_t>> listCommands();

        std::string command(const std::string& name, const std::vector<std::string>& args = std::vector<std::string>());

        std::string command(const std::string& name, const std::string& arg);

    protected:
        utils::Dispatcher _dispatcher;

    private:
        static bool managedDevice;

        // Make the device manager a friend class to allow toggling the Device::managedDevice flag
        friend class DeviceManager;

        /* Device name */
        std::string name_;
    }; // class Device

} // namespace peary::device