CommonClasses.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 <utility>
#include <numeric>
#include <stdexcept>
#include <limits>
#include <type_traits>
 
#include "BaseTypes.h"
#include "Enumerations.h"
 
namespace mnx {
 
class Fermata : public Object
{
public:
    using Object::Object;
 
    MNX_OPTIONAL_PROPERTY_WITH_DEFAULT(FermataDuration, duration, FermataDuration::Auto);       
    MNX_OPTIONAL_PROPERTY_WITH_DEFAULT(Orientation, orient, Orientation::Auto);                 
    MNX_OPTIONAL_PROPERTY_WITH_DEFAULT(MarkingUpDownAuto, pointing, MarkingUpDownAuto::Auto);   
    MNX_OPTIONAL_PROPERTY_WITH_DEFAULT(FermataSymbol, symbol, FermataSymbol::Normal);           
};
 
struct [[nodiscard]] FractionValue
{
    using NumType = unsigned;
    static_assert(std::is_integral<NumType>::value, "FractionValue::NumType must be an integral type");
 
private:
    NumType m_num = 0; 
    NumType m_den = 1; 
 
    template<typename T = NumType,
             typename std::enable_if_t<std::is_signed<T>::value, int> = 0>
    constexpr void normalizeSign()
    {
        if (m_den < 0) {
            m_den = -m_den;
            m_num = -m_num;
        }
    }
 
    // Unsigned case: no-op, never even sees m_den < 0
    template<typename T = NumType,
             typename std::enable_if_t<!std::is_signed<T>::value, int> = 0>
    constexpr void normalizeSign() {}
 
public:
    constexpr FractionValue() = default;
 
    constexpr FractionValue(NumType num, NumType den)
        : m_num(num), m_den(den)
    {
        if (m_den == 0) {
            throw std::invalid_argument("FractionValue: denominator must not be zero.");
        }
        normalizeSign();
    }
 
    constexpr FractionValue(NumType value) : m_num(value), m_den(1) {}
 
    [[nodiscard]] constexpr NumType numerator() const noexcept { return m_num; }
 
    [[nodiscard]] constexpr NumType denominator() const noexcept { return m_den; }
 
    [[nodiscard]] constexpr NumType quotient() const
    {
        return m_num / m_den;
    }
 
    constexpr FractionValue remainder() const
    {
        FractionValue result;
        result.m_num = m_num % m_den;
        result.m_den = m_den;
        return result;
    }
 
    static constexpr FractionValue max() noexcept
    {
        return FractionValue((std::numeric_limits<NumType>::max)());
    }
 
    [[nodiscard]] constexpr double toDouble() const {
        return double(m_num) / double(m_den);
    }
 
    constexpr FractionValue& operator+=(const FractionValue& rhs)
    {
        // a/b + c/d = (ad + bc)/bd
        m_num = m_num * rhs.m_den + rhs.m_num * m_den;
        m_den = m_den * rhs.m_den;
        reduce();
        return *this;
    }
 
    constexpr FractionValue& operator-=(const FractionValue& rhs)
    {
        // a/b - c/d = (ad - bc)/bd
        m_num = m_num * rhs.m_den - rhs.m_num * m_den;
        m_den = m_den * rhs.m_den;
        reduce();
        return *this;
    }
 
    constexpr FractionValue& operator*=(const FractionValue& rhs)
    {
        m_num = m_num * rhs.m_num;
        m_den = m_den * rhs.m_den;
        reduce();
        return *this;
    }
 
    constexpr FractionValue& operator/=(const FractionValue& rhs)
    {
        if (rhs.m_num == 0) {
            throw std::invalid_argument("Division by zero FractionValue.");
        }
        m_num = m_num * rhs.m_den;
        m_den = m_den * rhs.m_num;
        reduce();
        return *this;
    }
 
    constexpr void reduce()
    {
        const NumType g = std::gcd(m_num, m_den);
        if (g > 1) {
            m_num /= g;
            m_den /= g;
        }
        normalizeSign();
    }
 
    constexpr FractionValue reduced() const
    {
        auto result = *this;
        result.reduce();
        return result;
    }
 
    constexpr bool expressWithDenominator(NumType targetDenominator)
    {
        if (targetDenominator == 0) {
            // Cannot express anything with denominator 0.
            return false;
        }
 
        // Zero fraction: 0/d is expressible as 0/targetDenominator.
        if (m_num == 0) {
            m_den = targetDenominator;
            return true;
        }
 
        // Reduce the fraction logically: m_num/m_den -> (numRed/denRed).
        // We don't actually have to store the reduced form; just use it to
        // check compatibility and compute the new numerator.
        const NumType g = std::gcd(m_num, m_den);
        const NumType denRed = m_den / g;
        const NumType numRed = m_num / g;   // sign preserved
 
        // For an integer representation with the requested denominator to exist
        // (while preserving the value), the reduced denominator must divide
        // targetDenominator exactly.
        if (targetDenominator % denRed != 0) {
            return false;  // No integer scaling factor exists.
        }
 
        const NumType factor = targetDenominator / denRed;
 
        // Apply the scaling to the reduced numerator and store the new form.
        m_num = numRed * factor;
        m_den = targetDenominator;
 
        normalizeSign();
 
        return true;
    }
};
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
 
// ------------------------------------------------------------
// Non-member arithmetic operators
// ------------------------------------------------------------
 
[[nodiscard]] constexpr FractionValue operator+(FractionValue lhs, const FractionValue& rhs)
{
    lhs += rhs;
    return lhs;
}
 
[[nodiscard]] constexpr FractionValue operator-(FractionValue lhs, const FractionValue& rhs)
{
    lhs -= rhs;
    return lhs;
}
 
[[nodiscard]] constexpr FractionValue operator*(FractionValue lhs, const FractionValue& rhs)
{
    lhs *= rhs;
    return lhs;
}
 
[[nodiscard]] constexpr FractionValue operator/(FractionValue lhs, const FractionValue& rhs)
{
    lhs /= rhs;
    return lhs;
}
 
// ------------------------------------------------------------
// Comparison operators
// ------------------------------------------------------------
 
[[nodiscard]] constexpr bool operator==(const FractionValue& a, const FractionValue& b)
{
    return a.numerator() * b.denominator() == b.numerator() * a.denominator();
}
 
[[nodiscard]] constexpr bool operator!=(const FractionValue& a, const FractionValue& b)
{
    return !(a == b);
}
 
[[nodiscard]] constexpr bool operator<(const FractionValue& a, const FractionValue& b)
{
    return a.numerator() * b.denominator() < b.numerator() * a.denominator();
}
 
[[nodiscard]] constexpr bool operator<=(const FractionValue& a, const FractionValue& b)
{
    return !(b < a);
}
 
[[nodiscard]] constexpr bool operator>(const FractionValue& a, const FractionValue& b)
{
    return b < a;
}
 
[[nodiscard]] constexpr bool operator>=(const FractionValue& a, const FractionValue& b)
{
    return !(a < b);
}
 
#endif // DOXYGEN_SHOULD_IGNORE_THIS
 
class Fraction : private Array<unsigned>
{
private:
    using NumType = FractionValue::NumType;
    using ArrayType = Array<NumType>;
 
    static constexpr size_t NUMERATOR_INDEX = 0;
    static constexpr size_t DENOMINATOR_INDEX = 1;
 
public:    
    Fraction(const std::shared_ptr<json>& root, json_pointer pointer)
        : ArrayType(root, pointer)
    {
        if (size() != 2) {
            throw std::invalid_argument("mnx::Fraction must have exactly 2 elements.");
        }
    }
 
    Fraction(Base& parent, std::string_view key, const FractionValue& value)
        : ArrayType(parent, key)
    {
        push_back(value.numerator());
        push_back(value.denominator());
    }
 
    [[nodiscard]] operator FractionValue() const
    {
        return FractionValue(numerator(), denominator());
    }
 
    MNX_ARRAY_ELEMENT_PROPERTY(NumType, numerator, NUMERATOR_INDEX);        
    MNX_ARRAY_ELEMENT_PROPERTY(NumType, denominator, DENOMINATOR_INDEX);    
 
    friend class Base;
};
 
class IdPair : public Object
{
public:
    struct Required
    {
        std::string startId;    
        std::string endId;      
    };
 
    IdPair(const std::shared_ptr<json>& root, json_pointer pointer)
        : Object(root, pointer)
    {
    }
    
    IdPair(Base& parent, std::string_view key, const std::string& startId, const std::string& endId)
        : Object(parent, key)
    {
        set_start(startId);
        set_end(endId);
    }
 
    operator Required() const { return { start(), end() }; }
 
    static Required make(const std::string& startId, const std::string& endId) { return { startId, endId }; }
 
    MNX_REQUIRED_PROPERTY(std::string, start);          
    MNX_REQUIRED_PROPERTY(std::string, end);            
};
 
class RhythmicPosition : public Object
{
public:
    struct Required
    {
        FractionValue position{}; 
    };
 
    RhythmicPosition(const std::shared_ptr<json>& root, json_pointer pointer)
        : Object(root, pointer)
    {
    }
    
    RhythmicPosition(Base& parent, std::string_view key, const FractionValue& position)
        : Object(parent, key)
    {
        create_fraction(position);
    }
    
    RhythmicPosition(const FractionValue& position)
        : Object()
    {
        create_fraction(position);
    }
 
    operator Required() const { return { fraction() }; }
 
    static Required make(const FractionValue& position) { return { position }; }
 
    [[nodiscard]] static int compare(const RhythmicPosition& lhs,
                                     const RhythmicPosition& rhs,
                                     bool rhsIncludesTrailingGrace = false);
 
    MNX_REQUIRED_CHILD(
        Fraction, fraction,
        (const FractionValue&, value)); 
    MNX_OPTIONAL_PROPERTY(unsigned, graceIndex);        
};
 
class MeasureRhythmicPosition : public Object
{
public:
    struct Required
    {
        std::string measureId;    
        FractionValue position{}; 
    };
 
    MeasureRhythmicPosition(const std::shared_ptr<json>& root, json_pointer pointer)
        : Object(root, pointer)
    {
    }
    
    MeasureRhythmicPosition(Base& parent, std::string_view key, const std::string& measureId, const FractionValue& position)
        : Object(parent, key)
    {
        set_measure(measureId);
        create_position(position);
    }
    
    MeasureRhythmicPosition(const std::string& measureId, const FractionValue& position)
        : Object()
    {
        set_measure(measureId);
        create_position(position);
    }
 
    operator Required() const { return { measure(), position().fraction() }; }
 
    static Required make(const std::string& measureId, const FractionValue& position) { return { measureId, position }; }
 
    MNX_REQUIRED_PROPERTY(std::string, measure);    
    MNX_REQUIRED_CHILD(
        RhythmicPosition, position,
        (const FractionValue&, position)); 
};
 
class Interval : public Object
{
public:
    struct Required
    {
        int staffDistance{};    
        int halfSteps{};        
    };
 
    Interval(const std::shared_ptr<json>& root, json_pointer pointer)
        : Object(root, pointer)
    {
    }
 
    Interval(Base& parent, std::string_view key, int staffDistance, int halfSteps)
        : Object(parent, key)
    {
        set_halfSteps(halfSteps);
        set_staffDistance(staffDistance);
    }
 
    operator Required() const { return { staffDistance(), halfSteps() }; }
 
    static Required make(int staffDistance, int halfSteps) { return { staffDistance, halfSteps }; }
 
    MNX_REQUIRED_PROPERTY(int, halfSteps);      
    MNX_REQUIRED_PROPERTY(int, staffDistance);  
};
 
class KeySignature : public Object
{
public:
    struct Required
    {
        int fifths{};           
    };
 
    KeySignature(const std::shared_ptr<json>& root, json_pointer pointer)
        : Object(root, pointer)
    {
    }
 
    operator Required() const { return { fifths() }; }
 
    static Required make(int fifths) { return { fifths }; }
 
    KeySignature(Base& parent, std::string_view key, int fifths)
        : Object(parent, key)
    {
        set_fifths(fifths);
    }
 
    MNX_OPTIONAL_PROPERTY(std::string, color);                  
    MNX_REQUIRED_PROPERTY(int, fifths);                         
};
 
class NoteValue : public Object
{
public:
    struct Required
    {
        NoteValueBase base{};   
        unsigned dots{};        
    };
 
    NoteValue(const std::shared_ptr<json>& root, json_pointer pointer)
        : Object(root, pointer)
    {
    }
 
    NoteValue(Base& parent, std::string_view key, NoteValueBase base, unsigned dots = 0)
        : Object(parent, key)
    {
        set_base(base);
        if (dots) {
            set_dots(dots);
        }
    }
 
    operator Required() const { return { base(), dots() }; }
 
    static Required make(NoteValueBase base, unsigned dots = 0) { return { base, dots }; }
 
    [[nodiscard]] operator FractionValue() const;
 
    MNX_REQUIRED_PROPERTY(NoteValueBase, base);                 
    MNX_OPTIONAL_PROPERTY_WITH_DEFAULT(unsigned, dots, 0);      
 
    [[nodiscard]] unsigned calcNumberOfFlags() const;
};
 
class NoteValueQuantity : public Object
{
public:
    struct Required
    {
        unsigned count{};               
        NoteValue::Required noteValue{};  
    };
 
    NoteValueQuantity(const std::shared_ptr<json>& root, json_pointer pointer)
        : Object(root, pointer)
    {
    }
 
    NoteValueQuantity(Base& parent, std::string_view key, unsigned count, const NoteValue::Required& noteValue)
        : Object(parent, key)
    {
        set_multiple(count);
        create_duration(noteValue.base, noteValue.dots);
    }
 
    operator Required() const { return { multiple(), duration() }; }
 
    static Required make(unsigned count, const NoteValue::Required& noteValue) { return { count, noteValue }; }
 
    [[nodiscard]] operator FractionValue() const
    { return multiple() * duration(); }
 
    MNX_REQUIRED_CHILD(NoteValue, duration,
        (NoteValueBase, base), (unsigned, dots)); 
    MNX_REQUIRED_PROPERTY(unsigned, multiple);                  
};
 
class TimeSignature : public Object
{
public:
    struct Required
    {
        int count{};             
        TimeSignatureUnit unit{}; 
    };
 
    TimeSignature(const std::shared_ptr<json>& root, json_pointer pointer)
        : Object(root, pointer)
    {
    }
 
    TimeSignature(Base& parent, std::string_view key, int count, TimeSignatureUnit unit)
        : Object(parent, key)
    {
        set_count(count);
        set_unit(unit);
    }
 
    operator Required() const { return { count(), unit() }; }
 
    static Required make(int count, TimeSignatureUnit unit) { return { count, unit }; }
 
    [[nodiscard]] operator FractionValue() const
    { return FractionValue(static_cast<FractionValue::NumType>(count()), static_cast<FractionValue::NumType>(unit())); }
 
    MNX_REQUIRED_PROPERTY(int, count);                
    MNX_REQUIRED_PROPERTY(TimeSignatureUnit, unit);   
};
 
} // namespace mnx