#include <algorithm>
#include <iomanip>
#include <iostream>
#include <stdexcept>
#include <string>
#include <string_view>
#include <utility>
#include "adsData.h"

using namespace std::literals::string_view_literals;

std::ostream& operator<<(std::ostream& s, adsDatatypeId val) {
    static constexpr std::pair<adsDatatypeId, std::string_view> typenames[] =
    {
        { adsDatatypeId::void_,     "void"sv },
        { adsDatatypeId::int16_,    "int16"sv },
        { adsDatatypeId::int32_,    "int32"sv },
        { adsDatatypeId::float_,    "float"sv },
        { adsDatatypeId::double_,   "double"sv },
        { adsDatatypeId::int8_,     "int8"sv },
        { adsDatatypeId::uint8_,    "uint8"sv },
        { adsDatatypeId::uint16_,   "uint16"sv },
        { adsDatatypeId::uint32_,   "uint32"sv },
        { adsDatatypeId::int64_,    "int64"sv },
        { adsDatatypeId::uint64_,   "uint64"sv },
        { adsDatatypeId::cstring_,  "cstring"sv },
        { adsDatatypeId::wcstring_, "wcstring"sv },
        { adsDatatypeId::bool_,     "bool"sv },
        { adsDatatypeId::blob_,     "blob"sv },
    };
    auto it = std::lower_bound(std::begin(typenames), std::end(typenames), val,
        [](auto& x, auto& y) { return x.first < y; });
    if (it == std::end(typenames) || it->first != val)
        s << "unknown(" << static_cast<int>(val) << ')';
    else
        s << it->second << '(' << static_cast<int>(val) << ')';
    return s;
}

std::ostream& operator<<(std::ostream& s, const GUID& guid) {
    return s << std::uppercase << std::hex << std::setfill('0')
        << std::setw(8) << guid.Data1 << '-'
        << std::setw(4) << guid.Data2 << '-'
        << std::setw(4) << guid.Data3 << '-'
        << std::setw(2) << static_cast<short>(guid.Data4[0])
        << static_cast<short>(guid.Data4[1])
        << '-' << static_cast<short>(guid.Data4[2])
        << static_cast<short>(guid.Data4[3])
        << static_cast<short>(guid.Data4[4])
        << static_cast<short>(guid.Data4[5])
        << static_cast<short>(guid.Data4[6])
        << static_cast<short>(guid.Data4[7])
        << std::nouppercase << std::dec;
}

std::ostream& operator<<(std::ostream& s, const std::pair<std::string, std::string>& attr) {
    return s << attr.first << ": " << attr.second;
}

std::ostream& operator<<(std::ostream& s, const adsVarData& var) {
    s << std::boolalpha
        << "short: " << var.shortName() << '\n'
        << "type: " << var.type() << '\n'
        << "comment: " << var.comment() << '\n'
        << "typeId: " << var.typeId() << '\n'
        << "group: " << var.group() << '\n'
        << "offset: " << var.offset() << '\n'
        << "size: " << var.size() << '\n'
        << "is pointer: " << var.isPointer() << '\n'
        << "is static: " << var.isStatic() << '\n'
        << "copy mask: ";
    for (unsigned c : var.copyMask())
        s << "0x" << std::setw(2) << std::hex << c << ',';
    if (var.typeGuid())
        s << "\ntype GUID: " << *var.typeGuid();
    s << "\nattributes:\n";
    for (auto& attr : var.attributes())
        s << attr << '\n';
    s << "type attributes:\n";
    for (auto& attr : var.typeAttributes())
        s << attr << '\n';
    s << "type enums:\n";
    for (auto& e : var.typeEnums())
        s << e.first << ": " << e.valueToString() << '\n';
    return s;
}

void showSubs(const adsVarData& var, std::string prefix) {
    for (auto&& sub : var) {
        if (!sub.typeEnums().empty())
            std::cout << "name: " << sub.name(prefix) << '\n' << sub << '\n';
        showSubs(sub, sub.name(prefix));
    }
}

int main() {
    std::string varNames[] =
    {
        "MAIN.myInt",
    };
    try
    {
        adsData plcData{};
        for (auto&& var : plcData)
        {
            if (!var.typeEnums().empty())
                std::cout << var << '\n';
            showSubs(var, var.shortName());
        }
        for (auto& name : varNames)
        {
            try
            {
                std::cout << plcData[name] << '\n';
            }
            catch (std::out_of_range& e)
            {
                std::cout << e.what() << '\n';
            }
        }
    }
    catch (std::runtime_error& e)
    {
        std::cout << e.what() << '\n';
        return 1;
    }
}