feat(core/compression): add compression converters, router and factory

.github/workflows/cmake-single-platform.yml

@@ -16,9 +16,13 @@ jobs:
     steps:
     - uses: actions/checkout@v4
 
+    - name: Install System Dependencies
+      run: |
+        sudo apt-get update
+        sudo apt-get install -y clang-format pkg-config libzip-dev
+
     - name: Check Code Formatting
       run: |
-        sudo apt-get update && sudo apt-get install -y clang-format
         find core cli -type f \( -name "*.cpp" -o -name "*.hpp" -o -name "*.h" \) | xargs -r clang-format --dry-run --Werror
 
     - name: Configure CMake

cli/main.cpp

@@ -1 +1,81 @@
-int main(int argc, char **argv) { return 0; }
+#include "retroforge/bootstrap/CompressionEngineFactory.hpp"
+#include "retroforge/bootstrap/IdentificationEngineFactory.hpp"
+#include "retroforge/models/ConversionJob.hpp"
+#include <iostream>
+#include <string>
+#include <vector>
+
+using namespace retroforge;
+
+std::string nome_do_console(models::Console c) {
+    switch (c) {
+    case models::Console::PS1:
+        return "PS1";
+    case models::Console::PS2:
+        return "PS2";
+    case models::Console::PSP:
+        return "PSP";
+    case models::Console::PSP_PBP:
+        return "PSP (EBOOT.PBP)";
+    case models::Console::GameCube:
+        return "GameCube";
+    case models::Console::Dreamcast:
+        return "Dreamcast (Limpo)";
+    case models::Console::DreamcastModificado:
+        return "Dreamcast (Modificado)";
+    case models::Console::Genesis:
+        return "Mega Drive / Genesis";
+    case models::Console::SNES:
+        return "SNES";
+    case models::Console::SegaCD:
+        return "Sega CD";
+    case models::Console::Saturn:
+        return "Sega Saturn";
+    case models::Console::Desconhecido:
+        return "Desconhecido";
+    default:
+        return "Outro";
+    }
+}
+
+int main() {
+    auto identificador = bootstrap::IdentificationEngineFactory::criar();
+    auto roteador = bootstrap::CompressionEngineFactory::criar();
+
+    std::vector<std::string> arquivos_para_testar = {};
+
+    std::cout << "============================================\n";
+    std::cout << " PROTÓTIPO FUNCIONAL - MAIN RETROFORGE \n";
+    std::cout << "============================================\n\n";
+
+    for (const auto &caminho : arquivos_para_testar) {
+        std::cout << "[ARQUIVO] " << caminho << "\n";
+
+        auto console = identificador.identify(caminho);
+        std::cout << "  -> Identificado como: " << nome_do_console(console) << "\n";
+
+        if (console == models::Console::Desconhecido) {
+            std::cout << "  -> Ignorando arquivo. Nao reconhecido pelos detectores.\n\n";
+            continue;
+        }
+
+        auto job = std::make_shared<models::ConversionJob>(caminho, console);
+        auto resultado = roteador.rotear(job);
+
+        std::cout << "  -> Status do Roteador: ";
+        switch (resultado) {
+        case compression::ResultadoRoteamento::ConversaoIniciada:
+            std::cout << "Conversao iniciada/concluida com sucesso.\n";
+            break;
+        case compression::ResultadoRoteamento::BloqueadoPorSeguranca:
+            std::cout << "BLOQUEADO por seguranca (Trava do Smart Context ativada).\n";
+            break;
+        case compression::ResultadoRoteamento::ConsoleNaoSuportado:
+            std::cout << "Falha na compressao ou sem rota registrada.\n";
+            break;
+        }
+        std::cout << "\n";
+    }
+
+    return 0;
+}

core/CMakeLists.txt

@@ -1,3 +1,14 @@
+if(UNIX AND NOT APPLE)
+    find_package(PkgConfig REQUIRED)
+    pkg_check_modules(LIBZIP REQUIRED IMPORTED_TARGET libzip)
+
+    if(TARGET PkgConfig::LIBZIP AND NOT TARGET libzip::zip)
+        add_library(libzip::zip ALIAS PkgConfig::LIBZIP)
+    endif()
+else()
+    find_package(libzip CONFIG REQUIRED)
+endif()
+
 file(GLOB_RECURSE CORE_SOURCES 
     CONFIGURE_DEPENDS 
     "${CMAKE_CURRENT_SOURCE_DIR}/src/*.cpp"
@@ -25,4 +36,8 @@ target_include_directories(retroforge_core PUBLIC
     ${CMAKE_BINARY_DIR}/generated
 )
 
-target_compile_features(retroforge_core PUBLIC cxx_std_20)
+target_compile_features(retroforge_core PUBLIC cxx_std_20)
+
+target_link_libraries(retroforge_core PRIVATE
+    libzip::zip
+)

core/include/retroforge/bootstrap/CompressionEngineFactory.hpp

@@ -0,0 +1,12 @@
+#pragma once
+
+#include "retroforge/compression/CompressionRouter.hpp"
+
+namespace retroforge::bootstrap {
+
+class CompressionEngineFactory {
+  public:
+    static compression::CompressionRouter criar();
+};
+
+} // namespace retroforge::bootstrap

core/include/retroforge/compression/CompressionRouter.hpp

@@ -0,0 +1,23 @@
+#pragma once
+
+#include "retroforge/compression/ICompressionStrategy.hpp"
+#include "retroforge/models/Console.hpp"
+#include "retroforge/models/ConversionJob.hpp"
+#include <memory>
+#include <unordered_map>
+
+namespace retroforge::compression {
+
+enum class ResultadoRoteamento { ConversaoIniciada, BloqueadoPorSeguranca, ConsoleNaoSuportado };
+
+class CompressionRouter {
+  public:
+    void register_strategy(models::Console console,
+                           std::shared_ptr<ICompressionStrategy> estrategia);
+    ResultadoRoteamento rotear(const std::shared_ptr<models::ConversionJob> &job);
+
+  private:
+    std::unordered_map<models::Console, std::shared_ptr<ICompressionStrategy>> estrategias_;
+};
+
+} // namespace retroforge::compression

core/include/retroforge/compression/ICompressionStrategy.hpp

@@ -0,0 +1,18 @@
+#pragma once
+
+#include "retroforge/models/ConversionJob.hpp"
+
+#include <memory>
+
+namespace retroforge::compression {
+
+class ICompressionStrategy {
+  public:
+    virtual ~ICompressionStrategy() = default;
+
+    virtual bool comprimir(const std::shared_ptr<models::ConversionJob> &job) = 0;
+
+    virtual std::string extensao_saida() const = 0;
+};
+
+} // namespace retroforge::compression

core/include/retroforge/compression/converters/ChdmanConverter.hpp

@@ -0,0 +1,13 @@
+#pragma once
+
+#include "retroforge/compression/ICompressionStrategy.hpp"
+
+namespace retroforge::compression::converters {
+
+class ChdmanConverter : public ICompressionStrategy {
+  public:
+    bool comprimir(const std::shared_ptr<models::ConversionJob> &job) override;
+    std::string extensao_saida() const override { return ".chd"; }
+};
+
+} // namespace retroforge::compression::converters

core/include/retroforge/compression/converters/DolphinToolConverter.hpp

@@ -0,0 +1,13 @@
+#pragma once
+
+#include "retroforge/compression/ICompressionStrategy.hpp"
+
+namespace retroforge::compression::converters {
+
+class DolphinToolConverter : public ICompressionStrategy {
+  public:
+    bool comprimir(const std::shared_ptr<models::ConversionJob> &job) override;
+    std::string extensao_saida() const override { return ".rvz"; }
+};
+
+} // namespace retroforge::compression::converters

core/include/retroforge/compression/converters/LibzipPacker.hpp

@@ -0,0 +1,13 @@
+#pragma once
+
+#include "retroforge/compression/ICompressionStrategy.hpp"
+
+namespace retroforge::compression::converters {
+
+class LibzipPacker : public ICompressionStrategy {
+  public:
+    bool comprimir(const std::shared_ptr<models::ConversionJob> &job) override;
+    std::string extensao_saida() const override { return ".zip"; }
+};
+
+} // namespace retroforge::compression::converters

core/include/retroforge/compression/converters/MaxcsoConverter.hpp

@@ -0,0 +1,13 @@
+#pragma once
+
+#include "retroforge/compression/ICompressionStrategy.hpp"
+
+namespace retroforge::compression::converters {
+
+class MaxcsoConverter : public ICompressionStrategy {
+  public:
+    bool comprimir(const std::shared_ptr<models::ConversionJob> &job) override;
+    std::string extensao_saida() const override { return ".cso"; }
+};
+
+} // namespace retroforge::compression::converters

core/include/retroforge/io/BinaryFileReader.hpp

@@ -22,4 +22,5 @@ class BinaryFileReader {
     std::ifstream arquivo_;
     std::uintmax_t tamanho_total_;
 };
+
 } // namespace retroforge::io

core/include/retroforge/models/ConversionJob.hpp

@@ -0,0 +1,30 @@
+#pragma once
+
+#include "retroforge/models/Console.hpp"
+
+#include <atomic>
+#include <string>
+
+namespace retroforge::models {
+
+class ConversionJob {
+  public:
+    ConversionJob(std::string caminho_origem, Console console_alvo);
+
+    const std::string &caminho_origem() const { return caminho_origem_; };
+    Console console_alvo() const { return console_alvo_; }
+
+    void set_progresso(int progresso) { progresso_.store(progresso); };
+    int progresso() { return progresso_.load(); };
+
+    void cancelar() { cancelado_.store(true); };
+    bool is_cancelado() { return cancelado_.load(); };
+
+  private:
+    std::string caminho_origem_;
+    Console console_alvo_;
+    std::atomic<int> progresso_{0};
+    std::atomic<bool> cancelado_{false};
+};
+
+} // namespace retroforge::models

core/include/retroforge/process/ExternalProcessHandle.hpp

@@ -22,4 +22,5 @@ class ExternalProcessHandle {
 
     std::unique_ptr<FILE, FechadorDeProcesso> handle_;
 };
+
 } // namespace retroforge::process

core/src/bootstrap/CompressionEngineFactory.cpp

@@ -0,0 +1,39 @@
+#include "retroforge/bootstrap/CompressionEngineFactory.hpp"
+
+#include "retroforge/compression/converters/ChdmanConverter.hpp"
+#include "retroforge/compression/converters/DolphinToolConverter.hpp"
+#include "retroforge/compression/converters/LibzipPacker.hpp"
+#include "retroforge/compression/converters/MaxcsoConverter.hpp"
+
+namespace retroforge::bootstrap {
+
+using models::Console;
+
+compression::CompressionRouter CompressionEngineFactory::criar() {
+    compression::CompressionRouter roteador;
+
+    auto chdman = std::make_shared<compression::converters::ChdmanConverter>();
+
+    roteador.register_strategy(Console::PS1, chdman);
+    roteador.register_strategy(Console::PS2, chdman);
+    roteador.register_strategy(Console::SegaCD, chdman);
+    roteador.register_strategy(Console::Saturn, chdman);
+    roteador.register_strategy(Console::Dreamcast, chdman);
+
+    auto dolphin_tool = std::make_shared<compression::converters::DolphinToolConverter>();
+
+    roteador.register_strategy(Console::GameCube, dolphin_tool);
+
+    auto maxcso = std::make_shared<compression::converters::MaxcsoConverter>();
+
+    roteador.register_strategy(Console::PSP, maxcso);
+
+    auto libzip = std::make_shared<compression::converters::LibzipPacker>();
+
+    roteador.register_strategy(Console::SNES, libzip);
+    roteador.register_strategy(Console::Genesis, libzip);
+
+    return roteador;
+}
+
+} // namespace retroforge::bootstrap

core/src/compression/CompressionRouter.cpp

@@ -0,0 +1,28 @@
+#include "retroforge/compression/CompressionRouter.hpp"
+
+namespace retroforge::compression {
+
+using models::Console;
+
+void CompressionRouter::register_strategy(Console console,
+                                          std::shared_ptr<ICompressionStrategy> estrategia) {
+    estrategias_[console] = std::move(estrategia);
+}
+
+ResultadoRoteamento CompressionRouter::rotear(const std::shared_ptr<models::ConversionJob> &job) {
+    if (job->console_alvo() == Console::DreamcastModificado ||
+        job->console_alvo() == Console::PSP_PBP) {
+        return ResultadoRoteamento::BloqueadoPorSeguranca;
+    }
+
+    auto encontrado = estrategias_.find(job->console_alvo());
+    if (encontrado == estrategias_.end()) {
+        return ResultadoRoteamento::ConsoleNaoSuportado;
+    }
+
+    bool sucesso = encontrado->second->comprimir(job);
+    return sucesso ? ResultadoRoteamento::ConversaoIniciada
+                   : ResultadoRoteamento::ConsoleNaoSuportado;
+}
+
+} // namespace retroforge::compression