import axios from 'axios'
import semver from 'semver'
import type { App } from '../apps/_default'

export async function fetchGitHubReleases(
  app: App,
  platformIn: string[],
  archIn: string[],
  semverRangeIn: string,
) {
  const { repo, inferPlatformAndArch } = app
  const response = await axios.get(
    `https://api.github.com/repos/${repo}/releases`,
  )

  type GithubRelease = {
    tag_name: string
    assets: { name: string; browser_download_url: string }[]
  }

  const releases = response.data as GithubRelease[]

  const versions = releases.map((release) => release.tag_name.slice(1))

  const semverRange = (() => {
    if (semverRangeIn === 'latest') {
      const version = semver.maxSatisfying(versions, '*')
      if (version === null) {
        throw new Error(`Can't find latest version for ${repo}`)
      }
      return version
    }
    if (semverRangeIn === 'all') {
      return '*'
    }
    return semverRangeIn
  })()

  const matchingReleases = releases
    .map((release) => {
      return {
        assets: release.assets,
        version: release.tag_name.slice(1),
      }
    })
    .filter((release) => {
      const { version } = release
      return semver.satisfies(version, semverRange)
    })
    .map((release) => {
      return {
        ...release,
        assets: release.assets
          .filter((asset) => asset.name.startsWith('pocketbase_'))
          .map((asset) => {
            const { name, browser_download_url } = asset

            const { platform, arch } = inferPlatformAndArch(name)

            return {
              platform,
              arch,
              url: browser_download_url,
            }
          })
          .filter(({ platform, arch }) => {
            if (!archIn.includes(`all`) && !archIn.includes(arch)) {
              return false
            }
            if (!platformIn.includes(`all`) && !platformIn.includes(platform)) {
              return false
            }
            return true
          }),
      }
    })
  return matchingReleases
}