// @ts-nocheck

import fs from 'node:fs'
import os from 'node:os'
import path from 'node:path'
import { execSync } from 'node:child_process'

const rootDir = path.resolve(import.meta.dirname, '..')
const packagesDir = path.join(rootDir, 'packages')
const token = process.env.GH_TOKEN || process.env.GITHUB_TOKEN
const isPrerelease = process.argv.includes('--prerelease')

function run(command, options = {}) {
  return execSync(command, {
    cwd: rootDir,
    encoding: 'utf8',
    stdio: ['pipe', 'pipe', 'pipe'],
    ...options,
  }).trim()
}

function maybeRun(command) {
  try {
    return run(command)
  } catch {
    return null
  }
}

function getReleaseCommits() {
  const output = maybeRun(
    'git log --grep="ci: changeset release" --format=%H --no-merges',
  )

  if (!output) {
    return []
  }

  return output.split('\n').filter(Boolean)
}

function getPackages() {
  return fs
    .readdirSync(packagesDir, { withFileTypes: true })
    .filter((entry) => entry.isDirectory())
    .map((entry) => {
      const dir = entry.name
      const packageJsonPath = path.join(packagesDir, dir, 'package.json')
      const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8'))

      return {
        dir,
        packageJsonPath,
        packageJson,
      }
    })
    .filter(({ packageJson }) => !packageJson.private)
}

function getPreviousPackageJson(releaseCommit, packageJsonPath) {
  if (!releaseCommit) {
    return null
  }

  const relativePath = path.relative(rootDir, packageJsonPath)
  const content = maybeRun(`git show ${releaseCommit}:'${relativePath}'`)

  if (!content) {
    return null
  }

  return JSON.parse(content)
}

function getChangedPackages(previousReleaseCommit) {
  return getPackages()
    .map(({ dir, packageJsonPath, packageJson }) => {
      const previousPackageJson = getPreviousPackageJson(
        previousReleaseCommit,
        packageJsonPath,
      )

      if (
        !previousPackageJson ||
        previousPackageJson.version !== packageJson.version
      ) {
        return {
          dir,
          name: packageJson.name,
          version: packageJson.version,
          previousVersion: previousPackageJson?.version ?? null,
        }
      }

      return null
    })
    .filter(Boolean)
    .sort((left, right) => left.name.localeCompare(right.name))
}

function getChangelogSection(changelogPath, version) {
  if (!fs.existsSync(changelogPath)) {
    return null
  }

  const changelog = fs.readFileSync(changelogPath, 'utf8')
  const marker = `## ${version}`
  const start = changelog.indexOf(marker)

  if (start === -1) {
    return null
  }

  const bodyStart = changelog.indexOf('\n', start)
  const nextSection = changelog.indexOf('\n## ', bodyStart + 1)

  return changelog
    .slice(bodyStart + 1, nextSection === -1 ? undefined : nextSection)
    .trim()
}

function buildReleaseNotes(changedPackages) {
  const sections = changedPackages.map((pkg) => {
    const changelogPath = path.join(packagesDir, pkg.dir, 'CHANGELOG.md')
    const content =
      getChangelogSection(changelogPath, pkg.version) ||
      '- No changelog entries'

    return `#### ${pkg.name}\n\n${content}`
  })

  return sections.join('\n\n')
}

function createReleaseTag() {
  const now = new Date().toISOString()
  const tag = `release-${now.slice(0, 10)}-${now.slice(11, 13)}${now.slice(14, 16)}`
  const title = `Release ${now.slice(0, 10)} ${now.slice(11, 16)}`

  return { tag, title }
}

function createReleaseBody(title, changedPackages, notes) {
  const packages = changedPackages
    .map((pkg) => `- ${pkg.name}@${pkg.version}`)
    .join('\n')

  return `${title}\n\n## Changes\n\n${notes}\n\n## Packages\n\n${packages}`
}

function pushTag(tag) {
  const exists = maybeRun(`git rev-parse ${tag}`)

  if (exists) {
    return false
  }

  run(`git tag -a ${tag} -m "${tag}"`)
  run(`git push origin ${tag}`)
  return true
}

function createGitHubRelease(tag, title, body) {
  if (!token) {
    throw new Error('Missing GH_TOKEN or GITHUB_TOKEN')
  }

  const notesFile = path.join(os.tmpdir(), `${tag}.md`)
  fs.writeFileSync(notesFile, body)

  const args = [
    'gh',
    'release',
    'create',
    tag,
    '--title',
    JSON.stringify(title),
    '--notes-file',
    JSON.stringify(notesFile),
  ]

  if (isPrerelease) {
    args.push('--prerelease')
  } else {
    args.push('--latest')
  }

  try {
    execSync(args.join(' '), {
      cwd: rootDir,
      stdio: 'inherit',
      env: {
        ...process.env,
        GH_TOKEN: token,
        GITHUB_TOKEN: token,
      },
    })
  } finally {
    fs.rmSync(notesFile, { force: true })
  }
}

function rollbackTag(tag) {
  maybeRun(`git push --delete origin ${tag}`)
  maybeRun(`git tag -d ${tag}`)
}

function main() {
  const [, previousReleaseCommit] = getReleaseCommits()
  const changedPackages = getChangedPackages(previousReleaseCommit)

  if (changedPackages.length === 0) {
    console.log('No changed packages found for GitHub release.')
    return
  }

  const notes = buildReleaseNotes(changedPackages)
  const { tag, title } = createReleaseTag()
  const body = createReleaseBody(title, changedPackages, notes)

  let createdTag = false

  try {
    createdTag = pushTag(tag)
    createGitHubRelease(tag, title, body)
  } catch (error) {
    if (createdTag) {
      rollbackTag(tag)
    }

    throw error
  }
}

main()