#include "tool.hpp"
#include <filesystem>
#include <algorithm>
#include <spdlog/sinks/stdout_color_sinks.h>
#include <spdlog/sinks/basic_file_sink.h>
#include <CLI11.hpp>

void register_cmd_scan(CLI::App &app);
void register_cmd_dump(CLI::App &app);
void register_cmd_verify(CLI::App &app);
void register_cmd_hooks(CLI::App &app);

int main(int argc, char *argv[]) {
  // Initialize spdlog
  auto console = spdlog::stdout_color_mt("console");
  spdlog::set_default_logger(console);
  spdlog::set_level(spdlog::level::info); // Default to info level
  spdlog::set_pattern(std::string("[%^%l%$] %v"));

  CLI::App app{"Ghidra decompile database tool"};

  std::string type_str = "auto";

  Options &options = Options::get();
  app.add_option("-d,--database", options.db_path, "SQLite database path")
      ->default_val("gh.db");
  app.add_flag("-v,--verbose", options.verbose,
               "Enable verbose logging (debug level)")
      ->each([&](std::string) {
        if (options.verbose) {
          spdlog::set_level(spdlog::level::debug);
        }
      });
  app.add_flag("--log-file", options.log_file, "Enable logging to file")
      ->each([&](const std::string& arg) {
        auto log_sink = std::make_shared<spdlog::sinks::basic_file_sink_mt>(
            arg, true);
        console->sinks().push_back(log_sink);
      });
  app.require_subcommand();
  register_cmd_scan(app);
  register_cmd_dump(app);
  register_cmd_verify(app);
  register_cmd_hooks(app);
  CLI11_PARSE(app, argc, argv);

  return 0;
}

CallingConvention stringToCallingConvention(const std::string &conv_str) {
  std::string lower_conv = conv_str;
  std::transform(lower_conv.begin(), lower_conv.end(), lower_conv.begin(), ::tolower);

  if (lower_conv == "fastcall" || lower_conv == "__fastcall") {
    return CallingConvention::Fastcall;
  } else if (lower_conv == "stdcall" || lower_conv == "__stdcall") {
    return CallingConvention::Stdcall;
  } else {
    return CallingConvention::Cdecl; // Default
  }
}

std::string callingConventionToString(CallingConvention conv) {
  switch (conv) {
    case CallingConvention::Fastcall:
      return "fastcall";
    case CallingConvention::Stdcall:
      return "stdcall";
    case CallingConvention::Cdecl:
    default:
      return "cdecl";
  }
}