#pragma once
#include "Device/PublicFunc.h"
#include <vector>
#include <Device/json.hpp>

using json = nlohmann::json;
using std::vector;
struct json_cast
{
    json_cast(json s) :m_json(s) { if (s.is_null()) throw std::bad_alloc(); }

    operator std::int16_t() {
        return oper<std::int16_t>();
    }
    operator std::int64_t() {
        return oper<std::int64_t>();
    }
    operator std::int8_t() {
        return oper<std::int8_t>();
    }
    operator int() {
        return oper<int>();
    }
    operator bool() {
        if (m_json.is_boolean() or m_json.is_number() or m_json.is_number_unsigned() or m_json.is_number_float())
            if (isbool())
                return m_json.get<bool>();
            else
                return (int)m_json;
        else
            throw std::bad_typeid();
    }
    operator std::uint16_t() {
        return oper<std::uint16_t>();
    }
    operator std::uint32_t() {
        return oper<std::uint32_t>();
    }
    operator std::uint8_t() {
        return oper<std::uint8_t>();
    }
    operator float() {
        return oper<float>();
    }
    operator std::string() {
        if (m_json.is_string())
            return m_json;
        else
            return m_json.dump();
    }
    operator double() {
        return oper<double>();
    }

    int to_int() { return operator int(); }
    std::uint32_t to_uint32() { return operator std::uint32_t(); }
    std::uint16_t to_uint16() { return operator std::uint16_t(); }
    std::uint8_t to_uint8() { return operator std::uint8_t(); }
    std::int16_t to_int16() { return operator std::int16_t(); }
    std::int32_t to_int32() { return operator std::int32_t(); }
    std::int8_t to_int8() { return operator std::int8_t(); }
    bool to_bool() { return operator bool(); }
    float to_float() { return operator float(); }
    double to_double() { return operator double(); }
    std::string to_string() { return operator std::string(); }
    bool isbool() { return m_json.is_boolean() ? 1 : 0; }
    template<typename T>
    auto oper()->T {
        if (m_json.is_boolean() or m_json.is_number() or m_json.is_number_unsigned() or m_json.is_number_float())
            if (isbool())
                return (T)m_json.get<bool>();
            else
                return T(m_json);
        else
            throw std::bad_typeid();
    }
private:
    json m_json;
};
class GscanJsonConfig
{
public:
	GscanJsonConfig();
	~GscanJsonConfig();
public:
	GScanCap GetDefaultGscancapValue();
	void SaveGscanCapConfig(const GScanCap& gcap, const std::string path);
	void WriteJsonArrayToFile(std::vector<GScanCap> cfgArray, const std::string filename);
	GScanCap  ReadGscanCap();
	std::vector<GScanCap> ReadGscanCapsVector(const std::string gcapsfilepath);	bool DeleteJsonFile(std::string path);

	std::vector<GScanCap> parseJsonFromString(const std::string str);


	json GscancapToJson(GScanCap& cap);
	json GetDefaultJson();
    json Readjson(std::string path);
	void SaveGscancapJson(GScanCap cap, std::string path);
	GScanCap JsonToGscancap(json& js);

};

class Twain_config
{
public:
    Twain_config();
    ~Twain_config();
    int getrollermsgdate();
    void setrollermsgdata(int value);
    void GetOrSetPintfCapability(int& value,bool is_get);
    void GetOrSetDoubleNames(std::vector<std::string>& v, bool is_get);

private:
    std::string GetTwainInIPath();
    json loadjson(std::string path);
    void savejson(json js, std::string path);
    json defaultjson();
    json m_json;
};