/*
 * Copyright (C) 2018 The Android Open Source Project
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package com.android.xsdc.cpp;

import com.android.xsdc.CodeWriter;
import com.android.xsdc.FileSystem;
import com.android.xsdc.XmlSchema;
import com.android.xsdc.XsdConstants;
import com.android.xsdc.tag.*;

import java.io.IOException;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;

import javax.xml.namespace.QName;

public class CppCodeGenerator {
    private XmlSchema xmlSchema;
    private String pkgName;
    private Map<String, CppSimpleType> cppSimpleTypeMap;
    private CodeWriter cppFile;
    private CodeWriter headerFile;
    private boolean hasAttr;
    private boolean writer;

    private static final String UNKNOWN_ENUM = "UNKNOWN";

    public CppCodeGenerator(XmlSchema xmlSchema, String pkgName, boolean writer)
            throws CppCodeGeneratorException {
        this.xmlSchema = xmlSchema;
        this.pkgName = pkgName;
        this.writer = writer;

        // class naming validation
        {
            Set<String> nameSet = new HashSet<>();
            nameSet.add("XmlParser");
            for (XsdType type : xmlSchema.getTypeMap().values()) {
                if ((type instanceof XsdComplexType) || (type instanceof XsdRestriction &&
                        ((XsdRestriction)type).getEnums() != null)) {
                    String name = Utils.toClassName(type.getName());
                    if (nameSet.contains(name)) {
                        throw new CppCodeGeneratorException(
                                String.format("duplicate class name : %s", name));
                    }
                    nameSet.add(name);
                    if (type instanceof XsdComplexType && !hasAttr) {
                        hasAttr = hasAttribute((XsdComplexType)type);
                    }
                }
            }
            for (XsdElement element : xmlSchema.getElementMap().values()) {
                XsdType type = element.getType();
                if (type.getRef() == null && type instanceof XsdComplexType) {
                    String name = Utils.toClassName(element.getName());
                    if (nameSet.contains(name)) {
                        throw new CppCodeGeneratorException(
                                String.format("duplicate class name : %s", name));
                    }
                    nameSet.add(name);
                    if (!hasAttr) {
                        hasAttr = hasAttribute((XsdComplexType)type);
                    }
                }
            }
        }

        cppSimpleTypeMap = new HashMap<>();
        for (XsdType type : xmlSchema.getTypeMap().values()) {
            if (type instanceof XsdSimpleType) {
                XsdType refType = new XsdType(null, new QName(type.getName()));
                parseSimpleType(refType, true);
            }
        }
    }

    public void print(FileSystem fs)
            throws CppCodeGeneratorException, IOException {
        // cpp file, headr file init
        String cppFileName = pkgName.replace(".", "_") + ".cpp";
        String hFileName =  pkgName.replace(".", "_") + ".h";
        cppFile =  new CodeWriter(fs.getPrintWriter(cppFileName));
        headerFile = new CodeWriter(fs.getPrintWriter("include/" + hFileName));

        boolean hasEnums = false;
        for (XsdType type : xmlSchema.getTypeMap().values()) {
            if (type instanceof XsdRestriction &&
                  ((XsdRestriction)type).getEnums() != null) {
                hasEnums = true;
                break;
            }
        }

        String headerMacro = hFileName.toUpperCase().replace(".", "_");
        headerFile.printf("#ifndef %s\n", headerMacro);
        headerFile.printf("#define %s\n", headerMacro);
        headerFile.printf("\n");
        headerFile.printf("#include <array>\n");
        headerFile.printf("#include <map>\n");
        headerFile.printf("#include <optional>\n");
        headerFile.printf("#include <string>\n");
        headerFile.printf("#include <vector>\n");
        headerFile.printf("\n");
        headerFile.printf("#include <libxml/parser.h>\n");
        headerFile.printf("#include <libxml/xinclude.h>\n");
        if (hasEnums) {
            headerFile.printf("#include <xsdc/XsdcSupport.h>\n");
        }
        headerFile.printf("\n");

        cppFile.printf("#define LOG_TAG \"%s\"\n", pkgName);
        cppFile.printf("#include <android/log.h>\n");
        cppFile.printf("#include <android-base/strings.h>\n");
        cppFile.printf("#include <libxml/parser.h>\n");
        cppFile.printf("#include <libxml/xinclude.h>\n");
        cppFile.printf("\n");
        cppFile.printf("#include \"%s\"\n\n", hFileName);

        List<String> namespace = new java.util.ArrayList<>();
        for (String token : pkgName.split("\\.")) {
            if (token.isEmpty()) {
                continue;
            }
            if (Character.isDigit(token.charAt(0))) {
                token = "_" + token;
            }
            namespace.add(token);
            headerFile.printf("namespace %s {\n", token);
            cppFile.printf("namespace %s {\n", token);
        }

        printPrototype();
        printXmlParser();
        if (writer) {
            printXmlWriter();
        }

        for (XsdType type : xmlSchema.getTypeMap().values()) {
            if (type instanceof XsdRestriction &&
                  ((XsdRestriction)type).getEnums() != null) {
                String name = Utils.toClassName(type.getName());
                XsdRestriction restrictionType = (XsdRestriction) type;
                printEnum(name, restrictionType);
            }
        }
        for (XsdType type : xmlSchema.getTypeMap().values()) {
            if (type instanceof XsdComplexType) {
                String name = Utils.toClassName(type.getName());
                XsdComplexType complexType = (XsdComplexType) type;
                printClass(name, "", complexType);
            }
        }
        for (XsdElement element : xmlSchema.getElementMap().values()) {
            XsdType type = element.getType();
            if (type.getRef() == null && type instanceof XsdComplexType) {
                String name = Utils.toClassName(element.getName());
                XsdComplexType complexType = (XsdComplexType) type;
                printClass(name, "", complexType);
            }
        }

        Collections.reverse(namespace);
        for (String token : namespace) {
            headerFile.printf("} // %s\n", token);
            cppFile.printf("} // %s\n", token);
        }

        if (hasEnums) {
            headerFile.printf("\n//\n// global type declarations for package\n//\n\n");
            headerFile.printf("namespace android {\nnamespace details {\n");
            Collections.reverse(namespace);
            for (XsdType type : xmlSchema.getTypeMap().values()) {
                if (type instanceof XsdRestriction &&
                        ((XsdRestriction)type).getEnums() != null) {
                    String name = Utils.toClassName(type.getName());
                    XsdRestriction restrictionType = (XsdRestriction) type;
                    printEnumValues(namespace, name, restrictionType);
                }
            }
            headerFile.printf("}  // namespace details\n}  // namespace android\n\n");
        }

        headerFile.printf("#endif // %s\n", headerMacro);
        cppFile.close();
        headerFile.close();
    }

    private void printEnum(String name, XsdRestriction restrictionType)
            throws CppCodeGeneratorException {
        headerFile.printf("enum class %s {\n", name);
        cppFile.printf("const std::map<std::string, %s> %sString {\n", name, name);
        List<XsdEnumeration> enums = restrictionType.getEnums();

        headerFile.printf("%s = %d,\n", UNKNOWN_ENUM, -1);
        for (XsdEnumeration tag : enums) {
            String value = tag.getValue();
            headerFile.printf("%s,\n", Utils.toEnumName(value));
            cppFile.printf("{ \"%s\", %s::%s },\n", tag.getValue(), name,
                    Utils.toEnumName(value));
        }
        headerFile.printf("};\n");
        cppFile.printf("};\n\n");

        headerFile.printf("%s stringTo%s(const std::string& value);\n",
                name, name);
        cppFile.printf("%s stringTo%s(const std::string& value) {\n"
                + "auto enumValue = %sString.find(value);\n"
                + "return enumValue != %sString.end() ? enumValue->second : %s::%s;\n"
                + "}\n\n", name, name, name, name, name, UNKNOWN_ENUM);

        headerFile.printf("std::string toString(%s o);\n\n", name);
        cppFile.printf("std::string toString(%s o) {\n", name);
        cppFile.printf("switch (o) {\n");
        for (XsdEnumeration tag : enums) {
            String value = tag.getValue();
            cppFile.printf("case %s::%s: return \"%s\";\n",
                    name, Utils.toEnumName(value), tag.getValue());
        }
        cppFile.printf("default: return std::to_string(static_cast<int>(o));\n}\n");
        cppFile.printf("}\n\n");
    }

    private void printEnumValues(List<String> namespace, String name,
            XsdRestriction restrictionType) throws CppCodeGeneratorException {
        List<XsdEnumeration> enums = restrictionType.getEnums();
        String absoluteNamespace = "::" + String.join("::", namespace);
        headerFile.printf("template<> inline constexpr std::array<%s::%s, %d> "
                + "xsdc_enum_values<%s::%s> = {\n",
                absoluteNamespace, name, enums.size(), absoluteNamespace, name);
        for (XsdEnumeration tag : enums) {
            String value = tag.getValue();
            headerFile.printf("%s::%s::%s,\n", absoluteNamespace, name, Utils.toEnumName(value));
        }
        headerFile.printf("};\n");
    }

    private void printPrototype() throws CppCodeGeneratorException {
        for (XsdType type : xmlSchema.getTypeMap().values()) {
            if (type instanceof XsdRestriction &&
                ((XsdRestriction)type).getEnums() != null) {
                String name = Utils.toClassName(type.getName());
                headerFile.printf("enum class %s;\n", name);
            }
        }
        for (XsdType type : xmlSchema.getTypeMap().values()) {
            if (type instanceof XsdComplexType) {
                String name = Utils.toClassName(type.getName());
                headerFile.printf("class %s;\n", name);
            }
        }
        for (XsdElement element : xmlSchema.getElementMap().values()) {
            XsdType type = element.getType();
            if (type.getRef() == null && type instanceof XsdComplexType) {
                String name = Utils.toClassName(element.getName());
                headerFile.printf("class %s;\n", name);
            }
        }
    }

    private void printClass(String name, String nameScope, XsdComplexType complexType)
            throws CppCodeGeneratorException {
        assert name != null;
        // need element, attribute name duplicate validation?

        String baseName = getBaseName(complexType);
        CppSimpleType valueType = (complexType instanceof XsdSimpleContent) ?
                getValueType((XsdSimpleContent) complexType, false) : null;

        headerFile.printf("class %s ", name);

        if (baseName != null) {
            headerFile.printf(": public %s {\n", baseName);
        } else {
            headerFile.println("{");
        }

        // parse types for elements and attributes
        List<CppType> elementTypes = new ArrayList<>();
        List<XsdElement> elements = new ArrayList<>();
        elements.addAll(getAllElements(complexType.getGroup()));
        elements.addAll(complexType.getElements());

        for (XsdElement element : elements) {
            CppType cppType;
            XsdElement elementValue = resolveElement(element);
            if (element.getRef() == null && element.getType().getRef() == null
                    && element.getType() instanceof XsdComplexType) {
                // print inner class for anonymous types
                headerFile.printf("public:\n");
                String innerName = Utils.toClassName(getElementName(element));
                XsdComplexType innerType = (XsdComplexType) element.getType();
                printClass(innerName, nameScope + name + "::", innerType);
                headerFile.println();
                cppType = new CppComplexType(nameScope + name + "::"+ innerName);
            } else {
                cppType = parseType(elementValue.getType(), getElementName(elementValue));
            }
            elementTypes.add(cppType);
        }
        List<CppSimpleType> attributeTypes = new ArrayList<>();
        List<XsdAttribute> attributes = new ArrayList();
        for (XsdAttributeGroup attributeGroup : complexType.getAttributeGroups()) {
            attributes.addAll(getAllAttributes(resolveAttributeGroup(attributeGroup)));
        }
        attributes.addAll(complexType.getAttributes());

        for (XsdAttribute attribute : attributes) {
            XsdType type = resolveAttribute(attribute).getType();
            attributeTypes.add(parseSimpleType(type, false));
        }

        // print member variables

        headerFile.printf("private:\n");
        for (int i = 0; i < elementTypes.size(); ++i) {
            CppType type = elementTypes.get(i);
            XsdElement element = elements.get(i);
            XsdElement elementValue = resolveElement(element);
            String typeName = Utils.elementTypeName(type.getName(),
                    element.isMultiple() || type instanceof CppComplexType);
            headerFile.printf("const %s %s_;\n", typeName,
                    Utils.toVariableName(getElementName(elementValue)));
        }
        for (int i = 0; i < attributeTypes.size(); ++i) {
            CppType type = attributeTypes.get(i);
            XsdAttribute attribute = resolveAttribute(attributes.get(i));
            String variableName = Utils.toVariableName(attribute.getName());
            if (attribute.isRequired()) {
                headerFile.printf("const %s %s_;\n", type.getName(), variableName);
            } else {
                headerFile.printf("const std::optional<%s> %s_;\n", type.getName(), variableName);
            }
        }
        if (valueType != null) {
            headerFile.printf("const std::optional<%s> _value;\n", valueType.getName());
        }

        headerFile.printf("public:\n");
        String constructorArgs = printConstructor(name, nameScope, complexType, elements,
                attributes, baseName);

        // print getters and setters
        for (int i = 0; i < elementTypes.size(); ++i) {
            CppType type = elementTypes.get(i);
            XsdElement element = elements.get(i);
            XsdElement elementValue = resolveElement(element);
            printGetter(nameScope + name, type,
                    Utils.toVariableName(getElementName(elementValue)),
                    type instanceof CppComplexType ? true : element.isMultiple(),
                    type instanceof CppComplexType ? false : ((CppSimpleType)type).isList(),
                    false);
        }
        for (int i = 0; i < attributeTypes.size(); ++i) {
            CppType type = attributeTypes.get(i);
            XsdAttribute attribute = resolveAttribute(attributes.get(i));
            printGetter(nameScope + name, type, Utils.toVariableName(attribute.getName()),
                    false, false, attribute.isRequired());
        }
        if (valueType != null) {
            printGetter(nameScope + name, valueType, "value", false, false, false);
        }

        printParser(name, nameScope, complexType, constructorArgs);

        if (writer) {
            printWriter(name, nameScope, complexType);
        }

        headerFile.println("};\n");
    }

    private void printParser(String name, String nameScope, XsdComplexType complexType, String args)
            throws CppCodeGeneratorException {
        CppSimpleType baseValueType = (complexType instanceof XsdSimpleContent) ?
                getValueType((XsdSimpleContent) complexType, true) : null;
        List<XsdElement> allElements = new ArrayList<>();
        List<XsdAttribute> allAttributes = new ArrayList<>();
        stackComponents(complexType, allElements, allAttributes);

        // parse types for elements and attributes
        List<CppType> allElementTypes = new ArrayList<>();
        for (XsdElement element : allElements) {
            XsdElement elementValue = resolveElement(element);
            CppType cppType = parseType(elementValue.getType(), elementValue.getName());
            allElementTypes.add(cppType);
        }
        List<CppSimpleType> allAttributeTypes = new ArrayList<>();
        for (XsdAttribute attribute : allAttributes) {
            XsdType type = resolveAttribute(attribute).getType();
            allAttributeTypes.add(parseSimpleType(type, false));
        }

        String fullName = nameScope + name;
        headerFile.printf("static %s read(xmlNode *root);\n", fullName, Utils.lowerize(name));
        cppFile.printf("\n%s %s::read(xmlNode *root) {\n", fullName, fullName);

        cppFile.print("std::string raw;\n");

        for (int i = 0; i < allAttributes.size(); ++i) {
            CppSimpleType type = allAttributeTypes.get(i);
            XsdAttribute attribute = resolveAttribute(allAttributes.get(i));
            String variableName = Utils.toVariableName(attribute.getName());
            cppFile.printf("raw = getXmlAttribute(root, \"%s\");\n", attribute.getName());
            if (attribute.isRequired()) {
                if (type.getName().equals("bool")) {
                    cppFile.printf("%s %s = false;\n", type.getName(), variableName);
                } else if (type.getName().equals("std::string")) {
                    cppFile.printf("%s %s;\n", type.getName(), variableName);
                } else if (type.isEnum()) {
                    cppFile.printf("%s %s = %s::%s;\n",
                            type.getName(), variableName, type.getName(), UNKNOWN_ENUM);
                } else {
                    cppFile.printf("%s %s = 0;\n", type.getName(), variableName);
                }
            } else {
                cppFile.printf("std::optional<%s> %s = std::nullopt;\n", type.getName(),
                        variableName);
            }
            cppFile.printf("if (raw != \"\") {\n");
            cppFile.print(type.getParsingExpression());
            cppFile.printf("%s = value;\n}\n", variableName);
        }

        if (baseValueType != null) {
            cppFile.printf("auto xmlValue = make_xmlUnique(xmlNodeListGetString("
                    + "root->doc, root->xmlChildrenNode, 1));\n"
                    + "if (xmlValue != nullptr) {\n"
                    + "raw = reinterpret_cast<const char*>(xmlValue.get());\n");

            cppFile.print(baseValueType.getParsingExpression());
            cppFile.printf("instance.setValue(value);\n");
            cppFile.printf("}\n");
        } else if (!allElements.isEmpty()) {
            for (int i = 0; i < allElements.size(); ++i) {
                CppType type = allElementTypes.get(i);
                XsdElement element = allElements.get(i);
                XsdElement elementValue = resolveElement(element);
                String variableName = Utils.toVariableName(getElementName(elementValue));
                cppFile.printf("%s %s;\n", Utils.elementTypeName(type.getName(),
                        element.isMultiple() || type instanceof CppComplexType), variableName);
            }
            cppFile.print("for (xmlNode *child = root->xmlChildrenNode; child != nullptr;"
                    + " child = child->next) {\n");
            for (int i = 0; i < allElements.size(); ++i) {
                CppType type = allElementTypes.get(i);
                XsdElement element = allElements.get(i);
                XsdElement elementValue = resolveElement(element);
                String variableName = Utils.toVariableName(getElementName(elementValue));

                if (i != 0) cppFile.printf("} else ");
                cppFile.print("if (!xmlStrcmp(child->name, reinterpret_cast<const xmlChar*>");
                cppFile.printf("(\"%s\"))) {\n", elementValue.getName());

                if (type instanceof CppSimpleType) {
                    cppFile.print("auto xmlValue = make_xmlUnique(xmlNodeListGetString(");
                    cppFile.print("child->doc, child->xmlChildrenNode, 1));\n");
                    cppFile.print("if (xmlValue == nullptr) {\nraw = \"\";\n} else {\n");
                    cppFile.print("raw = reinterpret_cast<const char*>(xmlValue.get());\n}\n");
                }

                cppFile.print(type.getParsingExpression());

                if (element.isMultiple() || type instanceof CppComplexType) {
                    cppFile.printf("%s.push_back(std::move(value));\n", variableName);
                } else {
                    cppFile.printf("%s = std::move(value);\n", variableName);
                }
            }
            cppFile.printf("}\n}\n");
        }
        cppFile.printf("%s instance%s;\n", fullName, args.length() > 0 ? "(" + args + ")" : "");
        cppFile.print("return instance;\n}\n");
    }

    private void printWriter(String name, String nameScope, XsdComplexType complexType)
            throws CppCodeGeneratorException {
        CppSimpleType baseValueType = (complexType instanceof XsdSimpleContent) ?
                getValueType((XsdSimpleContent) complexType, true) : null;
        List<XsdElement> allElements = new ArrayList<>();
        List<XsdAttribute> allAttributes = new ArrayList<>();
        stackComponents(complexType, allElements, allAttributes);

        // parse types for elements and attributes
        List<CppType> allElementTypes = new ArrayList<>();
        for (XsdElement element : allElements) {
            XsdElement elementValue = resolveElement(element);
            CppType cppType = parseType(elementValue.getType(), elementValue.getName());
            allElementTypes.add(cppType);
        }
        List<CppSimpleType> allAttributeTypes = new ArrayList<>();
        for (XsdAttribute attribute : allAttributes) {
            XsdType type = resolveAttribute(attribute).getType();
            allAttributeTypes.add(parseSimpleType(type, false));
        }

        String fullName = nameScope + name;
        headerFile.printf("void write(std::ostream& out, const std::string& name) const;\n");
        cppFile.printf("\nvoid %s::write(std::ostream& out, const std::string& name) const {\n",
                fullName);

        cppFile.printf("out << printIndent() << \"<\" << name;\n");
        for (int i = 0; i < allAttributes.size(); ++i) {
            CppType type = allAttributeTypes.get(i);
            XsdAttribute attribute = resolveAttribute(allAttributes.get(i));
            String variableName = Utils.toVariableName(attribute.getName());
            cppFile.printf("if (has%s()) {\n", Utils.capitalize(variableName));
            cppFile.printf("out << \" %s=\\\"\";\n", attribute.getName());
            cppFile.print(type.getWritingExpression(String.format("get%s()",
                    Utils.capitalize(variableName)), attribute.getName()));
            cppFile.printf("out << \"\\\"\";\n}\n");
        }
        cppFile.print("out << \">\" << std::endl;\n");
        cppFile.print("++indentIndex;\n");

        if (!allElements.isEmpty()) {
            for (int i = 0; i < allElements.size(); ++i) {
                CppType type = allElementTypes.get(i);
                XsdElement element = allElements.get(i);
                XsdElement elementValue = resolveElement(element);
                String elementName = getElementName(elementValue);
                String variableName = Utils.toVariableName(elementName);

                if (type instanceof CppComplexType || element.isMultiple()) {
                    cppFile.printf("for (auto& value : get%s()) {\n",
                            Utils.capitalize(variableName));
                    if (type instanceof CppSimpleType) {
                        cppFile.printf("out << printIndent() << \"<%s>\";\n",
                                elementValue.getName());
                    }
                    cppFile.printf(type.getWritingExpression("value", elementValue.getName()));
                    if (type instanceof CppSimpleType) {
                        cppFile.printf("out << \"</%s>\" << std::endl;\n",
                                elementValue.getName());
                    }
                    cppFile.printf("}\n");
                } else {
                    cppFile.printf("if (has%s()) {\n", Utils.capitalize(variableName));
                    if (type instanceof CppSimpleType) {
                        cppFile.printf("out << printIndent() << \"<%s>\";\n",
                                elementValue.getName());
                    }
                    cppFile.print(type.getWritingExpression(String.format("get%s()",
                              Utils.capitalize(variableName)), elementValue.getName()));
                    if (type instanceof CppSimpleType) {
                        cppFile.printf("out << \"</%s>\" << std::endl;\n",
                                elementValue.getName());
                    }
                    cppFile.print("}\n");
                }
            }
        }
        cppFile.print("--indentIndex;\n");
        cppFile.printf("out << printIndent() << \"</\" << name << \">\" << std::endl;\n");
        cppFile.printf("}\n");
    }

    private void printGetter(String name, CppType type, String variableName,
            boolean isMultiple, boolean isMultipleType, boolean isRequired) {
        String typeName = isMultiple ? String.format("std::vector<%s>",
                type.getName()) : type.getName();

        headerFile.printf("const %s& get%s() const;\n", typeName, Utils.capitalize(variableName));

        cppFile.println();
        cppFile.printf("const %s& %s::get%s() const {\n"
                + "return %s;\n}\n\n",
                typeName, name, Utils.capitalize(variableName), isMultiple || isRequired ?
                variableName + "_" : String.format("%s_.value()", variableName));

        headerFile.printf("bool has%s() const;\n", Utils.capitalize(variableName));
        cppFile.printf("bool %s::has%s() const {\n", name, Utils.capitalize(variableName));
        if (isMultiple) {
            cppFile.printf("return !(%s_.empty());\n}\n", variableName);
        } else if (isRequired){
            cppFile.print("return true;\n}\n");
        } else {
            cppFile.printf("return %s_.has_value();\n}\n", variableName);
        }

        if (isMultiple || isMultipleType) {
            String elementTypeName = type instanceof CppComplexType ? type.getName() :
                    ((CppSimpleType)type).getTypeName();
            if (elementTypeName.equals("bool")) {
                headerFile.printf("%s getFirst%s() const;\n",
                        elementTypeName, Utils.capitalize(variableName));
                cppFile.println();
                cppFile.printf("%s %s::getFirst%s() const {\n"
                        + "if (%s_%sempty()) {\n"
                        + "return false;\n"
                        + "}\n"
                        + "return %s;\n"
                        + "}\n",
                        elementTypeName, name, Utils.capitalize(variableName), variableName,
                        isMultiple ? "." : "->",
                        isMultiple ? String.format("%s_[0]", variableName) :
                        String.format("%s_.value()[0]", variableName));
            } else {
                headerFile.printf("const %s* getFirst%s() const;\n",
                        elementTypeName, Utils.capitalize(variableName));
                cppFile.println();
                cppFile.printf("const %s* %s::getFirst%s() const {\n"
                        + "if (%s_%sempty()) {\n"
                        + "return nullptr;\n"
                        + "}\n"
                        + "return &%s;\n"
                        + "}\n",
                        elementTypeName, name, Utils.capitalize(variableName), variableName,
                        isMultiple ? "." : "->",
                        isMultiple ? String.format("%s_[0]", variableName) :
                        String.format("%s_.value()[0]", variableName));
            }
        }
    }

    private String printConstructor(String name, String nameScope, XsdComplexType complexType,
            List<XsdElement> elements, List<XsdAttribute> attributes, String baseName)
            throws CppCodeGeneratorException {
        String fullName = nameScope + name;
        StringBuilder constructorArgs = new StringBuilder();
        StringBuilder parentArgs = new StringBuilder();
        StringBuilder constructor = new StringBuilder();
        StringBuilder args = new StringBuilder();

        List<XsdElement> allElements = new ArrayList<>();
        List<XsdAttribute> allAttributes = new ArrayList<>();
        stackComponents(complexType, allElements, allAttributes);

        List<CppType> allElementTypes = new ArrayList<>();
        for (XsdElement element : allElements) {
            XsdElement elementValue = resolveElement(element);
            CppType type = parseType(elementValue.getType(), elementValue.getName());
            String variableName = Utils.toVariableName(getElementName(elementValue));
            constructorArgs.append(String.format(", %s %s", Utils.elementTypeName(type.getName(),
                    element.isMultiple() || type instanceof CppComplexType), variableName));
            args.append(String.format(", %s", variableName));
            boolean isMultipleType;
            if (type instanceof CppComplexType) {
                isMultipleType = true;
            } else if (((CppSimpleType)type).isList()) {
                isMultipleType = true;
            } else {
                isMultipleType = false;
            }

            if (elements.contains(element)) {
                constructor.append(String.format(", %s_(%s)", variableName,
                        Utils.toAssignmentName(type.getName(), variableName, isMultipleType)));
            } else {
                parentArgs.append(String.format(", %s", variableName));
            }
        }
        List<CppSimpleType> allAttributeTypes = new ArrayList<>();
        for (XsdAttribute attribute : allAttributes) {
            CppType type = parseSimpleType(resolveAttribute(attribute).getType(), false);
            String variableName = Utils.toVariableName(resolveAttribute(attribute).getName());
            if (attribute.isRequired()) {
                constructorArgs.append(String.format(", %s %s", type.getName(), variableName));
            } else {
                constructorArgs.append(String.format(", std::optional<%s> %s", type.getName(),
                        variableName));
            }
            args.append(String.format(", %s", variableName));
            boolean isMultipleType = ((CppSimpleType)type).isList() ? true : false;
            if (attributes.contains(attribute)) {
                constructor.append(String.format(", %s_(%s)", variableName,
                        Utils.toAssignmentName(type.getName(), variableName, isMultipleType)));
            } else {
                parentArgs.append(String.format(", %s", variableName));
            }
        }

        String constructorArgsString = constructorArgs.toString();
        String constructorString = constructor.toString();
        if (constructorArgsString.length() > 0) {
            constructorArgsString = constructorArgsString.substring(2);
        }
        headerFile.printf("%s(%s);\n", name, constructorArgsString);
        cppFile.printf("\n%s::%s(%s) : ", fullName, name, constructorArgsString);

        String parentArgsString = parentArgs.toString();
        if (parentArgsString.length() > 0) {
            parentArgsString = parentArgsString.substring(2);
            cppFile.printf("%s(%s)", baseName, parentArgsString);
        } else {
            constructorString = constructorString.substring(2);
        }
        cppFile.printf("%s {\n}\n", constructorString);

        String argsString = args.toString();
        if (argsString.length() > 0) {
            argsString = argsString.substring(2);
        }
        return argsString;
    }

    private void printXmlParser() throws CppCodeGeneratorException {
        cppFile.printf("template <class T>\n"
                + "constexpr void (*xmlDeleter)(T* t);\n"
                + "template <>\nconstexpr auto xmlDeleter<xmlDoc> = xmlFreeDoc;\n"
                + "template <>\nauto xmlDeleter<xmlChar> = [](xmlChar *s) { xmlFree(s); };\n\n"
                + "template <class T>\n"
                + "constexpr auto make_xmlUnique(T *t) {\n"
                + "auto deleter = [](T *t) { xmlDeleter<T>(t); };\n"
                + "return std::unique_ptr<T, decltype(deleter)>{t, deleter};\n"
                + "}\n\n");

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

        String className = Utils.toClassName(pkgName);

        boolean isMultiRootElement = xmlSchema.getElementMap().values().size() > 1;
        for (XsdElement element : xmlSchema.getElementMap().values()) {
            CppType cppType = parseType(element.getType(), element.getName());
            String elementName = element.getName();
            String VariableName = Utils.toVariableName(elementName);
            String typeName = cppType instanceof CppSimpleType ? cppType.getName() :
                    Utils.toClassName(cppType.getName());

            headerFile.printf("std::optional<%s> read%s(const char* configFile);\n\n",
                    typeName, isMultiRootElement ? Utils.capitalize(typeName) : "");
            cppFile.printf("std::optional<%s> read%s(const char* configFile) {\n",
                    typeName, isMultiRootElement ? Utils.capitalize(typeName) : "");
            cppFile.printf("auto doc = make_xmlUnique(xmlParseFile(configFile));\n"
                    + "if (doc == nullptr) {\n"
                    + "return std::nullopt;\n"
                    + "}\n"
                    + "xmlNodePtr child = xmlDocGetRootElement(doc.get());\n"
                    + "if (child == NULL) {\n"
                    + "return std::nullopt;\n"
                    + "}\n\n"
                    + "if (!xmlStrcmp(child->name, reinterpret_cast<const xmlChar*>"
                    + "(\"%s\"))) {\n",
                    elementName);

            if (cppType instanceof CppSimpleType) {
                cppFile.printf("%s value = getXmlAttribute(child, \"%s\");\n",
                        elementName, elementName);
            } else {
                cppFile.printf(cppType.getParsingExpression());
            }
            cppFile.printf("return value;\n}\n");
            cppFile.printf("return std::nullopt;\n");
            cppFile.printf("}\n\n");
        }
    }

    private void printXmlWriter() throws CppCodeGeneratorException {
        for (XsdElement element : xmlSchema.getElementMap().values()) {
            CppType cppType = parseType(element.getType(), element.getName());
            String elementName = element.getName();
            String VariableName = Utils.toVariableName(elementName);
            String typeName = cppType instanceof CppSimpleType ? cppType.getName() :
                    Utils.toClassName(cppType.getName());
            headerFile.printf("void write(std::ostream& out, %s& %s);\n\n",
                    typeName, VariableName);
            cppFile.printf("void write(std::ostream& out, %s& %s) {\n",
                    typeName, VariableName);

            cppFile.print("out << \"<?xml version=\\\"1.0\\\" encoding=\\\"utf-8\\\"?>\\n\";\n");
            cppFile.printf("%s.write(out, \"%s\");\n", VariableName, elementName);
            cppFile.printf("}\n\n");
        }

        cppFile.print("static int indentIndex = 0;\n"
                + "std::string printIndent() {\n"
                + "std::string s = \"\";\n"
                + "for (int index = 0; index < indentIndex; ++index) {\n"
                + "s += \"    \";\n"
                + "}\nreturn s;\n}\n\n");
    }

    private String getElementName(XsdElement element) {
        if (element instanceof XsdChoice) {
            return element.getName() + "_optional";
        } else if (element instanceof XsdAll) {
            return element.getName() + "_all";
        }
        return element.getName();
    }

    private void stackComponents(XsdComplexType complexType, List<XsdElement> elements,
            List<XsdAttribute> attributes) throws CppCodeGeneratorException {
        if (complexType.getBase() != null) {
            QName baseRef = complexType.getBase().getRef();
            if (baseRef != null && !baseRef.getNamespaceURI().equals(XsdConstants.XSD_NAMESPACE)) {
                XsdType parent = getType(baseRef.getLocalPart());
                if (parent instanceof XsdComplexType) {
                    stackComponents((XsdComplexType) parent, elements, attributes);
                }
            }
        }
        elements.addAll(getAllElements(complexType.getGroup()));
        elements.addAll(complexType.getElements());
        for (XsdAttributeGroup attributeGroup : complexType.getAttributeGroups()) {
            attributes.addAll(getAllAttributes(resolveAttributeGroup(attributeGroup)));
        }
        attributes.addAll(complexType.getAttributes());
    }

    private List<XsdAttribute> getAllAttributes(XsdAttributeGroup attributeGroup)
            throws CppCodeGeneratorException{
        List<XsdAttribute> attributes = new ArrayList<>();
        for (XsdAttributeGroup attrGroup : attributeGroup.getAttributeGroups()) {
            attributes.addAll(getAllAttributes(resolveAttributeGroup(attrGroup)));
        }
        attributes.addAll(attributeGroup.getAttributes());
        return attributes;
    }

    private List<XsdElement> getAllElements(XsdGroup group) throws CppCodeGeneratorException {
        List<XsdElement> elements = new ArrayList<>();
        if (group == null) {
            return elements;
        }
        elements.addAll(getAllElements(resolveGroup(group)));
        elements.addAll(group.getElements());
        return elements;
    }


    private String getBaseName(XsdComplexType complexType) throws CppCodeGeneratorException {
        if (complexType.getBase() == null) return null;
        if (complexType.getBase().getRef().getNamespaceURI().equals(XsdConstants.XSD_NAMESPACE)) {
            return null;
        }
        XsdType base = getType(complexType.getBase().getRef().getLocalPart());
        if (base instanceof XsdComplexType) {
            return Utils.toClassName(base.getName());
        }
        return null;
    }

    private CppSimpleType getValueType(XsdSimpleContent simpleContent, boolean traverse)
            throws CppCodeGeneratorException {
        assert simpleContent.getBase() != null;
        QName baseRef = simpleContent.getBase().getRef();
        assert baseRef != null;
        if (baseRef.getNamespaceURI().equals(XsdConstants.XSD_NAMESPACE)) {
            return predefinedType(baseRef.getLocalPart());
        } else {
            XsdType parent = getType(baseRef.getLocalPart());
            if (parent instanceof XsdSimpleType) {
                return parseSimpleTypeReference(baseRef, false);
            }
            if (!traverse) return null;
            if (parent instanceof XsdSimpleContent) {
                return getValueType((XsdSimpleContent) parent, true);
            } else {
                throw new CppCodeGeneratorException(
                        String.format("base not simple : %s", baseRef.getLocalPart()));
            }
        }
    }

    private CppType parseType(XsdType type, String defaultName) throws CppCodeGeneratorException {
        if (type.getRef() != null) {
            String name = type.getRef().getLocalPart();
            if (type.getRef().getNamespaceURI().equals(XsdConstants.XSD_NAMESPACE)) {
                return predefinedType(name);
            } else {
                XsdType typeValue = getType(name);
                if (typeValue instanceof XsdSimpleType) {
                    return parseSimpleTypeReference(type.getRef(), false);
                }
                return parseType(typeValue, name);
            }
        }
        if (type instanceof XsdComplexType) {
            return new CppComplexType(Utils.toClassName(defaultName));
        } else if (type instanceof XsdSimpleType) {
            return parseSimpleTypeValue((XsdSimpleType) type, false);
        } else {
            throw new CppCodeGeneratorException(
                    String.format("unknown type name : %s", defaultName));
        }
    }

    private CppSimpleType parseSimpleType(XsdType type, boolean traverse)
            throws CppCodeGeneratorException {
        if (type.getRef() != null) {
            return parseSimpleTypeReference(type.getRef(), traverse);
        } else {
            return parseSimpleTypeValue((XsdSimpleType) type, traverse);
        }
    }

    private CppSimpleType parseSimpleTypeReference(QName typeRef, boolean traverse)
            throws CppCodeGeneratorException {
        assert typeRef != null;
        String typeName = typeRef.getLocalPart();
        if (typeRef.getNamespaceURI().equals(XsdConstants.XSD_NAMESPACE)) {
            return predefinedType(typeName);
        }
        if (cppSimpleTypeMap.containsKey(typeName)) {
            return cppSimpleTypeMap.get(typeName);
        } else if (traverse) {
            XsdSimpleType simpleType = getSimpleType(typeName);
            CppSimpleType ret = parseSimpleTypeValue(simpleType, true);
            cppSimpleTypeMap.put(typeName, ret);
            return ret;
        } else {
            throw new CppCodeGeneratorException(String.format("unknown type name : %s", typeName));
        }
    }

    private CppSimpleType parseSimpleTypeValue(XsdSimpleType simpleType, boolean traverse)
            throws CppCodeGeneratorException {
        if (simpleType instanceof XsdList) {
            XsdList list = (XsdList) simpleType;
            return parseSimpleType(list.getItemType(), traverse).newListType();
        } else if (simpleType instanceof XsdRestriction) {
            // we don't consider any restrictions.
            XsdRestriction restriction = (XsdRestriction) simpleType;
            if (restriction.getEnums() != null) {
                String name = Utils.toClassName(restriction.getName());
                return new CppSimpleType(name, "stringTo" + name + "(%s)", false, true);
            }
            return parseSimpleType(restriction.getBase(), traverse);
        } else if (simpleType instanceof XsdUnion) {
            // unions are almost always interpreted as java.lang.String
            // Exceptionally, if any of member types of union are 'list', then we interpret it as
            // List<String>
            XsdUnion union = (XsdUnion) simpleType;
            for (XsdType memberType : union.getMemberTypes()) {
                if (parseSimpleType(memberType, traverse).isList()) {
                    return new CppSimpleType("std::string", "%s", true);
                }
            }
            return new CppSimpleType("std::string", "%s", false);
        } else {
            // unreachable
            throw new IllegalStateException("unknown simple type");
        }
    }

    private XsdElement resolveElement(XsdElement element) throws CppCodeGeneratorException {
        if (element.getRef() == null) return element;
        String name = element.getRef().getLocalPart();
        XsdElement ret = xmlSchema.getElementMap().get(name);
        if (ret != null) return ret;
        throw new CppCodeGeneratorException(String.format("no element named : %s", name));
    }

    private XsdGroup resolveGroup(XsdGroup group) throws CppCodeGeneratorException {
        if (group.getRef() == null) return null;
        String name = group.getRef().getLocalPart();
        XsdGroup ret = xmlSchema.getGroupMap().get(name);
        if (ret != null) return ret;
        throw new CppCodeGeneratorException(String.format("no group named : %s", name));
    }

    private XsdAttribute resolveAttribute(XsdAttribute attribute)
            throws CppCodeGeneratorException {
        if (attribute.getRef() == null) return attribute;
        String name = attribute.getRef().getLocalPart();
        XsdAttribute ret = xmlSchema.getAttributeMap().get(name);
        if (ret != null) return ret;
        throw new CppCodeGeneratorException(String.format("no attribute named : %s", name));
    }

    private XsdAttributeGroup resolveAttributeGroup(XsdAttributeGroup attributeGroup)
            throws CppCodeGeneratorException {
        if (attributeGroup.getRef() == null) return attributeGroup;
        String name = attributeGroup.getRef().getLocalPart();
        XsdAttributeGroup ret = xmlSchema.getAttributeGroupMap().get(name);
        if (ret != null) return ret;
        throw new CppCodeGeneratorException(String.format("no attribute group named : %s", name));
    }

    private XsdType getType(String name) throws CppCodeGeneratorException {
        XsdType type = xmlSchema.getTypeMap().get(name);
        if (type != null) return type;
        throw new CppCodeGeneratorException(String.format("no type named : %s", name));
    }

    private XsdSimpleType getSimpleType(String name) throws CppCodeGeneratorException {
        XsdType type = getType(name);
        if (type instanceof XsdSimpleType) return (XsdSimpleType) type;
        throw new CppCodeGeneratorException(String.format("not a simple type : %s", name));
    }

    private boolean hasAttribute(XsdComplexType complexType) throws CppCodeGeneratorException {
        if (complexType.getAttributes().size() > 0 ||
                complexType.getAttributeGroups().size() > 0) {
            return true;
        }
        boolean results = false;
        for (XsdElement element : complexType.getElements()) {
            XsdElement elementValue = resolveElement(element);
            if (element.getRef() == null && element.getType().getRef() == null
                    && element.getType() instanceof XsdComplexType) {
                results = hasAttribute((XsdComplexType) element.getType());
                if (results) {
                    return results;
                }
            }
        }
        return results;
    }

    private static CppSimpleType predefinedType(String name) throws CppCodeGeneratorException {
        switch (name) {
            case "string":
            case "token":
            case "normalizedString":
            case "language":
            case "ENTITY":
            case "ID":
            case "Name":
            case "NCName":
            case "NMTOKEN":
            case "anyURI":
            case "anyType":
            case "QName":
            case "NOTATION":
            case "IDREF":
                return new CppSimpleType("std::string", "%s", false);
            case "ENTITIES":
            case "NMTOKENS":
            case "IDREFS":
                return new CppSimpleType("std::string", "%s", true);
            case "date":
            case "dateTime":
            case "time":
            case "gDay":
            case "gMonth":
            case "gYear":
            case "gMonthDay":
            case "gYearMonth":
            case "duration":
                return new CppSimpleType("std::string", "%s", false);
            case "decimal":
                return new CppSimpleType("double", "std::stod(%s)", false);
            case "integer":
            case "negativeInteger":
            case "nonNegativeInteger":
            case "positiveInteger":
            case "nonPositiveInteger":
                return new CppSimpleType("int64_t", "std::stoll(%s)", false);
            case "unsignedLong":
                return new CppSimpleType("uint64_t", "std::stoull(%s)", false);
            case "long":
                return new CppSimpleType("int64_t", "std::stoll(%s)", false);
            case "unsignedInt":
                return new CppSimpleType("unsigned int",
                        "static_cast<unsigned int>(stoul(%s))", false);
            case "int":
                return new CppSimpleType("int", "std::stoi(%s)", false);
            case "unsignedShort":
                return new CppSimpleType("unsigned short",
                        "static_cast<unsigned short>(std::stoi(%s))", false);
            case "short":
                return new CppSimpleType("short", "static_cast<short>(std::stoi(%s))", false);
            case "unsignedByte":
                return new CppSimpleType("unsigned char",
                        "static_cast<unsigned char>(std::stoi(%s))", false);
            case "byte":
                return new CppSimpleType("char", "static_cast<char>(std::stoi(%s))", false);
            case "boolean":
                return new CppSimpleType("bool", "%s == \"true\"", false);
            case "double":
                return new CppSimpleType("double", "std::stod(%s)", false);
            case "float":
                return new CppSimpleType("float", "std::stof(%s)", false);
            case "base64Binary":
            case "hexBinary":
                return new CppSimpleType("std::string", "%s", false);
        }
        throw new CppCodeGeneratorException("unknown xsd predefined type : " + name);
    }
}