#include <XCEngine/Resources/UI/UIDocuments.h>

namespace XCEngine {
namespace Resources {

namespace {

size_t MeasureNodeMemorySize(const UIDocumentNode& node) {
    size_t size = sizeof(UIDocumentNode) + node.tagName.Length();
    for (const UIDocumentAttribute& attribute : node.attributes) {
        size += sizeof(UIDocumentAttribute);
        size += attribute.name.Length();
        size += attribute.value.Length();
    }

    for (const UIDocumentNode& child : node.children) {
        size += MeasureNodeMemorySize(child);
    }

    return size;
}

size_t MeasureDiagnosticMemorySize(const UIDocumentDiagnostic& diagnostic) {
    return sizeof(UIDocumentDiagnostic) + diagnostic.message.Length();
}

size_t MeasureSchemaAttributeMemorySize(const UISchemaAttributeDefinition& attribute) {
    size_t size = sizeof(UISchemaAttributeDefinition) + attribute.name.Length();
    for (const Containers::String& value : attribute.allowedValues) {
        size += sizeof(Containers::String) + value.Length();
    }
    return size;
}

size_t MeasureSchemaElementMemorySize(const UISchemaElementDefinition& element) {
    size_t size = sizeof(UISchemaElementDefinition) + element.tagName.Length();
    for (const UISchemaAttributeDefinition& attribute : element.attributes) {
        size += MeasureSchemaAttributeMemorySize(attribute);
    }
    for (const UISchemaElementDefinition& child : element.children) {
        size += MeasureSchemaElementMemorySize(child);
    }
    return size;
}

size_t MeasureSchemaDefinitionMemorySize(const UISchemaDefinition& schemaDefinition) {
    size_t size = sizeof(UISchemaDefinition) + schemaDefinition.name.Length();
    for (const UISchemaElementDefinition& element : schemaDefinition.elements) {
        size += MeasureSchemaElementMemorySize(element);
    }
    return size;
}

} // namespace

void UIDocumentResource::Release() {
    m_document.Clear();
    SetInvalid();
    m_memorySize = 0;
}

void UIDocumentResource::SetDocumentModel(const UIDocumentModel& document) {
    m_document = document;
    RecalculateMemorySize();
}

void UIDocumentResource::SetDocumentModel(UIDocumentModel&& document) {
    m_document = std::move(document);
    RecalculateMemorySize();
}

void UIDocumentResource::RecalculateMemorySize() {
    size_t size = sizeof(*this);
    size += m_document.sourcePath.Length();
    size += m_document.displayName.Length();
    size += MeasureNodeMemorySize(m_document.rootNode);
    size += MeasureSchemaDefinitionMemorySize(m_document.schemaDefinition);
    for (const Containers::String& dependency : m_document.dependencies) {
        size += sizeof(Containers::String) + dependency.Length();
    }
    for (const UIDocumentDiagnostic& diagnostic : m_document.diagnostics) {
        size += MeasureDiagnosticMemorySize(diagnostic);
    }

    m_memorySize = size;
}

} // namespace Resources
} // namespace XCEngine