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 <functional>
#include <memory>
#include <ostream>
#include <span>
#include <stdexcept>
#include <string>
#include <string_view>
#include <vector>
#include <utility>
 
#include "denigma/io/random_access_reader.h"
 
namespace denigma {
 
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 };
    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{};
};
 
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;
    }
 
private:
    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