local M = {}

local utils = require("vern.utils")
local templates = require("vern.templates")

local join = vim.fs.joinpath

---@param opts VernCConfig
function M.create_project(opts)
    vim.ui.input({ prompt = "Enter project name: " }, function(pname)
        pname = pname and vim.trim(pname)
        if not pname or pname == "" then
            return
        end

        local configs = require("vern.configs.c")

        ---@type VernCConfig
        local cfg = vim.tbl_deep_extend("force", {}, configs, configs, opts or {})
        local ctx = { project_name = pname }

        local root = join(vim.fn.expand(cfg.workspace_root), cfg.c.root, pname)
        vim.fn.mkdir(root, "p")
        local bin
        for tbl_name, tbl in pairs(cfg.c.templates.project) do
            local raw_path = join(tbl.path, tbl.name)
            local path = utils.resolve_path(raw_path, cfg.c.dirs, ctx)
            if tbl_name == "primary" then
                bin = join(root, path)
            end
            local abs_file_path = vim.fs.normalize(join(root, path))
            print("File Path: " .. abs_file_path)
            local abs_dir_path = vim.fs.dirname(abs_file_path)
            if abs_dir_path ~= root and not vim.startswith(root, abs_dir_path) then
                vim.fn.mkdir(abs_dir_path, "p")
            end
            utils.dump(abs_file_path, templates.fetch(tbl.kind_path, tbl.kind, pname))
        end
        for _, tbl in pairs(cfg.c.templates.extras) do
            if tbl.enabled then
                local raw_path = join(tbl.path, tbl.name)
                local path = utils.resolve_path(raw_path, cfg.c.dirs, ctx)
                local abs_file_path = vim.fs.normalize(join(root, path))
                local abs_dir_path = vim.fs.dirname(abs_file_path)
                if abs_dir_path ~= root and not vim.startswith(root, abs_dir_path) then
                    vim.fn.mkdir(abs_dir_path, "p")
                end
                utils.dump(abs_file_path, templates.fetch(tbl.kind_path, tbl.kind, pname))
            end
        end

        utils.init_git(root, "c")

        vim.cmd.edit(vim.fn.fnameescape(bin))
    end)
end

function M.create_file(opts)
    vim.ui.input({ prompt = "Enter type (c/h): " }, function(ft)
        ft = ft and vim.trim(ft)
        if not ft or ft == "" then
            return
        end
        local configs = require("vern.configs.c")
        ---@type VernCConfig
        local cfg = vim.tbl_deep_extend("force", {}, configs, opts or {})
        vim.ui.input({ prompt = "Enter file name: " }, function(fname)
            local root = join(vim.fn.expand(cfg.workspace_root), cfg.c.root, utils.proj_name())
            local input_txt = fname
            ft = ft and vim.trim(ft)
            if not ft or ft == "" then
                return
            end
            local mod
            if ft == "c" then
                mod = cfg.c.templates.file.source or {}
            end
            if ft == "h" then
                mod = cfg.c.templates.file.header or {}
                input_txt = fname:upper()
            end
            local raw_path = join(mod.path, mod.name)
            local context = { project_name = utils.proj_name(), name = fname }
            local path = utils.resolve_path(raw_path, cfg.c.dirs or {}, context)
            local abs_file_path = vim.fs.normalize(join(root, path))
            if ft == "h" then
                local abs_dir_path = vim.fs.dirname(abs_file_path)
                if abs_dir_path ~= root and not vim.startswith(root, abs_dir_path) then
                    vim.fn.mkdir(abs_dir_path, "p")
                end
            end
            utils.dump(abs_file_path, templates.fetch(mod.kind_path, mod.kind, input_txt))
            vim.cmd.edit(vim.fn.expand(abs_file_path))
        end)
    end)
end

--- Goal is to add providers for uv and venv so its available to more users
---@param opts? table Takes a table for the runtime
function M.run(opts)
    opts = opts or {}
    local root = utils.proj_root() or "."
    local pname = vim.fs.basename(root)

    local exe = opts.python.templates.project.bin.target or "src/%s/main.py"
    local full_path = join(vim.fn.expand(root), utils.fmt(exe, { project_name = pname }))
    utils.term({ "python3 " .. full_path }, opts.terminal or {})
end

---@param cmd_args? table Takes a table for the runtime
function M.pip_install(opts, cmd_args)
    local args = cmd_args and cmd_args.args and vim.trim(cmd_args.args) or ""
    if args ~= "" then
        utils.term({ "pip install " .. args }, opts.terminal or {})
        return
    end
    vim.ui.input({ prompt = "Enter pip module: " }, function(pip_module)
        if not pip_module or vim.trim(pip_module) == "" then
            vim.notify("Pip Cancelled", vim.log.levels.WARN)
            return
        end
        utils.term({ "pip install " .. vim.trim(pip_module) }, opts.terminal or {})
    end)
end

return M