local M = {}

---@class forge.Config
---@field ci forge.CIConfig
---@field sources table<string, forge.SourceConfig>
---@field keys forge.KeysConfig|false
---@field display forge.DisplayConfig

---@class forge.CIConfig
---@field lines integer

---@class forge.SourceConfig
---@field hosts string[]

---@class forge.KeysConfig
---@field pr forge.PRPickerKeys?
---@field issue forge.IssuePickerKeys?
---@field ci forge.CIPickerKeys?
---@field commits forge.CommitsPickerKeys?
---@field branches forge.BranchesPickerKeys?

---@class forge.PRPickerKeys
---@field checkout string|false
---@field diff string|false
---@field worktree string|false
---@field ci string|false
---@field browse string|false
---@field manage string|false
---@field create string|false
---@field filter string|false
---@field refresh string|false

---@class forge.IssuePickerKeys
---@field browse string|false
---@field close string|false
---@field filter string|false
---@field refresh string|false

---@class forge.CIPickerKeys
---@field log string|false
---@field browse string|false
---@field failed string|false
---@field passed string|false
---@field running string|false
---@field all string|false
---@field refresh string|false

---@class forge.CommitsPickerKeys
---@field checkout string|false
---@field diff string|false
---@field browse string|false
---@field yank string|false

---@class forge.BranchesPickerKeys
---@field diff string|false
---@field browse string|false

---@class forge.DisplayConfig
---@field icons forge.IconsConfig
---@field widths forge.WidthsConfig
---@field limits forge.LimitsConfig

---@class forge.IconsConfig
---@field open string
---@field merged string
---@field closed string
---@field pass string
---@field fail string
---@field pending string
---@field skip string
---@field unknown string

---@class forge.WidthsConfig
---@field title integer
---@field author integer
---@field name integer
---@field branch integer

---@class forge.LimitsConfig
---@field pulls integer
---@field issues integer
---@field runs integer

---@type forge.Config
local DEFAULTS = {
  ci = { lines = 10000 },
  sources = {},
  keys = {
    pr = {
      checkout = '<cr>',
      diff = '<c-d>',
      worktree = '<c-w>',
      ci = '<c-t>',
      browse = '<c-x>',
      manage = '<c-e>',
      create = '<c-a>',
      filter = '<c-o>',
      refresh = '<c-r>',
    },
    issue = { browse = '<cr>', close = '<c-s>', filter = '<c-o>', refresh = '<c-r>' },
    ci = {
      log = '<cr>',
      browse = '<c-x>',
      failed = '<c-f>',
      passed = '<c-p>',
      running = '<c-n>',
      all = '<c-a>',
      refresh = '<c-r>',
    },
    commits = { checkout = '<cr>', diff = '<c-d>', browse = '<c-x>', yank = '<c-y>' },
    branches = { diff = '<c-d>', browse = '<c-x>' },
  },
  display = {
    icons = {
      open = '+',
      merged = 'm',
      closed = 'x',
      pass = '*',
      fail = 'x',
      pending = '~',
      skip = '-',
      unknown = '?',
    },
    widths = {
      title = 45,
      author = 15,
      name = 35,
      branch = 25,
    },
    limits = {
      pulls = 100,
      issues = 100,
      runs = 30,
    },
  },
}

---@type table<string, forge.Forge>
local sources = {}

---@param name string
---@param source forge.Forge
function M.register(name, source)
  sources[name] = source
end

---@return table<string, forge.Forge>
function M.registered_sources()
  return sources
end

local hl_defaults = {
  ForgeComposeComment = 'Comment',
  ForgeComposeBranch = 'Special',
  ForgeComposeForge = 'Type',
  ForgeComposeDraft = 'DiagnosticWarn',
  ForgeComposeFile = 'Directory',
  ForgeComposeAdded = 'Added',
  ForgeComposeRemoved = 'Removed',
  ForgeNumber = 'Number',
  ForgeOpen = 'DiagnosticInfo',
  ForgeMerged = 'Constant',
  ForgeClosed = 'Comment',
  ForgePass = 'DiagnosticOk',
  ForgeFail = 'DiagnosticError',
  ForgePending = 'DiagnosticWarn',
  ForgeSkip = 'Comment',
  ForgeBranch = 'Special',
  ForgeDim = 'Comment',
}

for group, link in pairs(hl_defaults) do
  vim.api.nvim_set_hl(0, group, { default = true, link = link })
end

local compose_ns = vim.api.nvim_create_namespace('forge_compose')

---@param msg string
---@param level integer?
function M.log(msg, level)
  vim.schedule(function()
    vim.notify('[forge.nvim]: ' .. msg, level or vim.log.levels.INFO)
    vim.cmd.redraw()
  end)
end

---@param msg string
---@param level integer?
function M.log_now(msg, level)
  vim.notify('[forge.nvim]: ' .. msg, level or vim.log.levels.INFO)
  vim.cmd.redraw()
end

---@class forge.PRState
---@field state string
---@field mergeable string
---@field review_decision string
---@field is_draft boolean

---@class forge.Check
---@field name string
---@field status string
---@field elapsed string
---@field run_id string

---@class forge.CIRun
---@field id string
---@field name string
---@field branch string
---@field status string
---@field event string
---@field url string
---@field created_at string

---@class forge.RepoInfo
---@field permission string
---@field merge_methods string[]

---@class forge.Capabilities
---@field draft boolean
---@field reviewers boolean
---@field per_pr_checks boolean
---@field ci_json boolean

---@class forge.Forge
---@field name string
---@field cli string
---@field kinds { issue: string, pr: string }
---@field labels { issue: string, pr: string, pr_one: string, pr_full: string, ci: string }
---@field capabilities forge.Capabilities
---@field list_pr_json_cmd fun(self: forge.Forge, state: string): string[]
---@field list_issue_json_cmd fun(self: forge.Forge, state: string): string[]
---@field pr_json_fields fun(self: forge.Forge): { number: string, title: string, branch: string, state: string, author: string, created_at: string }
---@field issue_json_fields fun(self: forge.Forge): { number: string, title: string, state: string, author: string, created_at: string }
---@field view_web fun(self: forge.Forge, kind: string, num: string)
---@field browse fun(self: forge.Forge, loc: string, branch: string)
---@field browse_root fun(self: forge.Forge)
---@field browse_branch fun(self: forge.Forge, branch: string)
---@field browse_commit fun(self: forge.Forge, sha: string)
---@field checkout_cmd fun(self: forge.Forge, num: string): string[]
---@field yank_branch fun(self: forge.Forge, loc: string)
---@field yank_commit fun(self: forge.Forge, loc: string)
---@field fetch_pr fun(self: forge.Forge, num: string): string[]
---@field pr_base_cmd fun(self: forge.Forge, num: string): string[]
---@field pr_for_branch_cmd fun(self: forge.Forge, branch: string): string[]
---@field checks_cmd fun(self: forge.Forge, num: string): string
---@field check_log_cmd fun(self: forge.Forge, run_id: string, failed_only: boolean): string[]
---@field check_tail_cmd fun(self: forge.Forge, run_id: string): string[]
---@field list_runs_json_cmd fun(self: forge.Forge, branch: string?): string[]
---@field list_runs_cmd fun(self: forge.Forge, branch: string?): string
---@field normalize_run fun(self: forge.Forge, entry: table): forge.CIRun
---@field run_log_cmd fun(self: forge.Forge, id: string, failed_only: boolean): string[]
---@field run_tail_cmd fun(self: forge.Forge, id: string): string[]
---@field merge_cmd fun(self: forge.Forge, num: string, method: string): string[]
---@field approve_cmd fun(self: forge.Forge, num: string): string[]
---@field repo_info fun(self: forge.Forge): forge.RepoInfo
---@field pr_state fun(self: forge.Forge, num: string): forge.PRState
---@field close_cmd fun(self: forge.Forge, num: string): string[]
---@field reopen_cmd fun(self: forge.Forge, num: string): string[]
---@field close_issue_cmd fun(self: forge.Forge, num: string): string[]
---@field reopen_issue_cmd fun(self: forge.Forge, num: string): string[]
---@field draft_toggle_cmd fun(self: forge.Forge, num: string, is_draft: boolean): string[]?
---@field create_pr_cmd fun(self: forge.Forge, title: string, body: string, base: string, draft: boolean, reviewers: string[]?): string[]
---@field create_pr_web_cmd fun(self: forge.Forge): string[]?
---@field default_branch_cmd fun(self: forge.Forge): string[]
---@field checks_json_cmd (fun(self: forge.Forge, num: string): string[])?
---@field template_paths fun(self: forge.Forge): string[]

---@type table<string, forge.Forge>
local forge_cache = {}

---@type table<string, forge.RepoInfo>
local repo_info_cache = {}

---@type table<string, string>
local root_cache = {}

---@type table<string, table[]>
local list_cache = {}

---@return string?
local function git_root()
  local cwd = vim.fn.getcwd()
  if root_cache[cwd] then
    return root_cache[cwd]
  end
  local root = vim.trim(vim.fn.system('git rev-parse --show-toplevel'))
  if vim.v.shell_error ~= 0 then
    return nil
  end
  root_cache[cwd] = root
  return root
end

local builtin_hosts = {
  github = { 'github' },
  gitlab = { 'gitlab' },
  codeberg = { 'codeberg', 'gitea', 'forgejo' },
}

local function resolve_source(name)
  if sources[name] then
    return sources[name]
  end
  local ok, mod = pcall(require, 'forge.' .. name)
  if ok then
    sources[name] = mod
    return mod
  end
  return nil
end

---@param remote string
---@return string? forge_name
local function detect_from_remote(remote)
  local cfg = M.config().sources

  for name, opts in pairs(cfg) do
    for _, host in ipairs(opts.hosts or {}) do
      if remote:find(host, 1, true) then
        return name
      end
    end
  end

  for name, patterns in pairs(builtin_hosts) do
    for _, pattern in ipairs(patterns) do
      if remote:find(pattern, 1, true) then
        return name
      end
    end
  end

  return nil
end

---@return forge.Forge?
function M.detect()
  local root = git_root()
  if not root then
    return nil
  end
  if forge_cache[root] then
    return forge_cache[root]
  end
  local remote = vim.trim(vim.fn.system('git remote get-url origin'))
  if vim.v.shell_error ~= 0 then
    return nil
  end
  local name = detect_from_remote(remote)
  if not name then
    return nil
  end
  local source = resolve_source(name)
  if not source then
    return nil
  end
  if vim.fn.executable(source.cli) ~= 1 then
    return nil
  end
  forge_cache[root] = source
  return source
end

---@param f forge.Forge
---@return forge.RepoInfo
function M.repo_info(f)
  local root = git_root()
  if root and repo_info_cache[root] then
    return repo_info_cache[root]
  end
  local info = f:repo_info()
  if root then
    repo_info_cache[root] = info
  end
  return info
end

---@param kind string
---@param state string
---@return string
function M.list_key(kind, state)
  local root = git_root() or ''
  return root .. ':' .. kind .. ':' .. state
end

---@param key string
---@return table[]?
function M.get_list(key)
  return list_cache[key]
end

---@param key string
---@param data table[]
function M.set_list(key, data)
  list_cache[key] = data
end

---@param key string?
function M.clear_list(key)
  if key then
    list_cache[key] = nil
  else
    list_cache = {}
  end
end

function M.clear_cache()
  forge_cache = {}
  repo_info_cache = {}
  root_cache = {}
  list_cache = {}
end

---@return string
function M.file_loc()
  local root = git_root()
  if not root then
    return vim.fn.expand('%:t')
  end
  local file = vim.api.nvim_buf_get_name(0):sub(#root + 2)
  local mode = vim.fn.mode()
  if mode:match('[vV]') or mode == '\22' then
    local s = vim.fn.line('v')
    local e = vim.fn.line('.')
    if s > e then
      s, e = e, s
    end
    if s == e then
      return ('%s:%d'):format(file, s)
    end
    return ('%s:%d-%d'):format(file, s, e)
  end
  return ('%s:%d'):format(file, vim.fn.line('.'))
end

---@return string
function M.remote_web_url()
  local root = git_root()
  if not root then
    return ''
  end
  local remote = vim.trim(vim.fn.system('git remote get-url origin'))
  remote = remote:gsub('%.git$', '')
  remote = remote:gsub('^ssh://git@', 'https://')
  remote = remote:gsub('^git@([^:]+):', 'https://%1/')
  return remote
end

---@param s string
---@param width integer
---@return string
local function pad_or_truncate(s, width)
  local len = #s
  if len > width then
    return s:sub(1, width - 1) .. '…'
  end
  return s .. string.rep(' ', width - len)
end

---@param iso string?
---@return integer?
local function parse_iso(iso)
  if not iso or iso == '' then
    return nil
  end
  local y, mo, d, h, mi, s = iso:match('(%d+)-(%d+)-(%d+)T(%d+):(%d+):(%d+)')
  if not y then
    return nil
  end
  local ok, ts = pcall(os.time, {
    year = tonumber(y) --[[@as integer]],
    month = tonumber(mo) --[[@as integer]],
    day = tonumber(d) --[[@as integer]],
    hour = tonumber(h) --[[@as integer]],
    min = tonumber(mi) --[[@as integer]],
    sec = tonumber(s) --[[@as integer]],
  })
  if ok and ts then
    return ts
  end
  return nil
end

---@param iso string?
---@return string
local function relative_time(iso)
  local ts = parse_iso(iso)
  if not ts then
    return ''
  end
  local diff = os.time() - ts
  if diff < 0 then
    diff = 0
  end
  if diff < 3600 then
    return ('%dm'):format(math.max(1, math.floor(diff / 60)))
  end
  if diff < 86400 then
    return ('%dh'):format(math.floor(diff / 3600))
  end
  if diff < 2592000 then
    return ('%dd'):format(math.floor(diff / 86400))
  end
  if diff < 31536000 then
    return ('%dmo'):format(math.floor(diff / 2592000))
  end
  return ('%dy'):format(math.floor(diff / 31536000))
end

local event_map = {
  merge_request_event = 'mr',
  external_pull_request_event = 'ext',
  pull_request = 'pr',
  workflow_dispatch = 'manual',
  schedule = 'cron',
  pipeline = 'child',
  push = 'push',
  web = 'web',
  api = 'api',
  trigger = 'trigger',
}

---@param event string
---@return string
local function abbreviate_event(event)
  return event_map[event] or event
end

---@param entry table
---@param field string
---@return string
local function extract_author(entry, field)
  local v = entry[field]
  if type(v) == 'table' then
    return v.login or v.username or v.name or ''
  end
  return tostring(v or '')
end

local function hl(group, text)
  local utils = require('fzf-lua.utils')
  return utils.ansi_from_hl(group, text)
end

---@param entry table
---@param fields table
---@param show_state boolean
---@return string
function M.format_pr(entry, fields, show_state)
  local display = M.config().display
  local icons = display.icons
  local widths = display.widths
  local num = tostring(entry[fields.number] or '')
  local title = entry[fields.title] or ''
  local author = extract_author(entry, fields.author)
  local age = relative_time(entry[fields.created_at])
  local prefix = ''
  if show_state then
    local state = (entry[fields.state] or ''):lower()
    local icon, group
    if state == 'open' or state == 'opened' then
      icon, group = icons.open, 'ForgeOpen'
    elseif state == 'merged' then
      icon, group = icons.merged, 'ForgeMerged'
    else
      icon, group = icons.closed, 'ForgeClosed'
    end
    prefix = hl(group, icon) .. '  '
  end
  return prefix
    .. hl('ForgeNumber', ('#%-5s'):format(num))
    .. ' '
    .. pad_or_truncate(title, widths.title)
    .. ' '
    .. hl('ForgeDim', pad_or_truncate(author, widths.author) .. (' %3s'):format(age))
end

---@param entry table
---@param fields table
---@param show_state boolean
---@return string
function M.format_issue(entry, fields, show_state)
  local display = M.config().display
  local icons = display.icons
  local widths = display.widths
  local num = tostring(entry[fields.number] or '')
  local title = entry[fields.title] or ''
  local author = extract_author(entry, fields.author)
  local age = relative_time(entry[fields.created_at])
  local prefix = ''
  if show_state then
    local state = (entry[fields.state] or ''):lower()
    local icon, group
    if state == 'open' or state == 'opened' then
      icon, group = icons.open, 'ForgeOpen'
    else
      icon, group = icons.closed, 'ForgeClosed'
    end
    prefix = hl(group, icon) .. '  '
  end
  return prefix
    .. hl('ForgeNumber', ('#%-5s'):format(num))
    .. ' '
    .. pad_or_truncate(title, widths.title)
    .. ' '
    .. hl('ForgeDim', pad_or_truncate(author, widths.author) .. (' %3s'):format(age))
end

---@param check table
---@return string
function M.format_check(check)
  local display = M.config().display
  local icons = display.icons
  local widths = display.widths
  local bucket = (check.bucket or 'pending'):lower()
  local name = check.name or ''
  local icon, group
  if bucket == 'pass' then
    icon, group = icons.pass, 'ForgePass'
  elseif bucket == 'fail' then
    icon, group = icons.fail, 'ForgeFail'
  elseif bucket == 'pending' then
    icon, group = icons.pending, 'ForgePending'
  elseif bucket == 'skipping' or bucket == 'cancel' then
    icon, group = icons.skip, 'ForgeSkip'
  else
    icon, group = icons.unknown, 'ForgeSkip'
  end
  local elapsed = ''
  if check.startedAt and check.completedAt and check.completedAt ~= '' then
    local ok_s, ts = pcall(vim.fn.strptime, '%Y-%m-%dT%H:%M:%SZ', check.startedAt)
    local ok_e, te = pcall(vim.fn.strptime, '%Y-%m-%dT%H:%M:%SZ', check.completedAt)
    if ok_s and ok_e and ts > 0 and te > 0 then
      local secs = te - ts
      if secs >= 60 then
        elapsed = ('%dm%ds'):format(math.floor(secs / 60), secs % 60)
      else
        elapsed = ('%ds'):format(secs)
      end
    end
  end
  return hl(group, icon)
    .. '  '
    .. pad_or_truncate(name, widths.name)
    .. ' '
    .. hl('ForgeDim', elapsed)
end

---@param run forge.CIRun
---@return string
function M.format_run(run)
  local display = M.config().display
  local icons = display.icons
  local widths = display.widths
  local icon, group
  local s = run.status:lower()
  if s == 'success' then
    icon, group = icons.pass, 'ForgePass'
  elseif s == 'failure' or s == 'failed' then
    icon, group = icons.fail, 'ForgeFail'
  elseif s == 'in_progress' or s == 'running' or s == 'pending' or s == 'queued' then
    icon, group = icons.pending, 'ForgePending'
  elseif s == 'cancelled' or s == 'canceled' or s == 'skipped' then
    icon, group = icons.skip, 'ForgeSkip'
  else
    icon, group = icons.unknown, 'ForgeSkip'
  end
  local event = abbreviate_event(run.event)
  local age = relative_time(run.created_at)
  if run.branch ~= '' then
    local name_w = widths.name - widths.branch + 10
    return hl(group, icon)
      .. '  '
      .. pad_or_truncate(run.name, name_w)
      .. ' '
      .. hl('ForgeBranch', pad_or_truncate(run.branch, widths.branch))
      .. ' '
      .. hl('ForgeDim', ('%-6s'):format(event) .. ' ' .. age)
  end
  return hl(group, icon)
    .. '  '
    .. pad_or_truncate(run.name, widths.name)
    .. ' '
    .. hl('ForgeDim', ('%-6s'):format(event) .. ' ' .. age)
end

---@param checks table[]
---@param filter string?
---@return table[]
function M.filter_checks(checks, filter)
  if not filter or filter == 'all' then
    table.sort(checks, function(a, b)
      local order = { fail = 1, pending = 2, pass = 3, skipping = 4, cancel = 5 }
      local oa = order[(a.bucket or ''):lower()] or 9
      local ob = order[(b.bucket or ''):lower()] or 9
      return oa < ob
    end)
    return checks
  end
  local filtered = {}
  for _, c in ipairs(checks) do
    if (c.bucket or ''):lower() == filter then
      table.insert(filtered, c)
    end
  end
  return filtered
end

---@return forge.Config
function M.config()
  local user = vim.g.forge or {}
  local cfg = vim.tbl_deep_extend('force', DEFAULTS, user)
  if user.keys == false then
    cfg.keys = false
  end

  vim.validate('forge.sources', cfg.sources, 'table')
  vim.validate('forge.keys', cfg.keys, function(v)
    return v == false or type(v) == 'table'
  end, 'table or false')
  vim.validate('forge.display', cfg.display, 'table')
  vim.validate('forge.ci', cfg.ci, 'table')
  vim.validate('forge.ci.lines', cfg.ci.lines, 'number')

  vim.validate('forge.display.icons', cfg.display.icons, 'table')
  vim.validate('forge.display.icons.open', cfg.display.icons.open, 'string')
  vim.validate('forge.display.icons.merged', cfg.display.icons.merged, 'string')
  vim.validate('forge.display.icons.closed', cfg.display.icons.closed, 'string')
  vim.validate('forge.display.icons.pass', cfg.display.icons.pass, 'string')
  vim.validate('forge.display.icons.fail', cfg.display.icons.fail, 'string')
  vim.validate('forge.display.icons.pending', cfg.display.icons.pending, 'string')
  vim.validate('forge.display.icons.skip', cfg.display.icons.skip, 'string')
  vim.validate('forge.display.icons.unknown', cfg.display.icons.unknown, 'string')

  vim.validate('forge.display.widths', cfg.display.widths, 'table')
  vim.validate('forge.display.widths.title', cfg.display.widths.title, 'number')
  vim.validate('forge.display.widths.author', cfg.display.widths.author, 'number')
  vim.validate('forge.display.widths.name', cfg.display.widths.name, 'number')
  vim.validate('forge.display.widths.branch', cfg.display.widths.branch, 'number')

  vim.validate('forge.display.limits', cfg.display.limits, 'table')
  vim.validate('forge.display.limits.pulls', cfg.display.limits.pulls, 'number')
  vim.validate('forge.display.limits.issues', cfg.display.limits.issues, 'number')
  vim.validate('forge.display.limits.runs', cfg.display.limits.runs, 'number')

  local key_or_false = function(v)
    return v == false or type(v) == 'string'
  end
  if type(cfg.keys) == 'table' then
    local keys = cfg.keys --[[@as forge.KeysConfig]]
    if keys.pr ~= nil then
      vim.validate('forge.keys.pr', keys.pr, 'table')
      for _, k in ipairs({
        'checkout',
        'diff',
        'worktree',
        'ci',
        'browse',
        'manage',
        'create',
        'filter',
        'refresh',
      }) do
        vim.validate('forge.keys.pr.' .. k, keys.pr[k], key_or_false, 'string or false')
      end
    end
    if keys.issue ~= nil then
      vim.validate('forge.keys.issue', keys.issue, 'table')
      for _, k in ipairs({ 'browse', 'close', 'filter', 'refresh' }) do
        vim.validate('forge.keys.issue.' .. k, keys.issue[k], key_or_false, 'string or false')
      end
    end
    if keys.ci ~= nil then
      vim.validate('forge.keys.ci', keys.ci, 'table')
      for _, k in ipairs({ 'log', 'browse', 'failed', 'passed', 'running', 'all', 'refresh' }) do
        vim.validate('forge.keys.ci.' .. k, keys.ci[k], key_or_false, 'string or false')
      end
    end
    if keys.commits ~= nil then
      vim.validate('forge.keys.commits', keys.commits, 'table')
      for _, k in ipairs({ 'checkout', 'diff', 'browse', 'yank' }) do
        vim.validate(
          'forge.keys.commits.' .. k,
          keys.commits[k],
          key_or_false,
          'string or false'
        )
      end
    end
    if keys.branches ~= nil then
      vim.validate('forge.keys.branches', keys.branches, 'table')
      for _, k in ipairs({ 'diff', 'browse' }) do
        vim.validate(
          'forge.keys.branches.' .. k,
          keys.branches[k],
          key_or_false,
          'string or false'
        )
      end
    end
  end

  for name, source in pairs(cfg.sources) do
    vim.validate('forge.sources.' .. name, source, 'table')
    if source.hosts ~= nil then
      vim.validate('forge.sources.' .. name .. '.hosts', source.hosts, 'table')
    end
  end

  return cfg
end

---@param args string[]
function M.yank_url(args)
  vim.system(args, { text = true }, function(result)
    if result.code == 0 then
      local url = vim.trim(result.stdout or '')
      if url ~= '' then
        vim.schedule(function()
          vim.fn.setreg('+', url)
        end)
      end
    end
  end)
end

---@param branch string
---@param base string
---@return string title, string body
local function fill_from_commits(branch, base)
  local result = vim
    .system({ 'git', 'log', 'origin/' .. base .. '..HEAD', '--format=%s%n%b%x00' }, { text = true })
    :wait()
  local raw = vim.trim(result.stdout or '')
  if raw == '' then
    local clean = branch:gsub('^%w+/', ''):gsub('[/-]', ' ')
    return clean, ''
  end

  local commits = {}
  for chunk in raw:gmatch('([^%z]+)') do
    local lines = vim.split(vim.trim(chunk), '\n', { plain = true })
    local subject = lines[1] or ''
    local body = vim.trim(table.concat(lines, '\n', 2))
    table.insert(commits, { subject = subject, body = body })
  end

  if #commits == 0 then
    local clean = branch:gsub('^%w+/', ''):gsub('[/-]', ' ')
    return clean, ''
  end

  if #commits == 1 then
    return commits[1].subject, commits[1].body
  end

  local clean = branch:gsub('^%w+/', ''):gsub('[/-]', ' ')
  local lines = {}
  for _, c in ipairs(commits) do
    table.insert(lines, '- ' .. c.subject)
  end
  return clean, table.concat(lines, '\n')
end

---@param f forge.Forge
---@param repo_root string
---@return string?
local function discover_template(f, repo_root)
  local paths = f:template_paths()
  for _, p in ipairs(paths) do
    local full = repo_root .. '/' .. p
    local stat = vim.uv.fs_stat(full)
    if stat and stat.type == 'file' then
      local fd = vim.uv.fs_open(full, 'r', 438)
      if fd then
        local content = vim.uv.fs_read(fd, stat.size, 0)
        vim.uv.fs_close(fd)
        if content then
          return vim.trim(content)
        end
      end
    elseif stat and stat.type == 'directory' then
      local handle = vim.uv.fs_scandir(full)
      if handle then
        local templates = {}
        while true do
          local name, typ = vim.uv.fs_scandir_next(handle)
          if not name then
            break
          end
          if (typ == 'file' or not typ) and name:match('%.md$') then
            table.insert(templates, name)
          end
        end
        if #templates == 1 then
          local tpath = full .. '/' .. templates[1]
          local tstat = vim.uv.fs_stat(tpath)
          if tstat then
            local fd = vim.uv.fs_open(tpath, 'r', 438)
            if fd then
              local content = vim.uv.fs_read(fd, tstat.size, 0)
              vim.uv.fs_close(fd)
              if content then
                return vim.trim(content)
              end
            end
          end
        elseif #templates > 1 then
          table.sort(templates)
          local chosen
          vim.ui.select(templates, {
            prompt = 'PR template: ',
          }, function(choice)
            chosen = choice
          end)
          if chosen then
            local tpath = full .. '/' .. chosen
            local tstat = vim.uv.fs_stat(tpath)
            if tstat then
              local fd = vim.uv.fs_open(tpath, 'r', 438)
              if fd then
                local content = vim.uv.fs_read(fd, tstat.size, 0)
                vim.uv.fs_close(fd)
                if content then
                  return vim.trim(content)
                end
              end
            end
          end
        end
      end
    end
  end
  return nil
end

---@param f forge.Forge
---@param branch string
---@param title string
---@param body string
---@param pr_base string
---@param pr_draft boolean
---@param pr_reviewers string[]?
---@param buf integer?
local function push_and_create(f, branch, title, body, pr_base, pr_draft, pr_reviewers, buf)
  M.log_now('pushing and creating ' .. f.labels.pr_one .. '...')
  vim.system({ 'git', 'push', '-u', 'origin', branch }, { text = true }, function(push_result)
    if push_result.code ~= 0 then
      local msg = vim.trim(push_result.stderr or '')
      if msg == '' then
        msg = 'push failed'
      end
      M.log(msg, vim.log.levels.ERROR)
      return
    end
    vim.system(
      f:create_pr_cmd(title, body, pr_base, pr_draft, pr_reviewers),
      { text = true },
      function(create_result)
        vim.schedule(function()
          if create_result.code == 0 then
            local url = vim.trim(create_result.stdout or '')
            if url ~= '' then
              vim.fn.setreg('+', url)
            end
            M.log_now(('created %s → %s'):format(f.labels.pr_one, url))
            M.clear_list()
            if buf and vim.api.nvim_buf_is_valid(buf) then
              vim.bo[buf].modified = false
              vim.api.nvim_buf_delete(buf, { force = true })
            end
          else
            local msg = vim.trim(create_result.stderr or '')
            if msg == '' then
              msg = vim.trim(create_result.stdout or '')
            end
            if msg == '' then
              msg = 'creation failed'
            end
            M.log_now(msg, vim.log.levels.ERROR)
          end
          vim.cmd.redraw()
        end)
      end
    )
  end)
end

---@param f forge.Forge
---@param branch string
---@param base string
---@param draft boolean
local function open_compose_buffer(f, branch, base, draft)
  local root = git_root() or ''
  local title, commit_body = fill_from_commits(branch, base)
  local template = discover_template(f, root)
  local body = template or commit_body

  local buf = vim.api.nvim_create_buf(false, true)
  vim.api.nvim_buf_set_name(buf, 'forge://pr/new')
  vim.bo[buf].buftype = 'acwrite'
  vim.bo[buf].filetype = 'markdown'
  vim.bo[buf].swapfile = false

  local lines = { title, '' }
  if body ~= '' then
    for _, line in ipairs(vim.split(body, '\n', { plain = true })) do
      table.insert(lines, line)
    end
  else
    table.insert(lines, '')
  end

  table.insert(lines, '')
  local comment_start = #lines + 1

  local pr_kind = f.labels.pr_full:gsub('s$', '')
  local diff_stat = vim.fn.system('git diff --stat origin/' .. base .. '..HEAD'):gsub('%s+$', '')

  ---@type {line: integer, col: integer, end_col: integer, hl: string}[]
  local marks = {}

  local function add_line(fmt, ...)
    local text = fmt:format(...)
    table.insert(lines, text)
    return #lines
  end

  ---@param ln integer
  ---@param start integer
  ---@param len integer
  ---@param hl_group string
  local function mark(ln, start, len, hl_group)
    table.insert(marks, { line = ln, col = start, end_col = start + len, hl = hl_group })
  end

  add_line('<!--')

  local branch_prefix = '  On branch '
  local against = ' against '
  local ln = add_line('%s%s%s%s.', branch_prefix, branch, against, base)
  mark(ln, #branch_prefix, #branch, 'ForgeComposeBranch')
  mark(ln, #branch_prefix + #branch + #against, #base, 'ForgeComposeBranch')

  local creating_prefix = '  Creating ' .. pr_kind .. ' via '
  ln = add_line('%s%s.', creating_prefix, f.name)
  mark(ln, #creating_prefix, #f.name, 'ForgeComposeForge')

  add_line('')
  if f.capabilities.draft then
    local draft_val = draft and 'yes' or ''
    local draft_prefix = '  Draft: '
    ln = add_line('%s%s', draft_prefix, draft_val)
    if draft_val ~= '' then
      mark(ln, #draft_prefix, #draft_val, 'ForgeComposeDraft')
    end
  end

  if f.capabilities.reviewers then
    local reviewers_prefix = '  Reviewers: '
    add_line('%s', reviewers_prefix)
  end

  local stat_start, stat_end
  if diff_stat ~= '' then
    add_line('')
    local changes_prefix = '  Changes not in origin/'
    ln = add_line('%s%s:', changes_prefix, base)
    mark(ln, #changes_prefix, #base, 'ForgeComposeBranch')
    add_line('')
    stat_start = #lines + 1
    for _, sl in ipairs(vim.split(diff_stat, '\n', { plain = true })) do
      table.insert(lines, '  ' .. sl)
    end
    stat_end = #lines
  end
  add_line('')
  add_line('  An empty title or body aborts creation.')
  add_line('-->')

  vim.api.nvim_buf_set_lines(buf, 0, -1, false, lines)
  vim.bo[buf].modified = false

  vim.api.nvim_set_current_buf(buf)

  if stat_start and stat_end then
    for i = stat_start, stat_end do
      local line = lines[i]
      local pipe = line:find('|')
      if pipe then
        local fname_start = line:find('%S')
        if fname_start then
          mark(i, fname_start - 1, pipe - fname_start - 1, 'ForgeComposeFile')
        end
        for pos, run in line:gmatch('()([+-]+)') do
          if pos > pipe then
            local stat_hl = run:sub(1, 1) == '+' and 'ForgeComposeAdded' or 'ForgeComposeRemoved'
            mark(i, pos - 1, #run, stat_hl)
          end
        end
      end
    end
  end

  for _, m in ipairs(marks) do
    vim.api.nvim_buf_set_extmark(buf, compose_ns, m.line - 1, m.col, {
      end_col = m.end_col,
      hl_group = m.hl,
      priority = 200,
    })
  end
  for i = comment_start, #lines do
    vim.api.nvim_buf_set_extmark(buf, compose_ns, i - 1, 0, {
      line_hl_group = 'ForgeComposeComment',
      priority = 200,
    })
  end

  ---@return boolean, string[], string
  local function parse_comment()
    local buf_lines = vim.api.nvim_buf_get_lines(buf, 0, -1, false)
    local in_comment = false
    local pr_draft = false
    local pr_reviewers = {}
    for _, l in ipairs(buf_lines) do
      if l:match('^<!--') then
        in_comment = true
      elseif l:match('^%-%->') then
        break
      elseif in_comment then
        local dv = l:match('^%s*Draft:%s*(.*)$')
        if dv then
          dv = vim.trim(dv):lower()
          pr_draft = dv == 'yes' or dv == 'true'
        end
        local rv = l:match('^%s*Reviewers:%s*(.*)$')
        if rv then
          for r in vim.trim(rv):gmatch('[^,%s]+') do
            table.insert(pr_reviewers, r)
          end
        end
      end
    end
    return pr_draft, pr_reviewers, base
  end

  vim.api.nvim_create_autocmd('BufWriteCmd', {
    buffer = buf,
    callback = function()
      local buf_lines = vim.api.nvim_buf_get_lines(buf, 0, -1, false)
      local content_lines = {}
      for _, l in ipairs(buf_lines) do
        if l:match('^<!--') then
          break
        end
        table.insert(content_lines, l)
      end
      local pr_title = vim.trim(content_lines[1] or '')
      if pr_title == '' then
        M.log_now('aborting: empty title', vim.log.levels.WARN)
        vim.bo[buf].modified = false
        vim.api.nvim_buf_delete(buf, { force = true })
        return
      end
      local pr_body = vim.trim(table.concat(content_lines, '\n', 3))
      if pr_body == '' then
        M.log_now('aborting: empty body', vim.log.levels.WARN)
        vim.bo[buf].modified = false
        vim.api.nvim_buf_delete(buf, { force = true })
        return
      end

      local pr_draft, pr_reviewers, pr_base = parse_comment()

      push_and_create(f, branch, pr_title, pr_body, pr_base, pr_draft, pr_reviewers, buf)
    end,
  })

  vim.api.nvim_win_set_cursor(0, { 1, 0 })
  vim.cmd('normal! 0vg_')
  vim.api.nvim_feedkeys(vim.api.nvim_replace_termcodes('<C-G>', true, false, true), 'n', false)
end

---@class forge.CreatePROpts
---@field draft boolean?
---@field instant boolean?
---@field web boolean?

---@param opts forge.CreatePROpts?
function M.create_pr(opts)
  opts = opts or {}

  local f = M.detect()
  if not f then
    M.log_now('no forge detected', vim.log.levels.WARN)
    return
  end

  local branch = vim.trim(vim.fn.system('git branch --show-current'))
  if branch == '' then
    M.log_now('detached HEAD', vim.log.levels.WARN)
    return
  end

  M.log_now('checking for existing ' .. f.labels.pr_one .. '...')

  vim.system(f:pr_for_branch_cmd(branch), { text = true }, function(result)
    local num = vim.trim(result.stdout or '')
    vim.schedule(function()
      if num ~= '' and num ~= 'null' then
        M.log_now(
          ('%s #%s already exists for branch %s'):format(f.labels.pr_one, num, branch),
          vim.log.levels.WARN
        )
        return
      end

      if opts.web then
        M.log_now('pushing...')
        vim.system({ 'git', 'push', '-u', 'origin', branch }, { text = true }, function(push_result)
          vim.schedule(function()
            if push_result.code ~= 0 then
              M.log_now('push failed', vim.log.levels.ERROR)
              return
            end
            local web_cmd = f:create_pr_web_cmd()
            if web_cmd then
              vim.system(web_cmd)
            end
          end)
        end)
        return
      end

      M.log_now('resolving base branch...')
      vim.system(f:default_branch_cmd(), { text = true }, function(base_result)
        local base = vim.trim(base_result.stdout or '')
        if base == '' then
          base = 'main'
        end
        vim.schedule(function()
          local has_diff = vim
            .system({ 'git', 'diff', '--quiet', 'origin/' .. base .. '..HEAD' }, { text = true })
            :wait().code ~= 0
          if not has_diff then
            M.log_now('no changes from origin/' .. base, vim.log.levels.WARN)
            return
          end
          if opts.instant then
            local title, body = fill_from_commits(branch, base)
            push_and_create(f, branch, title, body, base, opts.draft or false)
          else
            open_compose_buffer(f, branch, base, opts.draft or false)
          end
        end)
      end)
    end)
  end)
end

return M