// Draft PRs get a longer inactivity window than ready PRs, and only checking
// the keep-alive box in the bot's own comment resets the clock -- a
// CI-triggered push or unrelated comment shouldn't make an abandoned draft
// look "fresh". Checking a box is also easier to discover and use than
// remembering an exact phrase to comment.
'use strict';

const LABEL = "draft-stale";
const STALE_DAYS = 60;
const KEEPALIVE_MARKER = "<!-- draft-stale-keepalive -->";
const KEEPALIVE_CHECKBOX = "- [ ] Still working on this -- check this box to keep the draft open";
const KEEPALIVE_CHECKED_RE = /-\s*\[[xX]\]\s*Still working on this/;

const MS_PER_DAY = 24 * 60 * 60 * 1000;
const daysSince = (isoDate) => (Date.now() - new Date(isoDate).getTime()) / MS_PER_DAY;

async function ensureLabel(github, owner, repo) {
  try {
    await github.rest.issues.getLabel({ owner, repo, name: LABEL });
  } catch (err) {
    if (err.status !== 404) throw err;
    await github.rest.issues.createLabel({
      owner,
      repo,
      name: LABEL,
      color: "5319e7",
      description: "Draft PR with no activity past the draft staleness window",
    });
  }
}

async function findKeepAliveComment(github, owner, repo, issue_number) {
  const comments = await github.paginate(github.rest.issues.listComments, { owner, repo, issue_number, per_page: 100 });
  const marked = comments.filter((c) => c.body?.includes(KEEPALIVE_MARKER));
  return marked.length ? marked[marked.length - 1] : null; // most recent stale episode's comment
}

// pr.updated_at is bumped by metadata-only changes (reviewer requested/removed, labels,
// milestone, assignee, etc.), which would let a draft dodge the staleness check forever
// without any real work happening. Use the latest commit/comment/review activity instead.
// Bot comments are excluded — they represent automated activity, not real human progress.
//
// One exception: a checked keepalive checkbox (see KEEPALIVE_CHECKBOX) IS real human
// activity, even though it's an edit to the bot's own comment rather than a new one of
// the human's own — GitHub lets any collaborator toggle a task-list checkbox in-place
// without changing the comment's author. Without counting it here, confirming via the
// checkbox would remove the label and post "Thanks for confirming" without ever moving
// the underlying clock, so the very next scheduled run would see the same stale
// last-activity timestamp and immediately re-flag it — contradicting the checkbox's own
// promise that checking it "resets this" (PR #6326 thrashed the label on a ~1-2 day loop
// once its true last activity fell behind the 60-day window and only the checkbox, never
// a new commit or comment, was being used to confirm it).
async function lastRealActivityAt(github, owner, repo, pr) {
  const timestamps = [new Date(pr.created_at).getTime()];

  const commits = await github.paginate(github.rest.pulls.listCommits, { owner, repo, pull_number: pr.number, per_page: 100 });
  for (const c of commits) {
    const date = c.commit?.committer?.date || c.commit?.author?.date;
    if (date) timestamps.push(new Date(date).getTime());
  }

  const comments = await github.paginate(github.rest.issues.listComments, { owner, repo, issue_number: pr.number, per_page: 100 });
  for (const c of comments) {
    if (c.user?.type !== "Bot") {
      timestamps.push(new Date(c.created_at).getTime());
    } else if (c.body?.includes(KEEPALIVE_MARKER) && KEEPALIVE_CHECKED_RE.test(c.body)) {
      timestamps.push(new Date(c.updated_at).getTime());
    }
  }

  const reviews = await github.paginate(github.rest.pulls.listReviews, { owner, repo, pull_number: pr.number, per_page: 100 });
  for (const r of reviews) {
    if (r.submitted_at && r.user?.type !== "Bot") timestamps.push(new Date(r.submitted_at).getTime());
  }

  const reviewComments = await github.paginate(github.rest.pulls.listReviewComments, { owner, repo, pull_number: pr.number, per_page: 100 });
  for (const rc of reviewComments) {
    if (rc.user?.type !== "Bot") timestamps.push(new Date(rc.created_at).getTime());
  }

  return Math.max(...timestamps);
}

// Returns true and removes the label if the PR has a keepalive signal:
//   (a) the checkbox in the bot's keepalive comment is checked, OR
//   (b) a non-bot human posted a comment after the keepalive comment was created.
// Case (b) handles external contributors who lack write access to edit the bot's comment.
async function processStaleSignals(github, owner, repo, pr) {
  const keepAliveComment = await findKeepAliveComment(github, owner, repo, pr.number);

  const checkboxChecked = keepAliveComment && KEEPALIVE_CHECKED_RE.test(keepAliveComment.body);

  let humanCommentAfterStale = false;
  if (!checkboxChecked && keepAliveComment) {
    const staleDate = new Date(keepAliveComment.created_at);
    const allComments = await github.paginate(github.rest.issues.listComments, { owner, repo, issue_number: pr.number, per_page: 100 });
    for (const c of allComments) {
      if (c.user?.type !== "Bot" && new Date(c.created_at) > staleDate) {
        humanCommentAfterStale = true;
        break;
      }
    }
  }

  if (checkboxChecked || humanCommentAfterStale) {
    await github.rest.issues.removeLabel({ owner, repo, issue_number: pr.number, name: LABEL }).catch(() => {});
    await github.rest.issues.createComment({
      owner,
      repo,
      issue_number: pr.number,
      body: "Thanks for confirming — removing the stale label.",
    });
    return true;
  }
  return false;
}

async function runDraftPolicy({ github, context, core }) {
  const { owner, repo } = context.repo;
  await ensureLabel(github, owner, repo);

  // Fast path for issue_comment: only check the PR that received the comment.
  // This avoids scanning all open PRs on every comment event.
  if (context.eventName === "issue_comment") {
    const issue = context.payload.issue;
    // issue_comment fires for issues too; skip non-PRs (PRs have a pull_request field).
    if (!issue?.pull_request) return;

    let prData;
    try {
      ({ data: prData } = await github.rest.pulls.get({ owner, repo, pull_number: issue.number }));
    } catch (e) {
      return;
    }
    if (!prData.draft) return;

    const labelNames = prData.labels.map((l) => l.name);
    if (!labelNames.includes(LABEL)) return;

    const removed = await processStaleSignals(github, owner, repo, prData);
    core.info(`draft-pr-policy: PR #${issue.number} — ${removed ? "un-staled" : "still stale"} (issue_comment trigger)`);
    return;
  }

  // Full scan path for schedule / workflow_dispatch.
  const prs = await github.paginate(github.rest.pulls.list, { owner, repo, state: "open", per_page: 100 });
  const drafts = prs.filter((pr) => pr.draft);

  for (const pr of drafts) {
    const labelNames = pr.labels.map((l) => l.name);

    if (!labelNames.includes(LABEL)) {
      const lastActivity = await lastRealActivityAt(github, owner, repo, pr);
      if (daysSince(lastActivity) >= STALE_DAYS) {
        await github.rest.issues.addLabels({ owner, repo, issue_number: pr.number, labels: [LABEL] });
        await github.rest.issues.createComment({
          owner,
          repo,
          issue_number: pr.number,
          body:
            `${KEEPALIVE_MARKER}\n` +
            `This draft has had no activity for ${STALE_DAYS} days and has been marked \`${LABEL}\`.\n\n` +
            `${KEEPALIVE_CHECKBOX}\n\n` +
            `Checking the box or posting a new comment resets this — a commit or other automated update alone won't. ` +
            `Otherwise it will be flagged for maintainer review.`,
        });
      }
      continue;
    }

    await processStaleSignals(github, owner, repo, pr);
  }

  core.info(`draft-pr-policy: checked ${drafts.length} draft PR(s)`);
}

module.exports = { runDraftPolicy };