LayoutHelpers.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 <optional>
#include <string>
#include <string_view>
#include <unordered_map>
#include <unordered_set>
#include <vector>
 
#include "../BaseTypes.h"
#include "../Global.h"
#include "../Layout.h"
 
namespace mnx::util {
 
struct StaffKey
{
    std::string partId;
 
    int staffNo = 1;
 
    bool operator==(const StaffKey& o) const noexcept
    {
        return staffNo == o.staffNo && partId == o.partId;
    }
};
 
struct StaffKeyHash
{
    size_t operator()(const StaffKey& k) const noexcept
    {
        size_t h1 = std::hash<std::string>{}(k.partId);
        size_t h2 = std::hash<int>{}(k.staffNo);
        return h1 ^ (h2 + 0x9e3779b9u + (h1 << 6) + (h1 >> 2));
    }
};
 
using LayoutStaffKeySet = std::unordered_set<StaffKey, StaffKeyHash>;
 
[[nodiscard]] inline std::optional<LayoutStaffKeySet>
analyzeLayoutStaffVoices(const layout::Staff& staff)
{
    const auto sources = staff.sources();
    if (sources.empty()) {
        return std::nullopt;
    }
 
    struct KeyState
    {
        size_t count = 0;
        bool anyMissingVoice = false;
        std::unordered_set<std::string> voices;
    };
 
    std::unordered_map<StaffKey, KeyState, StaffKeyHash> stateByKey;
    stateByKey.reserve(sources.size());
 
    for (const auto src : sources) {
        const std::string partId = src.part();
        if (partId.empty()) {
            return std::nullopt;
        }
 
        const StaffKey key{partId, src.staff()};
        auto& st = stateByKey[key];
        ++st.count;
 
        const auto v = src.voice();
        if (!v) {
            st.anyMissingVoice = true;
            continue;
        }
 
        if (v->empty()) {
            return std::nullopt;
        }
 
        if (!st.voices.emplace(*v).second) {
            return std::nullopt; // duplicate voice for same StaffKey
        }
    }
 
    // Enforce per-StaffKey semantic rule.
    for (const auto& kv : stateByKey) {
        const KeyState& st = kv.second;
        if (st.count > 1) {
            if (st.anyMissingVoice || st.voices.size() != st.count) {
                return std::nullopt;
            }
        }
    }
 
    LayoutStaffKeySet result;
    result.reserve(stateByKey.size());
    for (const auto& kv : stateByKey) {
        result.insert(kv.first);
    }
 
    return result;
}
 
[[nodiscard]] inline std::optional<std::vector<layout::Staff>>
flattenLayoutStaves(const Layout& layout)
{
    auto content = layout.content();
    std::vector<layout::Staff> result;
    result.reserve(content.size()); // lower bound; groups may expand further
 
    const auto walk = [&](auto&& self, const ContentArray& content) -> std::optional<bool> {
        for (auto elem : content) {
            if (elem.type() == layout::Group::ContentTypeValue) {
                layout::Group g = elem.get<layout::Group>();
                auto ok = self(self, g.content());
                if (!ok) {
                    return std::nullopt;
                }
            } else if (elem.type() == layout::Staff::ContentTypeValue) {
                result.push_back(elem.get<layout::Staff>());
            } else {
                return std::nullopt;
            }
        }
        return true;
    };
 
    if (!walk(walk, content)) {
        return std::nullopt;
    }
    return result;
}
 
struct LayoutSpan
{
    enum class Kind
    {
        Staff,  
        Group   
    };
 
    Kind kind{}; 
 
    size_t startIndex{};
 
    size_t endIndex{};
 
    size_t depth{};
 
    std::optional<std::string> label;
 
    std::optional<LabelRef> labelref;
 
    std::optional<LayoutSymbol> symbol;
 
    StaffGroupBarlineOverride barlineOverride = StaffGroupBarlineOverride::None;
 
    std::optional<LayoutStaffKeySet> sources;
};
 
[[nodiscard]] inline std::optional<std::vector<LayoutSpan>>
buildLayoutSpans(const mnx::Layout& layout)
{
    const auto content = layout.content();
    std::vector<LayoutSpan> spans;
    spans.reserve(content.size()); // lower bound
 
    size_t staffIndex = 0;
    size_t encounter  = 0; // stable tiebreaker
 
    struct SortKey { size_t start, depth, encounter; };
 
    struct TaggedSpan {
        LayoutSpan span;
        SortKey key;
    };
 
    std::vector<TaggedSpan> tagged;
    tagged.reserve(content.size());
 
    // Return value:
    // - outer std::optional: hard failure (unsupported element) if empty
    // - inner std::optional: no staves in subtree if empty; otherwise first/last staff indices
    const auto walk =
        [&](auto&& self, const ContentArray& arr, size_t depth)
            -> std::optional<std::optional<std::pair<size_t,size_t>>>
    {
        std::optional<size_t> first;
        std::optional<size_t> last;
 
        for (auto elem : arr) {
            if (elem.type() == layout::Staff::ContentTypeValue) {
                layout::Staff s = elem.get<layout::Staff>();
 
                const size_t i = staffIndex++;
 
                LayoutSpan span;
                span.kind       = LayoutSpan::Kind::Staff;
                span.depth      = depth + 1; // staff spans must be at the deepest depth
                span.startIndex = i;
                span.endIndex   = i;
                span.symbol     = s.symbol();
                span.label      = s.label();
                span.labelref   = s.labelref();
                span.barlineOverride = StaffGroupBarlineOverride::None;
                span.sources    = util::analyzeLayoutStaffVoices(s);
 
                tagged.push_back({ std::move(span), SortKey{i, depth + 1, encounter++} });
 
                first = first.value_or(i);
                last  = i;
            } else if (elem.type() == layout::Group::ContentTypeValue) {
                layout::Group g = elem.get<layout::Group>();
 
                auto childRange = self(self, g.content(), depth + 1);
                if (!childRange) {
                    return std::nullopt; // hard failure
                }
                if (!*childRange) {
                    continue; // skip groups with no staves anywhere in their subtree
                }
                const auto [cFirst, cLast] = **childRange;
 
                LayoutSpan span;
                span.kind       = LayoutSpan::Kind::Group;
                span.depth      = depth;
                span.startIndex = cFirst;
                span.endIndex   = cLast;
                span.symbol     = g.symbol();
                span.label      = g.label();
                span.barlineOverride = g.calcBarlineOverride();
 
                tagged.push_back({ std::move(span), SortKey{cFirst, depth, encounter++} });
 
                first = first.value_or(cFirst);
                last  = cLast;
            } else {
                return std::nullopt; // unsupported content element
            }
        }
 
        if (!first || !last) {
            return std::optional<std::pair<size_t,size_t>>{}; // success, but no staves
        }
        return std::make_pair(*first, *last);
    };
 
    auto rootRange = walk(walk, content, /*depth*/0);
    if (!rootRange) {
        return std::nullopt;
    }
    // Empty root content is allowed; it simply produces an empty spans vector.
 
    std::stable_sort(tagged.begin(), tagged.end(),
        [](const TaggedSpan& a, const TaggedSpan& b)
        {
            if (a.key.start != b.key.start) return a.key.start < b.key.start;
            if (a.key.depth != b.key.depth) return a.key.depth < b.key.depth;
            return a.key.encounter < b.key.encounter;
        });
 
    spans.reserve(tagged.size());
    for (auto& t : tagged) spans.push_back(std::move(t.span));
    return spans;
}
 
[[nodiscard]] inline std::vector<LayoutSpan>
buildDefaultLayoutSpans(const Array<Part>& parts)
{
    std::vector<LayoutSpan> result;
    size_t staffIdx = 0;
 
    for (const auto& part : parts) {
        const size_t numStaves = static_cast<size_t>(part.staves());
        if (numStaves == 0) {
            continue;
        }
        size_t staffDepth = 1;
        bool staffNameNeeded = true;
        if (numStaves > 1) {
            LayoutSpan groupSpan;
            groupSpan.depth = 0;
            groupSpan.kind = LayoutSpan::Kind::Group;
            groupSpan.symbol = LayoutSymbol::Brace;
            groupSpan.startIndex = staffIdx;
            groupSpan.endIndex = staffIdx + numStaves - 1;
            groupSpan.label = part.name();
            groupSpan.barlineOverride = StaffGroupBarlineOverride::Unified;
            staffNameNeeded = false;
            result.emplace_back(std::move(groupSpan));
        }
        for (size_t x = 0; x < numStaves; x++) {
            LayoutSpan staffSpan;
            staffSpan.depth = staffDepth;
            staffSpan.kind = LayoutSpan::Kind::Staff;
            staffSpan.startIndex = staffIdx;
            staffSpan.endIndex = staffIdx;
            staffSpan.barlineOverride = StaffGroupBarlineOverride::None;
            if (staffNameNeeded) {
                staffSpan.label = part.name();
            }
            result.emplace_back(std::move(staffSpan));
            staffIdx++;
        }
    }
 
    return result;
}
 
} // namespace mnx::util