#ifdef unix
#undef unix
#endif

#include "nix/expr/eval.hh"
#include "nix/expr/primops.hh"
#include "nix/expr/value.hh"
#include "nix/store/store-api.hh"
#include "nix/util/source-path.hh"

#include "irc/ir_gen.h"
#include "irc/parser.h"
#include "irc/resolver.h"
#include "irc/serializer.h"
#include "irc/types.h"
#include "irc/evaluator.h"

#include <fstream>
#include <iostream>
#include <memory>
#include <optional>

namespace nix_ir_plugin {

using namespace nix;
using namespace nix_irc;

/**
 * Load and evaluate a pre-compiled IR bundle
 * Usage: builtins.nixIR.loadIR "/path/to/file.nixir"
 */
static void prim_loadIR(EvalState &state, const PosIdx pos, Value **args,
                        Value &v) {
  auto path = state.forceStringNoCtx(
      *args[0], pos,
      "while evaluating the first argument to builtins.nixIR.loadIR");

  std::string pathStr(path);

  Deserializer deserializer;
  IRModule module;

  try {
    module = deserializer.deserialize(pathStr);
  } catch (const std::exception &e) {
    state.error<EvalError>("failed to deserialize IR bundle: %s", e.what())
        .atPos(pos)
        .debugThrow();
  }

  if (!module.entry) {
    state.error<EvalError>("IR bundle has no entry point")
        .atPos(pos)
        .debugThrow();
  }

  try {
    Evaluator evaluator(state);
    evaluator.eval_to_nix(module.entry, v);
  } catch (const std::exception &e) {
    state.error<EvalError>("failed to evaluate IR: %s", e.what())
        .atPos(pos)
        .debugThrow();
  }
}

/**
 * Compile Nix source to IR on-the-fly
 * Usage: builtins.nixIR.compile "{ x = 1; }"
 */
static void prim_compileNix(EvalState &state, const PosIdx pos, Value **args,
                            Value &v) {
  auto source = state.forceStringNoCtx(
      *args[0], pos,
      "while evaluating the first argument to builtins.nixIR.compile");

  std::string sourceStr(source);

  try {
    Parser parser;
    auto ast = parser.parse(sourceStr, "<inline>");

    if (!ast) {
      state.error<EvalError>("failed to parse Nix expression")
          .atPos(pos)
          .debugThrow();
    }

    IRGenerator ir_gen;
    auto ir = ir_gen.generate(ast);

    Evaluator evaluator(state);
    evaluator.eval_to_nix(ir, v);

  } catch (const std::exception &e) {
    state.error<EvalError>("IR compilation failed: %s", e.what())
        .atPos(pos)
        .debugThrow();
  }
}

/**
 * Get information about the IR plugin
 * Usage: builtins.nixIR.info
 */
static void prim_info(EvalState &state, const PosIdx pos, Value **args,
                      Value &v) {
  auto bindings = state.buildBindings(3);

  Value *vName = state.allocValue();
  vName->mkString("nix-ir-plugin");
  bindings.insert(state.symbols.create("name"), vName);

  Value *vVersion = state.allocValue();
  vVersion->mkString("0.1.0");
  bindings.insert(state.symbols.create("version"), vVersion);

  Value *vStatus = state.allocValue();
  vStatus->mkString("runtime-active");
  bindings.insert(state.symbols.create("status"), vStatus);

  v.mkAttrs(bindings.finish());
}

// Register primops on plugin load
static RegisterPrimOp rp_loadIR({
    .name = "__nixIR_loadIR",
    .args = {"path"},
    .arity = 1,
    .doc = R"(
      Load a pre-compiled IR bundle from the given path.
      Returns an attrset with information about the loaded bundle.

    )",
    .fun = prim_loadIR,
});

static RegisterPrimOp rp_compileNix({
    .name = "__nixIR_compile",
    .args = {"source"},
    .arity = 1,
    .doc = R"(
      Compile Nix source code to IR on-the-fly.
      Returns an attrset with information about the compiled IR.

    )",
    .fun = prim_compileNix,
});

static RegisterPrimOp rp_info({
    .name = "__nixIR_info",
    .args = {},
    .arity = 0,
    .doc = R"(
      Get information about the IR plugin.
      Returns an attrset with plugin name, version, and status.
    )",
    .fun = prim_info,
});

} // namespace nix_ir_plugin

// Plugin initialization message
__attribute__((constructor)) static void init_plugin() {
  std::cerr << "nix-ir-plugin loaded" << std::endl;
}