BaseClasses.h

/*
 * Copyright (C) 2025, Robert Patterson
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 * THE SOFTWARE.
 */
#pragma once
 
#include <cassert>
#include <filesystem>
#include <set>
#include <string_view>
#include <unordered_set>
#include <memory>
 
#include "musx/dom/Fundamentals.h"
#include "musx/xml/XmlInterface.h"
#include "musx/util/Logger.h"
#include "MusxInstance.h"
 
namespace musx {
 
namespace dom {
 
class integrity_error : public std::runtime_error
{
public:
    using std::runtime_error::runtime_error;
};
 
class Document;
using DocumentPtr = std::shared_ptr<Document>;
using DocumentWeakPtr = std::weak_ptr<Document>;
 
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
class PartContextCloner {
public:
    template <typename T>
    static void setRequestedPartId(const std::shared_ptr<T>& obj, Cmper partId)
    {
        obj->setRequestedPartId(partId);
    }
 
    template <typename T>
    static std::shared_ptr<T> copyWithPartId(const std::shared_ptr<const T>& obj, Cmper partId)
    {
        auto result = std::make_shared<T>(*obj);
        setRequestedPartId(result, partId);
        return result;
    }
};
#endif
 
class Base
{
public:
    using SharedNodes = std::set<std::string>;
 
    enum class ShareMode
    {
        // this enum was giving Doxygen fits until I switched to using the slash-splat-bang-lt comment commands.
        All,            
        Partial,        
        None            
    };
 
    virtual ~Base() noexcept(false) = default;
 
    DocumentPtr getDocument() const
    {
        auto document = m_document.lock();
        MUSX_ASSERT_IF(!document) {
            throw std::logic_error("Document pointer is no longer valid.");
        }
        return document;
    }
 
    Cmper getSourcePartId() const { return m_sourcePartId; }
 
    ShareMode getShareMode() const { return m_shareMode; }
 
    const SharedNodes& getUnlinkedNodes() const { return m_unlinkedNodes; }
 
    void addUnlinkedNode(const std::string& nodeName)
    {
        m_unlinkedNodes.insert(nodeName);
    }
 
    virtual void integrityCheck([[maybe_unused]]const std::shared_ptr<Base>& ptrToThis) { }
 
    virtual bool requireAllFields() const { return true; }
 
protected:
    Base(const DocumentWeakPtr& document, Cmper partId, ShareMode shareMode)
        : m_document(document), m_sourcePartId(partId), m_shareMode(shareMode) {}
 
    Base(const Base&) = default;        
    Base(Base&&) noexcept = default;    
 
    Base& operator=(const Base&) { return *this; }
    Base& operator=(Base&&) noexcept { return *this; }
 
private:
    const DocumentWeakPtr m_document;
    const Cmper m_sourcePartId;
    const ShareMode m_shareMode;
    SharedNodes m_unlinkedNodes;
};
 
class CommonClassBase : public Base
{
    Cmper getSourcePartId() const = delete; 
 
public:
    CommonClassBase(const DocumentWeakPtr& document)
        : Base(document, SCORE_PARTID, ShareMode::All) {}
 
protected:
    // Because the part ID and share mode are hard-coded for this category of classes,
    // these Base functions do not return useful results.
    using Base::getShareMode;
    using Base::getUnlinkedNodes;
};
 
class ContainedClassBase : public Base
{
    Cmper getSourcePartId() const = delete; 
 
public:
    ContainedClassBase(const MusxInstance<Base>& parent)
        : Base(parent->getDocument(), SCORE_PARTID, ShareMode::All), m_parent(parent)
    {}
 
    template <typename ParentClass = Base>
    MusxInstance<ParentClass> getParent() const
    {
        auto result = m_parent.lock();
        MUSX_ASSERT_IF (!result) {
            throw std::logic_error("Attempt to get parent of contained class, but the parent is no longer allocated.");
        }
        if constexpr (std::is_same_v<Base, ParentClass>) {
            return result;
        } else {
            return std::dynamic_pointer_cast<const ParentClass>(result);
        }
    }
    
private:
    const MusxInstanceWeak<Base> m_parent;
};
 
class OptionsBase : public Base {
    Cmper getSourcePartId() const = delete; 
 
protected:
    OptionsBase(const DocumentWeakPtr& document, Cmper partId, ShareMode shareMode)
        : Base(document, partId, shareMode) {}
};
 
class OthersBase : public Base
{
    void setRequestedPartId(Cmper newValue) { m_requestedPartId = newValue; }
 
    friend class PartContextCloner; // gives access to private setter
 
protected:
    OthersBase(const DocumentWeakPtr& document, Cmper partId, ShareMode shareMode, Cmper cmper, std::optional<Inci> inci = std::nullopt)
        : Base(document, partId, shareMode), m_requestedPartId(partId), m_cmper(cmper), m_inci(inci) {}
 
    OthersBase& operator=(const OthersBase& other)
    {
        if (this != &other) {
            this->Base::operator=(other);
        }
        return *this;
    }
    OthersBase& operator=(OthersBase&& other) noexcept
    {
        if (this != &other) {
            this->Base::operator=(other);
        }
        return *this;
    }
 
public:
    OthersBase(const OthersBase&) = default;        
    OthersBase(OthersBase&&) noexcept = default;    
 
    Cmper getCmper() const { return m_cmper; }
 
    std::optional<Inci> getInci() const { return m_inci; }
 
    Cmper getRequestedPartId() const { return m_requestedPartId; }
 
private:
    Cmper m_requestedPartId{};      
    Cmper m_cmper;                  
    std::optional<Inci> m_inci;     
};
 
template <typename ElementType, size_t REQUIRED_SIZE = 0>
class OthersArray : public OthersBase
{
private:
    virtual std::string_view xmlTag() const = 0;
 
public:
    explicit OthersArray(const DocumentWeakPtr& document, Cmper partId, ShareMode shareMode, Cmper cmper)
        : OthersBase(document, partId, shareMode, cmper)
    {
    }
 
    std::vector<ElementType> values;    
 
    void integrityCheck(const std::shared_ptr<Base>& ptrToThis) override
    {
        OthersBase::integrityCheck(ptrToThis);
        if constexpr (REQUIRED_SIZE > 0) {
            const size_t originalSize = values.size();
            values.resize(REQUIRED_SIZE); // resize first, in case MUSX_INTEGRITY_ERROR throws. (Avoid unreachable code warning.)
            if (originalSize < REQUIRED_SIZE) {
                MUSX_INTEGRITY_ERROR("Array with xml tag " + std::string(xmlTag()) + " and cmper " + std::to_string(getCmper())
                    + " has fewer than " + std::to_string(REQUIRED_SIZE) + " elements.");
            }
        }
    }
};
 
class OthersName : public OthersBase
{
public:
    explicit OthersName(const DocumentWeakPtr& document, Cmper partId, ShareMode shareMode, Cmper cmper)
        : OthersBase(document, partId, shareMode, cmper)
    {
    }
 
    std::string name;       
 
    static const xml::XmlElementArray<OthersName>& xmlMappingArray(); 
};
 
class DetailsBase : public Base
{
    void setRequestedPartId(Cmper newValue) { m_requestedPartId = newValue; }
 
    friend class PartContextCloner; // gives access to private setter
 
protected:
    DetailsBase(const DocumentWeakPtr& document, Cmper partId, ShareMode shareMode, Cmper cmper1, Cmper cmper2, std::optional<Inci> inci = std::nullopt)
        : Base(document, partId, shareMode), m_requestedPartId(partId), m_cmper1(cmper1), m_cmper2(cmper2), m_inci(inci) {}
 
    DetailsBase& operator=(const DetailsBase& other)
    {
        if (this != &other) {
            this->Base::operator=(other);
        }
        return *this;
    }
    DetailsBase& operator=(DetailsBase&& other) noexcept
    {
        if (this != &other) {
            this->Base::operator=(other);
        }
        return *this;
    }
 
public:
    DetailsBase(const DetailsBase&) = default;        
    DetailsBase(DetailsBase&&) noexcept = default;    
 
    Cmper getCmper1() const { return m_cmper1; }
 
    Cmper getCmper2() const { return m_cmper2; }
 
    std::optional<Inci> getInci() const { return m_inci; }
 
    Cmper getRequestedPartId() const { return m_requestedPartId; }
 
private:
    Cmper m_requestedPartId{};      
    Cmper m_cmper1;                 
    Cmper m_cmper2;                 
    std::optional<Inci> m_inci;     
};
 
class EntryDetailsBase : public DetailsBase
{
protected:
    EntryDetailsBase(const DocumentWeakPtr& document, Cmper partId, ShareMode shareMode, EntryNumber entnum, std::optional<Inci> inci = std::nullopt)
        : DetailsBase(document, partId, shareMode, Cmper(entnum >> 16), Cmper(entnum & 0xffff), inci) {}
 
public:
    EntryNumber getEntryNumber() const { return EntryNumber(getCmper1()) << 16 | EntryNumber(getCmper2()); }
 
private:
    using DetailsBase::getCmper1;
    using DetailsBase::getCmper2;
};
 
template <typename ElementType, size_t REQUIRED_SIZE = 0>
class DetailsArray : public DetailsBase
{
private:
    virtual std::string_view xmlTag() const = 0;
 
public:
    explicit DetailsArray(const DocumentWeakPtr& document, Cmper partId, ShareMode shareMode, Cmper cmper1, Cmper cmper2)
        : DetailsBase(document, partId, shareMode, cmper1, cmper2)
    {
    }
 
    std::vector<ElementType> values;    
 
    void integrityCheck(const std::shared_ptr<Base>& ptrToThis) override
    {
        DetailsBase::integrityCheck(ptrToThis);
        if constexpr (REQUIRED_SIZE > 0) {
            const size_t originalSize = values.size();
            values.resize(REQUIRED_SIZE); // resize first, in case MUSX_INTEGRITY_ERROR throws. (Avoid unreachable code warning.)
            if (originalSize < REQUIRED_SIZE) {
                MUSX_INTEGRITY_ERROR("Array with xml tag " + std::string(xmlTag()) + " and cmpers [" + std::to_string(getCmper1()) + ", " + std::to_string(getCmper2())
                    + "] has fewer than " + std::to_string(REQUIRED_SIZE) + " elements.");
            }
        }
    }
};
 
class NoteDetailsBase : public EntryDetailsBase
{
public:
    virtual NoteNumber getNoteId() const = 0;
 
protected:
    using EntryDetailsBase::EntryDetailsBase;
};
 
class FontInfo;
class TextsBase : public Base
{
    Cmper getSourcePartId() const = delete; 
 
public:
    TextsBase(const DocumentWeakPtr& document, Cmper partId, ShareMode shareMode, Cmper textNumber)
        : Base(document, partId, shareMode), m_textNumber(textNumber) {}
 
    std::string text;    
 
    Cmper getTextNumber() const { return m_textNumber; }
 
    void setTextNumber(Cmper textNumber) { m_textNumber = textNumber; }
 
    util::EnigmaParsingContext getRawTextCtx(const MusxInstance<TextsBase>& ptrToThis, Cmper forPartId, std::optional<Cmper> forPageId = std::nullopt,
        util::EnigmaString::TextInsertCallback defaultInsertFunc = util::EnigmaString::defaultInsertsCallback) const;
 
private:
    Cmper m_textNumber;             
};
 
} // namespace dom
} // namespace musx