EntityMap.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 <algorithm>
#include <array>
#include <memory>
#include <optional>
#include <sstream>
#include <string>
#include <tuple>
#include <type_traits>
#include <unordered_map>
 
#include "../BaseTypes.h"
#include "../Global.h"
#include "../Layout.h"
#include "../Part.h"
#include "../Score.h"
#include "../Sequence.h"
 
namespace mnx::util {
 
namespace detail {
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
 
template <typename T>
struct JsonSchemaTypeNames
{
    static constexpr std::array<std::string_view, 1> value{ T::JsonSchemaTypeName };
};
 
template <>
struct JsonSchemaTypeNames<sequence::NoteBase>
{
    static constexpr std::array<std::string_view, 2> value{
        sequence::Note::JsonSchemaTypeName,
        sequence::KitNote::JsonSchemaTypeName
    };
};
 
template <typename T>
bool matchesTypeName(std::string_view typeName)
{
    for (const auto name : JsonSchemaTypeNames<T>::value) {
        if (name == typeName) {
            return true;
        }
    }
    return false;
}
 
template <typename T>
std::string typeNamesExpectationString()
{
    std::ostringstream oss;
    const auto& names = JsonSchemaTypeNames<T>::value;
    const auto count = names.size();
    if (count > 1) {
        oss << "expected one of ";
    } else {
        oss << "expected ";
    }
    for (size_t i = 0; i < count; ++i) {
        if (i > 0) {
            oss << ", ";
        }
        oss << "\"" << names[i] << "\"";
    }
    return oss.str();
}
 
#endif // DOXYGEN_SHOULD_IGNORE_THIS
} // namespace detail
 
class mapping_error : public std::runtime_error
{
    using runtime_error::runtime_error;
};
 
class EntityMap
{
public:
    struct MappedPosition
    {
        std::string measureId;                  
        FractionValue fraction;                 
        std::optional<unsigned> graceIndex;     
 
        MappedPosition(const std::string& measureId, const FractionValue& fraction,
                       std::optional<unsigned> graceIndex = std::nullopt)
            : measureId(measureId), fraction(fraction), graceIndex(graceIndex)
        {
        }
 
        MappedPosition(const MeasureRhythmicPosition& position)
            : measureId(position.measure()), fraction(position.position().fraction()), graceIndex(position.position().graceIndex())
        {
        }
    };
 
private:
    template <typename T>
    void add(const std::string& id, const T& value)
    {
        auto result = m_objectMap.emplace(id, MappedLocation{ value.pointer(), T::JsonSchemaTypeName });
        if (!result.second) {
            mapping_error err("ID " + formatKeyString(id) + " already exists for type \"" + std::string(result.first->second.typeName)
                + "\" at " + result.first->second.location.to_string());
            if (m_errorHandler) {
                m_errorHandler.value()(err.what(), value);
            } else {
                throw err;
            }
        }
    }
    
    void addEventToBeam(const std::string& eventId, const part::Beam& beam)
    {
        auto result = m_eventsInBeams.emplace(eventId, BeamMappingEntry{ MappedLocation{ beam.pointer(), part::Beam::JsonSchemaTypeName }, 0 });
        if (!result.second) {
            mapping_error err("ID " + formatKeyString(eventId) + " already exists in beam "
                + result.first->second.location.location.to_string());
            if (m_errorHandler) {
                m_errorHandler.value()(err.what(), beam);
            } else {
                throw err;
            }
        }
    }
 
    void setEventBeamStartLevel(const std::string& eventId, int level)
    {
        auto it = m_eventsInBeams.find(eventId);
        if (it == m_eventsInBeams.end()) {
            throw std::logic_error("Attempted to assign a beam start level to unmapped event " + eventId);
        }
        if (it->second.startLevel == 0) {
            it->second.startLevel = level;
        } else {
            it->second.startLevel = std::min(it->second.startLevel, level);
        }
    }
 
    void setEventOttavaShift(const std::string& eventPointer, int shift)
    {
        m_eventOttavaShift[eventPointer] = shift;
    }
 
    void setEventPosition(const std::string& eventPointer, const MappedPosition& position)
    {
        m_eventPositions.insert_or_assign(eventPointer, position);
    }
 
    friend class mnx::Document;
 
public:
 
    explicit EntityMap(std::weak_ptr<json> documentRoot, const std::optional<ErrorHandler>& errorHandler = std::nullopt)
        : m_root(documentRoot), m_errorHandler(errorHandler) {}
        
    template <typename T>
    std::optional<T> tryGet(
        const std::string& id,
        const std::optional<Base>& errorLocation = std::nullopt) const
    {
        auto it = m_objectMap.find(id);
        if (it == m_objectMap.end()) {
            return std::nullopt;
        }
        MNX_ASSERT_IF(!detail::matchesTypeName<T>(it->second.typeName)) {
            mapping_error err(
                "ID " + formatKeyString(id) + " has type \"" + std::string(it->second.typeName) +
                "\", but " + detail::typeNamesExpectationString<T>() + "."
            );
            if (m_errorHandler) {
                m_errorHandler.value()(err.what(), errorLocation.value_or(Document(root())));
            }
            throw err;
        }
        return T(root(), it->second.location);
    }
 
    template <typename T>
    T get(const std::string& id, const std::optional<Base>& errorLocation = std::nullopt) const
    {
        if (auto v = tryGet<T>(id, errorLocation)) {
            return *std::move(v);
        }
        mapping_error err("ID " + formatKeyString(id) + " not found in ID mapping");
        if (m_errorHandler) {
            m_errorHandler.value()(err.what(), errorLocation.value_or(Document(root())));
        }
        throw err;
    }
 
    template <typename T>
    size_t getIndexOf(const std::string& id, const std::optional<Base>& errorLocation = std::nullopt) const
    {
        static_assert(std::is_base_of_v<ArrayElementObject, T>,
                    "getIndexOf<T> requires T to derive from ArrayElementObject");
 
        auto v = get<T>(id, errorLocation);
        return v.calcArrayIndex();
    }
 
 
    template <typename T>
    bool exists(const std::string& id) const
    {
        const auto it = m_objectMap.find(id);
        if (it == m_objectMap.end()) {
            return false;
        }
        return detail::matchesTypeName<T>(it->second.typeName);
    }
 
    std::optional<part::Beam> tryGetBeam(const sequence::Event& event) const
    {
        if (const auto& eventId = event.id()) {
            const auto it = m_eventsInBeams.find(eventId.value());
            if (it != m_eventsInBeams.end()) {
                MNX_ASSERT_IF(it->second.location.typeName != part::Beam::JsonSchemaTypeName) {
                    mapping_error err(
                        "The beam mapping for eventId " + formatKeyString(eventId.value())
                        + " was mapped to an object of type \"" + std::string(it->second.location.typeName) + "\"."
                    );
                    if (m_errorHandler) {
                        m_errorHandler.value()(err.what(), event);
                    }
                    throw err;
                }
                return part::Beam(root(), it->second.location.location);
            }
        }
        return std::nullopt;
    }
 
    [[nodiscard]] std::optional<int> tryGetBeamStartLevel(const std::string& eventId) const
    {
        const auto it = m_eventsInBeams.find(eventId);
        if (it == m_eventsInBeams.end()) {
            return std::nullopt;
        }
        return it->second.startLevel;
    }
 
    [[nodiscard]] int getBeamStartLevel(const std::string& eventId) const
    {
        if (const auto level = tryGetBeamStartLevel(eventId)) {
            return *level;
        }
        return 0;
    }
 
    void clear()
    {
        m_objectMap.clear();
        m_eventsInBeams.clear();
        m_eventPositions.clear();
        m_eventOttavaShift.clear();
        m_lyricLineOrder.clear();
    }
 
    [[nodiscard]] std::optional<int> tryGetOttavaShift(const sequence::Event& event) const
    {
        const auto it = m_eventOttavaShift.find(event.pointer().to_string());
        if (it == m_eventOttavaShift.end()) {
            return std::nullopt;
        }
        return -it->second;
    }
 
    [[nodiscard]] int getOttavaShift(const sequence::Event& event) const
    {
        if (auto shift = tryGetOttavaShift(event)) {
            return shift.value();
        }
        return 0;
    }
 
    [[nodiscard]] std::optional<MappedPosition> tryGetEventPosition(const sequence::Event& event) const
    {
        const auto it = m_eventPositions.find(event.pointer().to_string());
        if (it == m_eventPositions.end()) {
            return std::nullopt;
        }
        return it->second;
    }
 
    [[nodiscard]] MappedPosition getEventPosition(const sequence::Event& event) const
    {
        if (auto position = tryGetEventPosition(event)) {
            return *std::move(position);
        }
        throw std::logic_error("No mapped position cached for event at " + event.pointer().to_string());
    }
 
    [[nodiscard]] int comparePositions(const MappedPosition& lhs,
                                       const MappedPosition& rhs,
                                       bool rhsIncludesTrailingGrace = false) const;
 
    [[nodiscard]] const std::vector<std::string>& getLyricLineOrder() const
    { return m_lyricLineOrder; }
 
private:
    std::weak_ptr<json> m_root;
    std::optional<ErrorHandler> m_errorHandler;
 
    std::shared_ptr<json> root() const
    {
        std::shared_ptr<json> result = m_root.lock();
        if (!result) {
            throw std::runtime_error("ID mapping is invalid because the document was destroyed.");
        }
        return result;
    }
 
    using MappedLocation = struct
    {
        json_pointer location;          
        std::string_view typeName;      
    };
    std::unordered_map<std::string, MappedLocation> m_objectMap;
    struct BeamMappingEntry
    {
        MappedLocation location;
        int startLevel{0};
    };
    std::unordered_map<std::string, BeamMappingEntry> m_eventsInBeams;
    std::unordered_map<std::string, MappedPosition> m_eventPositions;
    std::unordered_map<std::string, int> m_eventOttavaShift;
    std::vector<std::string> m_lyricLineOrder;
 
    static std::string formatKeyString(const std::string& key) {
        return "\"" + key + "\"";
    }
 
};
 
} // namespace mnx::util