#define LOG_TAG "com.android.apex"
#include "com_android_apex.h"

#include <assert.h>
#ifndef __BIONIC__
#define __assert2(f,n,fun,e) do { fprintf(stderr, "%s:%d: %s: Assertion `%s' failed", (f), (n), (fun), (e)); abort(); } while (false)
#endif
#define _xsdc_assert(e) do if (!(e)) __assert2(__FILE__, __LINE__, __PRETTY_FUNCTION__, #e); while (false)

namespace com {
    namespace android {
        namespace apex {
            template <class T>
            constexpr void (*xmlDeleter)(T* t);
            template <>
            constexpr auto xmlDeleter<xmlDoc> = xmlFreeDoc;
            template <>
            auto xmlDeleter<xmlChar> = [](xmlChar *s) { xmlFree(s); };

            template <class T>
            constexpr auto make_xmlUnique(T *t) {
                auto deleter = [](T *t) { xmlDeleter<T>(t); };
                return std::unique_ptr<T, decltype(deleter)>{t, deleter};
            }

            static std::string getXmlAttribute(const xmlNode *cur, const char *attribute) {
                auto xmlValue = make_xmlUnique(xmlGetProp(cur, reinterpret_cast<const xmlChar*>(attribute)));
                if (xmlValue == nullptr) {
                    return "";
                }
                std::string value(reinterpret_cast<const char*>(xmlValue.get()));
                return value;
            }

            std::optional<ApexInfoList> readApexInfoList(const char* configFile) {
                auto doc = make_xmlUnique(xmlParseFile(configFile));
                if (doc == nullptr) {
                    return std::nullopt;
                }
                xmlNodePtr _child = xmlDocGetRootElement(doc.get());
                if (_child == nullptr) {
                    return std::nullopt;
                }
                if (xmlXIncludeProcess(doc.get()) < 0) {
                    return std::nullopt;
                }

                if (!xmlStrcmp(_child->name, reinterpret_cast<const xmlChar*>("apex-info-list"))) {
                    ApexInfoList _value = ApexInfoList::read(_child);
                    return _value;
                }
                return std::nullopt;
            }

            std::optional<ApexInfoList> parseApexInfoList(const char* xml) {
                auto doc = make_xmlUnique(xmlParseDoc(reinterpret_cast<const xmlChar*>(xml)));
                if (doc == nullptr) {
                    return std::nullopt;
                }
                xmlNodePtr _child = xmlDocGetRootElement(doc.get());
                if (_child == nullptr) {
                    return std::nullopt;
                }
                if (xmlXIncludeProcess(doc.get()) < 0) {
                    return std::nullopt;
                }

                if (!xmlStrcmp(_child->name, reinterpret_cast<const xmlChar*>("apex-info-list"))) {
                    ApexInfoList _value = ApexInfoList::read(_child);
                    return _value;
                }
                return std::nullopt;
            }

            void write(std::ostream& _out, const ApexInfoList& apexInfoList) {
                _out << "<?xml version=\"1.0\" encoding=\"utf-8\"?>\n";
                apexInfoList.write(_out, "apex-info-list");
            }

            static int indentIndex = 0;
            std::string printIndent() {
                std::string s = "";
                for (int index = 0; index < indentIndex; ++index) {
                    s += "    ";
                }
                return s;
            }


            ApexInfoList::ApexInfoList(std::vector<ApexInfo> apexInfo) : apexInfo_(std::move(apexInfo)) {
            }

            const std::vector<ApexInfo>& ApexInfoList::getApexInfo() const {
                return apexInfo_;
            }

            bool ApexInfoList::hasApexInfo() const {
                return !(apexInfo_.empty());
            }

            const ApexInfo* ApexInfoList::getFirstApexInfo() const {
                if (apexInfo_.empty()) {
                    return nullptr;
                }
                return &apexInfo_[0];
            }

            ApexInfoList ApexInfoList::read(xmlNode *root) {
                std::string _raw;
                std::vector<ApexInfo> apexInfo;
                for (auto *_child = root->xmlChildrenNode; _child != nullptr; _child = _child->next) {
                    if (!xmlStrcmp(_child->name, reinterpret_cast<const xmlChar*>("apex-info"))) {
                        ApexInfo _value = ApexInfo::read(_child);
                        apexInfo.push_back(std::move(_value));
                    }
                }
                ApexInfoList instance(apexInfo);
                return instance;
            }

            void ApexInfoList::write(std::ostream& _out, const std::string& _name) const {
                _out << printIndent() << "<" << _name;
                _out << ">" << std::endl;
                ++indentIndex;
                for (auto& _value : getApexInfo()) {
                    _value.write(_out, "apex-info");
                }
                --indentIndex;
                _out << printIndent() << "</" << _name << ">" << std::endl;
            }

            ApexInfo::ApexInfo(std::string moduleName, std::string modulePath, std::optional<std::string> preinstalledModulePath, int64_t versionCode, std::string versionName, bool isFactory, bool isActive, std::optional<int64_t> lastUpdateMillis, bool provideSharedApexLibs) : moduleName_(std::move(moduleName)), modulePath_(std::move(modulePath)), preinstalledModulePath_(std::move(preinstalledModulePath)), versionCode_(versionCode), versionName_(std::move(versionName)), isFactory_(isFactory), isActive_(isActive), lastUpdateMillis_(lastUpdateMillis), provideSharedApexLibs_(provideSharedApexLibs) {
            }

            const std::string& ApexInfo::getModuleName() const {
                return moduleName_;
            }

            bool ApexInfo::hasModuleName() const {
                return true;
            }

            const std::string& ApexInfo::getModulePath() const {
                return modulePath_;
            }

            bool ApexInfo::hasModulePath() const {
                return true;
            }

            const std::string& ApexInfo::getPreinstalledModulePath() const {
                _xsdc_assert(hasPreinstalledModulePath());
                return preinstalledModulePath_.value();
            }

            bool ApexInfo::hasPreinstalledModulePath() const {
                return preinstalledModulePath_.has_value();
            }

            const int64_t& ApexInfo::getVersionCode() const {
                return versionCode_;
            }

            bool ApexInfo::hasVersionCode() const {
                return true;
            }

            const std::string& ApexInfo::getVersionName() const {
                return versionName_;
            }

            bool ApexInfo::hasVersionName() const {
                return true;
            }

            const bool& ApexInfo::getIsFactory() const {
                return isFactory_;
            }

            bool ApexInfo::hasIsFactory() const {
                return true;
            }

            const bool& ApexInfo::getIsActive() const {
                return isActive_;
            }

            bool ApexInfo::hasIsActive() const {
                return true;
            }

            const int64_t& ApexInfo::getLastUpdateMillis() const {
                _xsdc_assert(hasLastUpdateMillis());
                return lastUpdateMillis_.value();
            }

            bool ApexInfo::hasLastUpdateMillis() const {
                return lastUpdateMillis_.has_value();
            }

            const bool& ApexInfo::getProvideSharedApexLibs() const {
                return provideSharedApexLibs_;
            }

            bool ApexInfo::hasProvideSharedApexLibs() const {
                return true;
            }

            ApexInfo ApexInfo::read(xmlNode *root) {
                std::string _raw;
                _raw = getXmlAttribute(root, "moduleName");
                std::string moduleName{};
                if (_raw != "") {
                    std::string &_value = _raw;
                    moduleName = _value;
                }
                _raw = getXmlAttribute(root, "modulePath");
                std::string modulePath{};
                if (_raw != "") {
                    std::string &_value = _raw;
                    modulePath = _value;
                }
                _raw = getXmlAttribute(root, "preinstalledModulePath");
                std::optional<std::string> preinstalledModulePath = std::nullopt;
                if (_raw != "") {
                    std::string &_value = _raw;
                    preinstalledModulePath = _value;
                }
                _raw = getXmlAttribute(root, "versionCode");
                int64_t versionCode{};
                if (_raw != "") {
                    int64_t _value = std::stoll(_raw);
                    versionCode = _value;
                }
                _raw = getXmlAttribute(root, "versionName");
                std::string versionName{};
                if (_raw != "") {
                    std::string &_value = _raw;
                    versionName = _value;
                }
                _raw = getXmlAttribute(root, "isFactory");
                bool isFactory{};
                if (_raw != "") {
                    bool _value = _raw == "true";
                    isFactory = _value;
                }
                _raw = getXmlAttribute(root, "isActive");
                bool isActive{};
                if (_raw != "") {
                    bool _value = _raw == "true";
                    isActive = _value;
                }
                _raw = getXmlAttribute(root, "lastUpdateMillis");
                std::optional<int64_t> lastUpdateMillis = std::nullopt;
                if (_raw != "") {
                    int64_t _value = std::stoll(_raw);
                    lastUpdateMillis = _value;
                }
                _raw = getXmlAttribute(root, "provideSharedApexLibs");
                bool provideSharedApexLibs{};
                if (_raw != "") {
                    bool _value = _raw == "true";
                    provideSharedApexLibs = _value;
                }
                ApexInfo instance(moduleName, modulePath, preinstalledModulePath, versionCode, versionName, isFactory, isActive, lastUpdateMillis, provideSharedApexLibs);
                return instance;
            }

            void ApexInfo::write(std::ostream& _out, const std::string& _name) const {
                _out << printIndent() << "<" << _name;
                if (hasModuleName()) {
                    _out << " moduleName=\"";
                    _out << getModuleName();
                    _out << "\"";
                }
                if (hasModulePath()) {
                    _out << " modulePath=\"";
                    _out << getModulePath();
                    _out << "\"";
                }
                if (hasPreinstalledModulePath()) {
                    _out << " preinstalledModulePath=\"";
                    _out << getPreinstalledModulePath();
                    _out << "\"";
                }
                if (hasVersionCode()) {
                    _out << " versionCode=\"";
                    _out << getVersionCode();
                    _out << "\"";
                }
                if (hasVersionName()) {
                    _out << " versionName=\"";
                    _out << getVersionName();
                    _out << "\"";
                }
                if (hasIsFactory()) {
                    _out << " isFactory=\"";
                    _out << (getIsFactory() ? "true" : "false");
                    _out << "\"";
                }
                if (hasIsActive()) {
                    _out << " isActive=\"";
                    _out << (getIsActive() ? "true" : "false");
                    _out << "\"";
                }
                if (hasLastUpdateMillis()) {
                    _out << " lastUpdateMillis=\"";
                    _out << getLastUpdateMillis();
                    _out << "\"";
                }
                if (hasProvideSharedApexLibs()) {
                    _out << " provideSharedApexLibs=\"";
                    _out << (getProvideSharedApexLibs() ? "true" : "false");
                    _out << "\"";
                }
                _out << ">" << std::endl;
                ++indentIndex;
                --indentIndex;
                _out << printIndent() << "</" << _name << ">" << std::endl;
            }
        } // apex
    } // android
} // com