BanksModule.cpp

#include "BanksModule.hpp"

#include <fstream>
#include <sstream>
#include <stdexcept>

#include <nlohmann/json.hpp>

namespace {

std::string ReadAllText(const std::string& fileName) {
    std::ifstream in(fileName, std::ios::in | std::ios::binary);
    if (!in) throw std::runtime_error("Unable to read file: " + fileName);
    std::ostringstream ss;
    ss << in.rdbuf();
    return ss.str();
}

} // namespace

BanksModule::BanksModule(ModuleDispatcher& moduleDispatcher)
    : dispatcher_(moduleDispatcher) {}

void BanksModule::Info(const std::vector<std::string>& args) {
    const std::string bankFileName = GetBankFileNameParam(args);
    auto bankFile = LoadBankFileOrThrow(bankFileName);

    BankInfoOutputObject output = BuildBankInfo(*bankFile);
    nlohmann::json j = output;
    dispatcher_.setModuleOutput(j.dump());
}

void BanksModule::Unpack(const std::vector<std::string>& args) {
    const std::string bankFileName = GetBankFileNameParam(args);
    const std::string packedFilePath = GetPackedFileParam(args);
    const auto targetDirOpt = GetThirdParam(args);

    // In the C# module, the 3rd parameter is optional; if omitted, we default to "." (current directory).
    const std::string targetDir = targetDirOpt.value_or(".");

    auto bankFile = LoadBankFileOrThrow(bankFileName);
    bankFile->extractPackedFile(packedFilePath, targetDir, /*extractToDirectory=*/true);

    dispatcher_.noModuleOutput();
}

void BanksModule::BatchUnpack(const std::vector<std::string>& args) {
    const std::string bankFileName = GetBankFileNameParam(args);
    const std::string batchInputFileName = GetBatchInputFileParam(args);
    const auto targetDirOpt = GetThirdParam(args);

    BatchInputObject batch = LoadBatchInputFileOrThrow(batchInputFileName);
    auto bankFile = LoadBankFileOrThrow(bankFileName);

    const bool unpackToDirectory = targetDirOpt.has_value();
    const std::string targetDir = targetDirOpt.value_or("");

    for (const auto& item : batch.items) {
        if (unpackToDirectory) {
            bankFile->extractPackedFile(item.internalPath, targetDir, /*extractToDirectory=*/true);
        } else {
            bankFile->extractPackedFile(item.internalPath, item.externalFile, /*extractToDirectory=*/false);
        }
    }

    dispatcher_.noModuleOutput();
}

void BanksModule::Repack(const std::vector<std::string>& args) {
    const std::string bankFileName = GetBankFileNameParam(args);
    const std::string packedFilePath = GetPackedFileParam(args);
    const auto sourceFileOpt = GetThirdParam(args);
    if (!sourceFileOpt.has_value()) {
        throw std::invalid_argument("Missing args[2] sourceFileName for BANK-R");
    }

    auto bankFile = LoadBankFileOrThrow(bankFileName);
    bankFile->replacePackedFile(packedFilePath, *sourceFileOpt);

    dispatcher_.noModuleOutput();
}

void BanksModule::BatchRepack(const std::vector<std::string>& args) {
    const std::string bankFileName = GetBankFileNameParam(args);
    const std::string batchInputFileName = GetBatchInputFileParam(args);

    BatchInputObject batch = LoadBatchInputFileOrThrow(batchInputFileName);
    auto bankFile = LoadBankFileOrThrow(bankFileName);

    for (const auto& item : batch.items) {
        bankFile->replacePackedFile(item.internalPath, item.externalFile);
    }

    dispatcher_.noModuleOutput();
}

std::string BanksModule::GetBankFileNameParam(const std::vector<std::string>& args) {
    if (args.size() < 1) throw std::invalid_argument("Missing args[0] bankFileName");
    return args[0];
}

std::string BanksModule::GetPackedFileParam(const std::vector<std::string>& args) {
    if (args.size() < 2) throw std::invalid_argument("Missing args[1] packedFilePath");
    return args[1];
}

std::string BanksModule::GetBatchInputFileParam(const std::vector<std::string>& args) {
    if (args.size() < 2) throw std::invalid_argument("Missing args[1] batchInputFileName");
    return args[1];
}

std::optional<std::string> BanksModule::GetThirdParam(const std::vector<std::string>& args) {
    if (args.size() == 3) return args[2];
    return std::nullopt;
}

std::unique_ptr<BNK> BanksModule::LoadBankFileOrThrow(const std::string& bankFileName) {
    auto bank = LoadBNKFromFile(bankFileName);
    if (!bank) throw std::runtime_error("Unable to load bank file: " + bankFileName);
    return bank;
}

BatchInputObject BanksModule::LoadBatchInputFileOrThrow(const std::string& batchInputFileName) {
    const std::string text = ReadAllText(batchInputFileName);
    nlohmann::json j = nlohmann::json::parse(text);
    return j.get<BatchInputObject>();
}

BankInfoOutputObject BanksModule::BuildBankInfo(const BNK& bankFile) {
    BankInfoOutputObject out(bankFile.size(), bankFile.year());

    for (const auto& packedPath : bankFile.getPackedFilesPaths(/*root=*/"")) {
        out.packedFiles.emplace_back(
            bankFile.getPackedFileName(packedPath),
            packedPath,
            bankFile.getPackedFileSize(packedPath),
            bankFile.getPackedFileTypeDescription(packedPath)
        );
    }

    return out;
}