chords.h

/*
 * Copyright (C) 2026, 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 <vector>
 
#include "musx/musx.h"
 
namespace denigma {
namespace classify {
 
namespace chord {
 
enum class BassArrangement {
    Horizontal,
    Vertical,
    Diagonal
};
 
enum class Quality {
    Major,              
    Minor,              
    Augmented,          
    Diminished,         
    Dominant,           
    AugmentedSeventh,   
    MajorSeventh,       
    MinorSeventh,       
    DiminishedSeventh,  
    HalfDiminished,     
    MajorMinor,         
    MajorSixth,         
    MinorSixth,         
    DominantNinth,      
    MajorNinth,         
    MinorNinth,         
    DominantEleventh,   
    MajorEleventh,      
    MinorEleventh,      
    DominantThirteenth, 
    MajorThirteenth,    
    MinorThirteenth,    
    SuspendedSecond,    
    SuspendedFourth,    
    Pedal,              
    None,               
    Power               
};
 
struct Degree
{
    enum class Type {
        Add,    
        Remove, 
        Alter   
    };
 
    int value{};                
    int alteration{};           
    Type type{Type::Add};     
    bool impliedByText{};       
};
 
struct SuffixString
{
    enum class Position {
        Inline, 
        Above,  
        Below   
    };
 
    std::string text;                       
    Position position{Position::Inline};  
};
 
} // namespace chord
 
struct ChordSuffixClassification
{
    std::vector<chord::SuffixString> strings;
    std::optional<chord::Quality> quality;
    std::vector<chord::Degree> degrees;
    bool parenthesizeDegrees{};
    bool stackDegrees{};
    bool hasOuterParentheses{};
    bool hasUnrecognizedGlyphs{};
 
    std::string calcText() const;
};
 
struct ChordSymbolClassification
{
    music_theory::Pitch root;
    bool rootLowerCase{};
    bool showRoot{};
    ChordSuffixClassification suffix;
    bool showSuffix{};
    std::optional<music_theory::Pitch> bass;
    bool bassLowerCase{};
    std::optional<chord::BassArrangement> bassArrangement;
};
 
ChordSuffixClassification classifyChordSuffix(const musx::dom::MusxInstanceList<musx::dom::others::ChordSuffixElement>& suffix);
 
ChordSuffixClassification classifyChordSuffix();
 
struct ChordAssignmentClassification
{
    musx::dom::MusxInstance<musx::dom::details::ChordAssign> assignment;
    musx::util::Fraction position;
    ChordSymbolClassification classification;
};
 
std::optional<ChordSymbolClassification> classifyChordSymbol(const musx::dom::MusxInstance<musx::dom::details::ChordAssign>& assignment,
    const musx::dom::MusxInstance<musx::dom::KeySignature>& keySignature, musx::dom::KeySignature::KeyContext keyContext);
 
std::vector<ChordAssignmentClassification> classifyChordAssignments(const musx::dom::MusxInstanceList<musx::dom::details::ChordAssign>& assignments,
    const musx::dom::MusxInstance<musx::dom::KeySignature>& keySignature, musx::dom::KeySignature::KeyContext keyContext);
 
} // namespace classify
} // namespace denigma