conversion.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 <cassert>
#include <cstddef>
#include <cstring>
#include <functional>
#include <memory>
#include <optional>
#include <ostream>
#include <span>
#include <sstream>
#include <stdexcept>
#include <string>
#include <string_view>
#include <utility>
#include <vector>
 
#include "denigma/io/random_access_reader.h"
 
namespace denigma {
 
namespace classify {
class GapCollector;
} // namespace classify
 
enum class FormatId {
    Musx,       
    EnigmaXml,  
    MnxJson,    
    MusicXml,   
    MssXml,     
    Svg         
};
 
enum class MessageSeverity {
    Info,
    Warning,
    Error,
    Verbose
};
 
struct Diagnostic
{
    MessageSeverity severity{MessageSeverity::Info}; 
    std::string message;                 
};
 
struct CommonOptions
{
    std::string sourceName;
    bool validate{true};
    bool verbose{false};
    bool quiet{false};
    bool allFontsAvailable{false};
    classify::GapCollector* gapCollector{};
    std::function<void(MessageSeverity severity, std::string_view message)> logCallback = [](MessageSeverity, std::string_view) {};
};
 
class IOptions
{
public:
    virtual ~IOptions() = default;      
};
 
struct ConversionRequest
{
    const IOptions* options{};
};
 
class ConversionResult
{
public:
    [[nodiscard]] std::span<const Diagnostic> diagnostics() const noexcept { return m_diagnostics; }
 
    [[nodiscard]] bool hasError() const noexcept { return m_hasError; }
 
    explicit operator bool() const noexcept { return !hasError(); }
 
    void addDiagnostic(MessageSeverity severity, std::string message) { addDiagnostic(Diagnostic{severity, std::move(message)}); }
 
    void addDiagnostic(Diagnostic diagnostic)
    {
        m_hasError = m_hasError || diagnostic.severity == MessageSeverity::Error;
        m_diagnostics.push_back(std::move(diagnostic));
    }
 
private:
    std::vector<Diagnostic> m_diagnostics;
    bool m_hasError{};
};
 
struct ConversionOutput
{
    std::string suggestedName;
    std::vector<std::byte> data;
};
 
class ConversionArtifact
{
public:
    ConversionArtifact(ConversionResult result, std::vector<ConversionOutput> outputs)
        : m_result(std::move(result)), m_outputs(std::move(outputs))
    {}
 
    [[nodiscard]] const ConversionResult& result() const noexcept { return m_result; }
 
    [[nodiscard]] std::span<const ConversionOutput> outputs() const noexcept { return m_outputs; }
 
    [[nodiscard]] bool hasError() const noexcept { return m_result.hasError(); }
 
    explicit operator bool() const noexcept { return static_cast<bool>(m_result); }
 
private:
    ConversionResult m_result;
    std::vector<ConversionOutput> m_outputs;
};
 
template <typename OptionsT>
OptionsT optionsFromRequest(const ConversionRequest& request, std::string_view converterName)
{
    if (!request.options) {
        return {};
    }
    if (const auto* options = dynamic_cast<const OptionsT*>(request.options)) {
        return *options;
    }
    assert(false && "incompatible conversion options");
    throw std::invalid_argument(std::string(converterName) + " received incompatible conversion options.");
}
 
class IConverter
{
public:
    virtual ~IConverter() = default;    
 
    [[nodiscard]] virtual FormatId sourceFormat() const = 0;
    [[nodiscard]] virtual FormatId targetFormat() const = 0;
 
    virtual ConversionResult convert(std::span<const std::byte> input, std::ostream& output, const ConversionRequest& request = {}) const = 0;
};
 
class IReaderConverter
{
public:
    virtual ~IReaderConverter() = default;    
 
    [[nodiscard]] virtual FormatId sourceFormat() const = 0;
    [[nodiscard]] virtual FormatId targetFormat() const = 0;
 
    virtual ConversionResult convert(const IRandomAccessReader& input, std::ostream& output, const ConversionRequest& request = {}) const = 0;
};
 
using MultiOutputCallback = std::function<void(std::string_view suggestedName, std::span<const std::byte> data)>;
 
class IMultiOutputConverter
{
public:
    virtual ~IMultiOutputConverter() = default;    
 
    [[nodiscard]] virtual FormatId sourceFormat() const = 0;
    [[nodiscard]] virtual FormatId targetFormat() const = 0;
 
    virtual ConversionResult convert(
        std::span<const std::byte> input, const MultiOutputCallback& outputCallback, const ConversionRequest& request = {}) const = 0;
};
 
class IReaderMultiOutputConverter
{
public:
    virtual ~IReaderMultiOutputConverter() = default;    
 
    [[nodiscard]] virtual FormatId sourceFormat() const = 0;
    [[nodiscard]] virtual FormatId targetFormat() const = 0;
 
    virtual ConversionResult convert(
        const IRandomAccessReader& input, const MultiOutputCallback& outputCallback, const ConversionRequest& request = {}) const = 0;
};
 
class ConverterRegistry
{
public:
    void add(std::unique_ptr<IConverter> converter)
    {
        if (!converter) {
            throw std::invalid_argument("converter cannot be null");
        }
        m_converters.emplace_back(std::move(converter));
    }
 
    void add(std::unique_ptr<IMultiOutputConverter> converter)
    {
        if (!converter) {
            throw std::invalid_argument("converter cannot be null");
        }
        m_multiOutputConverters.emplace_back(std::move(converter));
    }
 
    void add(std::unique_ptr<IReaderConverter> converter)
    {
        if (!converter) {
            throw std::invalid_argument("converter cannot be null");
        }
        m_readerConverters.emplace_back(std::move(converter));
    }
 
    void add(std::unique_ptr<IReaderMultiOutputConverter> converter)
    {
        if (!converter) {
            throw std::invalid_argument("converter cannot be null");
        }
        m_readerMultiOutputConverters.emplace_back(std::move(converter));
    }
 
    [[nodiscard]] const IConverter* find(FormatId sourceFormat, FormatId targetFormat) const
    {
        for (const auto& converter : m_converters) {
            if (converter->sourceFormat() == sourceFormat && converter->targetFormat() == targetFormat) {
                return converter.get();
            }
        }
        return nullptr;
    }
 
    [[nodiscard]] const IMultiOutputConverter* findMultiOutput(FormatId sourceFormat, FormatId targetFormat) const
    {
        for (const auto& converter : m_multiOutputConverters) {
            if (converter->sourceFormat() == sourceFormat && converter->targetFormat() == targetFormat) {
                return converter.get();
            }
        }
        return nullptr;
    }
 
    [[nodiscard]] const IReaderConverter* findReader(FormatId sourceFormat, FormatId targetFormat) const
    {
        for (const auto& converter : m_readerConverters) {
            if (converter->sourceFormat() == sourceFormat && converter->targetFormat() == targetFormat) {
                return converter.get();
            }
        }
        return nullptr;
    }
 
    [[nodiscard]] const IReaderMultiOutputConverter* findReaderMultiOutput(FormatId sourceFormat, FormatId targetFormat) const
    {
        for (const auto& converter : m_readerMultiOutputConverters) {
            if (converter->sourceFormat() == sourceFormat && converter->targetFormat() == targetFormat) {
                return converter.get();
            }
        }
        return nullptr;
    }
 
    [[nodiscard]] ConversionArtifact convert(
        FormatId sourceFormat, FormatId targetFormat, std::span<const std::byte> input, const ConversionRequest& request = {}) const
    {
        if (const auto* converter = find(sourceFormat, targetFormat)) {
            return collectSingleOutput(*converter, input, request);
        }
        if (const auto* converter = findMultiOutput(sourceFormat, targetFormat)) {
            return collectMultipleOutputs(*converter, input, request);
        }
        return unsupportedConversion();
    }
 
    [[nodiscard]] ConversionArtifact convert(
        FormatId sourceFormat, FormatId targetFormat, const IRandomAccessReader& input, const ConversionRequest& request = {}) const
    {
        if (const auto* converter = findReader(sourceFormat, targetFormat)) {
            return collectSingleOutput(*converter, input, request);
        }
        if (const auto* converter = findReaderMultiOutput(sourceFormat, targetFormat)) {
            return collectMultipleOutputs(*converter, input, request);
        }
        return unsupportedConversion();
    }
 
private:
    template <typename Converter, typename Input>
    static ConversionArtifact collectSingleOutput(const Converter& converter, const Input& input, const ConversionRequest& request)
    {
        std::ostringstream output;
        auto result = converter.convert(input, output, request);
        auto text = output.str();
        std::vector<std::byte> data(text.size());
        if (!text.empty()) {
            std::memcpy(data.data(), text.data(), text.size());
        }
        std::vector<ConversionOutput> outputs;
        outputs.push_back({{}, std::move(data)});
        return {std::move(result), std::move(outputs)};
    }
 
    template <typename Converter, typename Input>
    static ConversionArtifact collectMultipleOutputs(const Converter& converter, const Input& input, const ConversionRequest& request)
    {
        std::vector<ConversionOutput> outputs;
        auto result = converter.convert(
            input,
            [&outputs](std::string_view suggestedName, std::span<const std::byte> data) {
                outputs.push_back({std::string(suggestedName), {data.begin(), data.end()}});
            },
            request);
        return {std::move(result), std::move(outputs)};
    }
 
    static ConversionArtifact unsupportedConversion()
    {
        ConversionResult result;
        result.addDiagnostic(MessageSeverity::Error, "No converter is registered for the requested formats.");
        return {std::move(result), {}};
    }
 
    std::vector<std::unique_ptr<IConverter>> m_converters;
    std::vector<std::unique_ptr<IMultiOutputConverter>> m_multiOutputConverters;
    std::vector<std::unique_ptr<IReaderConverter>> m_readerConverters;
    std::vector<std::unique_ptr<IReaderMultiOutputConverter>> m_readerMultiOutputConverters;
};
 
} // namespace denigma