local core = require "core"
local process = require "process"
local debugger = require "plugins.jpdebug.debugger"

-- Enable hot reloading of mdb
package.loaded["plugins.jpdebug.runners.luadebug.mdb"] = nil
local mdb = require "plugins.jpdebug.runners.luadebug.mdb"

---@class luadebug: runner
local luadebug = debugger.runner:new({
  name = "luadebug",
  proc = nil ---@type process|nil
})

-- tiny helpers
local function dirname(p) return p:match("^(.*)[/\\]") or "" end
local function join(a, b) return (a:sub(-1) == "/" and a or (a .. "/")) .. b end

-- returns absolute path to the plugin root (…/jpdebug)
local function get_plugin_root()
  -- debug.getinfo(1, "S").source gives "@/full/path/to/this/file.lua"
  local src = debug.getinfo(1, "S").source
  if src:sub(1, 1) == "@" then src = src:sub(2) end
  local here = dirname(src)                    -- …/jpdebug/runners
  return dirname(here)                         -- …/jpdebug
end

-- Main lua process spawner
local function spawn_lua_process(entry, lua, cwd, env)
  local host = "localhost"
  local port = 8172

  -- Resolve vendor/?.lua so "require('mobdebug')" finds the bundled file
  local vendor_glob = join(get_plugin_root(), "vendor/?.lua")

  -- Build the inline lua launcher
  local dbg_call = string.format([[
    local ok, m = pcall(require, "mobdebug"); if ok then
      print("Connecting to "..%q..":"..tostring(%d))
      local connected = m.start(%q, %d)
    end
  ]], host, port, host, port)
  local launcher = string.format([[
    package.path = %q .. ";" .. package.path
    %s
    dofile(%q)
  ]], vendor_glob, dbg_call, entry)

  -- Spawn the process
  local cmd = {}
  if type(lua) == "table" then
    for i=1, #lua do table.insert(cmd, lua[i]) end
  else
    table.insert(cmd, lua)
  end
  table.insert(cmd, "-e")
  table.insert(cmd, launcher)
  local proc = process.start(cmd, {
    cwd = cwd,
    env = env,
    stdout = process.REDIRECT_PIPE,
    stderr = process.REDIRECT_PIPE,
  })
  return proc
end

function luadebug:run(target, name)
  if target.entry == nil then
    self.error("target.entry is required for "..name)
    return
  end
  local entry = target.entry
  local lua = target.lua or "lua"
  local cwd = target.cwd or "."
  local env = target.env or {}

  -- spwawn the mobdebug process
  self.mdb = mdb:new({
    log = self.log,
    error = self.error,

    on_connected = function()
      self.on_state('running')
      self.mdb:setb('test.lua', 6)
      self.mdb:run()
    end,
    on_pause = function(file, line)
      self.on_state('paused')
      self.on_break(file, line, "breakpoint") 
    end,

  })
  self.mdb:spawn(lua, get_plugin_root())

  -- spawn the main lua process
  local proc = spawn_lua_process(entry, lua, cwd, env)
  if proc == nil then
    self.error("Failed to start "..entry)
    return
  end
  self.proc = proc

  self.on_state('connecting')

    -- output pump
  core.add_thread(function()
    while true do
      core.redraw = true
      coroutine.yield(0.016) -- 60FPS
      local sout = self.proc:read_stdout()
      local serr = self.proc:read_stderr()
      if sout == nil and serr == nil then
        local exitcode = self.proc:wait(process.WAIT_INFINITE)
        self.on_exit(exitcode)
        break
      end
      if sout and sout~="" then self.on_stdout(sout) end
      if serr and serr~="" then self.on_stderr(serr) end
    end
  end)
end

function luadebug:continue()
  if not self.proc then return end
  self.mdb:run()
end

function luadebug:wait(time)
  if not self.proc then return end
  return self.proc:wait(time)
end

function luadebug:read_stdout()
  if not self.proc then return end
  local sl = self.proc:read_stdout()
  return sl
end

function luadebug:read_stderr()
  if not self.proc then return end
  local sl = self.proc:read_stderr()
  return sl
end

function luadebug:kill()
  if self.mdb then self.mdb:kill() end
  if not self.proc then return end
  self.proc:kill()
end

function luadebug:terminate()
  if not self.proc then return end
  self.proc:terminate()
end

return luadebug