-- lazy.nvim
{
  "GustavEikaas/easy-dotnet.nvim",
  dependencies = { "nvim-lua/plenary.nvim", 'folke/snacks.nvim', },
  config = function()
    require("easy-dotnet").setup()
  end
}

-- lazy.nvim
{
  "GustavEikaas/easy-dotnet.nvim",
  -- 'nvim-telescope/telescope.nvim' or 'ibhagwan/fzf-lua' or 'folke/snacks.nvim'
  -- are highly recommended for a better experience
  dependencies = { "nvim-lua/plenary.nvim", 'mfussenegger/nvim-dap', 'folke/snacks.nvim', },
  config = function()
    local dotnet = require("easy-dotnet")
    -- Options are not required
    dotnet.setup({
     managed_terminal = {
       auto_hide = true, -- auto hides terminal if exit code is 0
       auto_hide_delay = 1000, -- delay before auto hiding, 0 = instant
       mappings = {
         next_tab       = { lhs = "<Tab>",   desc = "Next terminal tab" },
         prev_tab       = { lhs = "<S-Tab>", desc = "Previous terminal tab" },
         new_terminal   = { lhs = "+",       desc = "New user terminal" },
         close_terminal = { lhs = "X",       desc = "Close current terminal tab" },
         hide_panel     = { lhs = "q",       desc = "Hide terminal panel" },
       },
     },
      -- Optional configuration for external terminals (matches nvim-dap structure)
      external_terminal = nil,
      projx_lsp = {
        enabled = true,
      },
      lsp = {
        enabled = true, -- Enable builtin roslyn lsp
        set_fold_expr = false,
        preload_roslyn = true, -- Start loading roslyn before any buffer is opened
        roslynator_enabled = true, -- Automatically enable roslynator analyzer
        easy_dotnet_analyzer_enabled = true, -- Enable roslyn analyzer from easy-dotnet-server
        easy_dotnet_extension_enabled = false, -- Needs to be true for enhanced_rename and create_type_from_usage
        enhanced_rename = false, -- auto rename file when renaming class
        create_type_from_usage = false, -- code action for creating class from unresolved symbol in a separate file
        restart_roslyn_on_branch_change = false, -- Restart Roslyn when Git HEAD changes
        auto_refresh_codelens = true,
        suggest_updates = true, -- Periodically suggest roslyn-language-server updates
        analyzer_assemblies = {}, -- Any additional roslyn analyzers you might use like SonarAnalyzer.CSharp
        razor = {
          enabled = true,
          html = {
            enabled = true,
            cmd = nil, -- Auto-detect project node_modules/.bin/vscode-html-language-server, then PATH
            request_timeout = 5000,
          },
        },
        config = {},
      },
      debugger = {
        -- Path to custom coreclr DAP adapter
        -- When set, this fully overrides `engine`; easy-dotnet-server uses this binary as-is.
        -- When nil, easy-dotnet-server falls back to its own bundled debugger selected by `engine`.
        bin_path = nil,
        -- Which bundled debugger to use when `bin_path` is nil.
        --   "netcoredbg" (default) — Samsung netcoredbg
        --   "dncdbg"               — viewizard/dncdbg (a fork of netcoredbg with a richer set of features)
        engine = "netcoredbg",
        console = "integratedTerminal", -- Controls where the target app runs: "integratedTerminal" (Neovim buffer) or "externalTerminal" (OS window)
        apply_value_converters = true,
        auto_register_dap = true,
        mappings = {
          open_variable_viewer = { lhs = "T", desc = "open variable viewer" },
        },
      },
      ---@type TestRunnerOptions
      test_runner = {
        auto_start_testrunner = true,
        hide_legend = false,
        -- Set to true when using neotest to avoid duplicate signs and conflicting buffer keymaps. 
        neotest_integration = false,
        ---@type "split" | "vsplit" | "float" | "buf"
        viewmode = "float",
        ---@type number|nil
        vsplit_width = nil,
        ---@type string|nil "topleft" | "topright" 
        vsplit_pos = nil,
        icons = {
          passed = "",
          skipped = "",
          failed = "",
          success = "",
          reload = "",
          test = "",
          sln = "󰘐",
          project = "󰘐",
          dir = "",
          package = "",
          class = "",
          build_failed = "󰒡",
        },
        mappings = {
          run_test_from_buffer = { lhs = "<leader>r", desc = "run test from buffer" },
          run_all_tests_from_buffer = { lhs = "<leader>t", desc = "Run all tests in file" },
          get_build_errors = { lhs = "<leader>e", desc = "get build errors" },
          peek_stack_trace_from_buffer = { lhs = "<leader>p", desc = "peek stack trace from buffer" },
          debug_test_from_buffer = { lhs = "<leader>d", desc = "run test from buffer" },
          debug_test = { lhs = "<leader>d", desc = "debug test" },
          go_to_file = { lhs = "<leader>g", desc = "go to file" },
          run_all = { lhs = "<leader>R", desc = "run all tests" },
          run = { lhs = "<leader>r", desc = "run test" },
          peek_stacktrace = { lhs = "<leader>p", desc = "peek stacktrace of failed test" },
          expand = { lhs = "o", desc = "expand" },
          expand_node = { lhs = "E", desc = "expand node" },
          collapse_all = { lhs = "W", desc = "collapse all" },
          close = { lhs = "q", desc = "close testrunner" },
          refresh_testrunner = { lhs = "<C-r>", desc = "refresh testrunner" },
          cancel = { lhs = "<C-c>", desc = "cancel in-flight operation" },
          next_failure = { lhs = "]f", desc = "jump to next failing test" },
          prev_failure = { lhs = "[f", desc = "jump to previous failing test" },
        }
      },
      new = {
        project = {
          prefix = "sln" -- "sln" | "none"
        }
      },
      csproj_mappings = true,
      fsproj_mappings = true,
      auto_bootstrap_namespace = {
          --block_scoped, file_scoped
          type = "block_scoped",
          enabled = true,
          use_clipboard_json = {
            behavior = "prompt", --'auto' | 'prompt' | 'never',
            register = "+", -- which register to check
          },
      },
      server = {
          use_visual_studio = false, -- Set true for .NET Framework support on Windows
          ---@type nil | "Off" | "Critical" | "Error" | "Warning" | "Information" | "Verbose" | "All"
          log_level = nil,
      },
      -- choose which picker to use with the plugin
      -- possible values are "telescope" | "fzf" | "snacks" | "basic"
      -- if no picker is specified, the plugin will determine
      -- the available one automatically with this priority:
      --  snacks -> fzf -> telescope ->  basic
      picker = "snacks",
      notifications = {
        --Set this to false if you have configured lualine to avoid double logging
        handler = function(start_event)
          local spinner = require("easy-dotnet.ui-modules.spinner").new()
          spinner:start_spinner(function() return start_event.job.name end)
          ---@param finished_event JobEvent
          return function(finished_event)
            spinner:stop_spinner(finished_event.result.msg, finished_event.result.level)
          end
        end,
      },
      diagnostics = {
        default_severity = "error",
        setqflist = false,
      },
      outdated = {
        mappings = {
          upgrade = { lhs = "<leader>pu", desc = "upgrade package under cursor" },
          upgrade_all = { lhs = "<leader>pa", desc = "upgrade all outdated packages" },
        },
      },
    })

    -- Example command
    vim.api.nvim_create_user_command('Secrets', function()
      dotnet.secrets()
    end, {})

    -- Example keybinding
    vim.keymap.set("n", "<C-p>", function()
      vim.cmd("Dotnet run profile default")
    end)
  end
}

local dotnet = require("easy-dotnet")

require("lualine").setup {
  sections = {
    -- ...
    lualine_a = { "mode", dotnet.lualine.jobs },
    -- Shows the default startup project and its launch profile (if any),
    -- pushed by the server whenever it changes.
    lualine_x = { dotnet.lualine.active_project },
    -- ...
  },
}

local dotnet = require("easy-dotnet")

require("lualine").setup {
  sections = {
    lualine_x = {
      dotnet.lualine.jobs,
      {
        dotnet.lualine.run_status,
        color    = dotnet.lualine.run_status_color,
        on_click = dotnet.lualine.run_status_click,
      },
    },
  },
}

local dotnet = require("easy-dotnet")
dotnet.lsp_start()
dotnet.lsp_restart()
dotnet.lsp_stop()
dotnet.get_environment_variables(project_name, project_path, use_default_launch_profile: boolean)
dotnet.is_dotnet_project()                                 
dotnet.try_get_selected_solution()                         
dotnet.get_debug_dll()                                     
dotnet.reset()                                             
dotnet.test()
dotnet.test_solution()
dotnet.test_default()
dotnet.testrunner()
dotnet.new()
dotnet.outdated()
dotnet.add_package()
dotnet.remove_package()
dotnet.solution_select(path: string)
dotnet.ef_migrations_remove()
dotnet.ef_migrations_add(name: string)
dotnet.ef_migrations_list()
dotnet.ef_database_drop()
dotnet.ef_database_update()
dotnet.ef_database_update_pick()
dotnet.createfile(path: string)                                    
dotnet.build()                           
dotnet.build_solution()
dotnet.build_solution_quickfix()
dotnet.build_quickfix()                 
dotnet.build_default()                 
dotnet.build_default_quickfix()       
dotnet.pack()                           
dotnet.push()                           
dotnet.run()
dotnet.run_profile_default()
dotnet.run_default()
dotnet.watch()
dotnet.watch_default()
dotnet.secrets()                                                          
dotnet.clean()                                                           
dotnet.restore()
dotnet.stop()

local diagnostics = require("easy-dotnet.actions.diagnostics")
diagnostics.get_workspace_diagnostics()
diagnostics.get_workspace_diagnostics("error") 
diagnostics.get_workspace_diagnostics("warning")

require("easy-dotnet").setup({
  test_runner = {
    neotest_integration = true,
  },
})

require("neotest").setup({
  adapters = {
    require("easy-dotnet.neotest"),
  },
})

{
  "nvim-neotest/neotest",
  dependencies = {
    "nvim-lua/nvim-nio",
    "nvim-lua/plenary.nvim",
    "antoinemadec/FixCursorHold.nvim",
    "nvim-treesitter/nvim-treesitter",
    "GustavEikaas/easy-dotnet.nvim",
  },
  config = function()
    require("neotest").setup({
      adapters = {
        require("easy-dotnet.neotest"),
      },
    })
  end,
},
-- Make sure easy-dotnet is configured with neotest_integration = true
{
  "GustavEikaas/easy-dotnet.nvim",
  config = function()
    require("easy-dotnet").setup({
      test_runner = {
        neotest_integration = true,
      },
    })
  end,
}

require("easy-dotnet").setup({
  diagnostics = {
    default_severity = "error",  -- "error" or "warning" (default: "error")
    setqflist = false,           -- Populate quickfix list automatically (default: false)
  },
})

    require("nvim-tree").setup({
      on_attach = function(bufnr)
        local api = require('nvim-tree.api')

        local function opts(desc)
          return { desc = 'nvim-tree: ' .. desc, buffer = bufnr, noremap = true, silent = true, nowait = true }
        end

        vim.keymap.set('n', 'A', function()
          local node = api.tree.get_node_under_cursor()
          local path = node.type == "directory" and node.absolute_path or vim.fs.dirname(node.absolute_path)
          require("easy-dotnet").create_item(path)
        end, opts('Create item'))
      end
    })

      require("neo-tree").setup({
      ---...other options
        filesystem = {
          window = {
            mappings = {
              -- Make the mapping anything you want
              ["R"] = "easy",
            },
          },
          commands = {
            ["easy"] = function(state)
              local node = state.tree:get_node()
              local path = node.type == "directory" and node.path or vim.fs.dirname(node.path)
              require("easy-dotnet").create_item(path)
            end
          }
        },
      })

    vim.api.nvim_create_autocmd("User", {
      pattern = "MiniFilesBufferCreate",
      callback = function(args)
        local buf_id = args.data.buf_id
        vim.keymap.set("n", "<leader>a", function()
          local entry = require("mini.files").get_fs_entry()
          if entry == nil then
            vim.notify("No fd entry in mini files", vim.log.levels.WARN)
            return
          end
          local target_dir = entry.path
          if entry.fs_type == "file" then
            target_dir = vim.fn.fnamemodify(entry.path, ":h")
          end
          require("easy-dotnet").create_item(target_dir)
        end, { buffer = buf_id, desc = "Create item" })
      end,
    })

  {
    "folke/snacks.nvim",
    ---@type snacks.Config
    opts = {
      picker = {
        sources = {
          explorer = {
            win = {
              list = {
                keys = {
                  ["A"] = "explorer_add_dotnet",
                },
              },
            },
            actions = {
              explorer_add_dotnet = function(picker)
                local dir = picker:dir()
                local easydotnet = require("easy-dotnet")

                easydotnet.create_item(dir)
              end,
            },
          },
        },
      },
    },
  },