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 <functional>
#include <string_view>
#include <unordered_set>
#include <memory>
 
#include "musx/dom/Fundamentals.h"
#include "musx/xml/XmlInterface.h"
#include "musx/util/EnigmaString.h"
#include "musx/util/Logger.h"
#include "DocumentElement.h"
#include "MusxInstance.h"
 
namespace musx {
 
namespace dom {
 
class integrity_error : public std::runtime_error
{
public:
    using std::runtime_error::runtime_error;
};
 
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
template <typename T>
struct PartContextRebinder
{
    static void rebind(const std::shared_ptr<T>&) {}
};
 
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);
        PartContextRebinder<T>::rebind(result);
        return result;
    }
};
#endif
 
class EnigmaBase : public DocumentElement
{
    Cmper getPartId() const = delete;
 
public:
    enum class ShareMode
    {
        All,            
        Partial,        
        None            
    };
 
    Cmper getSourcePartId() const { return DocumentElement::getPartId(); }
 
    ShareMode getShareMode() const { return m_shareMode; }
 
    virtual void integrityCheck([[maybe_unused]] const std::shared_ptr<EnigmaBase>& ptrToThis) { }
 
    virtual bool requireAllFields() const { return true; }
 
protected:
    EnigmaBase(const DocumentWeakPtr& document, Cmper partId, ShareMode shareMode)
        : DocumentElement(document, partId), m_shareMode(shareMode) {}
 
    EnigmaBase(const EnigmaBase&) = default;        
    EnigmaBase(EnigmaBase&&) noexcept = default;    
 
    EnigmaBase& operator=(const EnigmaBase&) { return *this; }
 
    EnigmaBase& operator=(EnigmaBase&&) noexcept { return *this; }
 
private:
    const ShareMode m_shareMode;
};
 
using ImportObjectCallback = std::function<void(const EnigmaBase&)>;
 
class CommonClassBase : public EnigmaBase
{
    Cmper getSourcePartId() const = delete; 
 
public:
    CommonClassBase(const DocumentWeakPtr& document)
        : EnigmaBase(document, SCORE_PARTID, ShareMode::All) {}
 
protected:
    // Because the part ID and share mode are hard-coded for this category of classes,
    // these EnigmaBase functions do not return useful results.
    using EnigmaBase::getShareMode;
};
 
class ContainedClassBase : public EnigmaBase
{
    Cmper getSourcePartId() const = delete; 
 
protected:
    // A shallow copy of an owning OthersBase or DetailsBase leaves contained objects parented to
    // the source instance. If that distinction matters, the owner must use PartContextRebinder.
    // PartContextRebinder<details::CenterShape> is a simple example.
 
    ContainedClassBase& operator=(const ContainedClassBase& other)
    {
        if (this != &other) {
            this->EnigmaBase::operator=(other);
        }
        return *this;
    }
 
    ContainedClassBase& operator=(ContainedClassBase&& other) noexcept
    {
        if (this != &other) {
            this->EnigmaBase::operator=(std::move(other));
        }
        return *this;
    }
 
public:
    ContainedClassBase(const MusxInstance<EnigmaBase>& parent)
        : EnigmaBase(parent->getDocument(), SCORE_PARTID, ShareMode::All), m_parent(parent)
    {}
 
    template <typename ParentClass = EnigmaBase>
    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<EnigmaBase, ParentClass>) {
            return result;
        } else {
            return std::dynamic_pointer_cast<const ParentClass>(result);
        }
    }
 
private:
    const MusxInstanceWeak<EnigmaBase> m_parent;
};
 
class OptionsBase : public EnigmaBase {
    Cmper getSourcePartId() const = delete; 
 
protected:
    OptionsBase(const DocumentWeakPtr& document, Cmper partId, ShareMode shareMode)
        : EnigmaBase(document, partId, shareMode) {}
};
 
class OthersBase : public EnigmaBase
{
    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)
        : EnigmaBase(document, partId, shareMode), m_requestedPartId(partId), m_cmper(cmper), m_inci(inci) {}
 
    OthersBase& operator=(const OthersBase& other)
    {
        if (this != &other) {
            this->EnigmaBase::operator=(other);
        }
        return *this;
    }
    OthersBase& operator=(OthersBase&& other) noexcept
    {
        if (this != &other) {
            this->EnigmaBase::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;    
 
    bool containsValue(const ElementType& value) const noexcept
    {
        const auto& v = this->values;
        return std::find(v.begin(), v.end(), value) != v.end();
    }
 
    void integrityCheck(const std::shared_ptr<EnigmaBase>& 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 EnigmaBase
{
    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)
        : EnigmaBase(document, partId, shareMode), m_requestedPartId(partId), m_cmper1(cmper1), m_cmper2(cmper2), m_inci(inci) {}
 
    DetailsBase& operator=(const DetailsBase& other)
    {
        if (this != &other) {
            this->EnigmaBase::operator=(other);
        }
        return *this;
    }
    DetailsBase& operator=(DetailsBase&& other) noexcept
    {
        if (this != &other) {
            this->EnigmaBase::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
{
public:
    enum class StemSelection
    {
        MatchEntry,     
        UpStem,         
        DownStem,       
        Any             
    };
 
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) {}
 
    template <typename EDUP, typename EDDOWN, typename EDBASE>
    static MusxInstance<EDBASE> getStemDependentDetail(const EntryInfoPtr& entryInfo, StemSelection stemSelection);
 
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<EnigmaBase>& 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 EnigmaBase
{
    Cmper getSourcePartId() const = delete; 
 
public:
    TextsBase(const DocumentWeakPtr& document, Cmper partId, ShareMode shareMode, Cmper textNumber)
        : EnigmaBase(document, partId, shareMode), m_textNumber(textNumber) {}
 
    TextsBase(const TextsBase&) = default;        
    TextsBase(TextsBase&&) noexcept = default;    
 
protected:
    TextsBase& operator=(const TextsBase& other)
    {
        if (this != &other) {
            this->EnigmaBase::operator=(other);
            text = other.text;
        }
        return *this;
    }
 
    TextsBase& operator=(TextsBase&& other) noexcept
    {
        if (this != &other) {
            this->EnigmaBase::operator=(std::move(other));
            text = std::move(other.text);
        }
        return *this;
    }
 
public:
    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