import { RequestMethod } from "../types/fetch.ts"
import { authorization } from "./client.ts"
import { sleep } from "../utils/utils.ts"

const ratelimitedPaths = new Map<string, RateLimitedPath>()

export interface RateLimitedPath {
  url: string
  resetTimestamp: number
}

setInterval(() => {
  const now = Date.now()
  ratelimitedPaths.forEach((value, key) => {
    if (value.resetTimestamp > now) return
    ratelimitedPaths.delete(key)
  })
}, 1000)

export const RequestManager = {
  // Something off about using runMethod with get breaks when using fetch
  get: async (url: string, body?: unknown) => {
    await checkRatelimits(url)
    const result = await fetch(url, createRequestBody(body))
    processHeaders(url, result.headers)

    return result.json()
  },
  post: (url: string, body?: unknown) => {
    return runMethod(RequestMethod.Post, url, body)
  },
  delete: (url: string, body?: unknown) => {
    return runMethod(RequestMethod.Delete, url, body)
  },
  patch: (url: string, body?: unknown) => {
    return runMethod(RequestMethod.Patch, url, body)
  },
  put: (url: string, body?: unknown) => {
    return runMethod(RequestMethod.Put, url, body)
  },
}

const createRequestBody = (body: any, method?: RequestMethod) => {
  return {
    headers: {
      Authorization: authorization,
      "User-Agent": `DiscordBot (https://github.com/skillz4killz/discordeno, 0.0.1)`,
      "Content-Type": "application/json",
      "X-Audit-Log-Reason": body ? encodeURIComponent(body.reason) : "",
    },
    body: JSON.stringify(body),
    method: method?.toUpperCase(),
  }
}

const runMethod = async (method: RequestMethod, url: string, body?: unknown) => {
  await checkRatelimits(url)
  const response = await fetch(url, createRequestBody(body, method))
  processHeaders(url, response.headers)

  // Sometimes Discord returns an empty 204 response that can't be made to JSON.
  if (response.status === 204) return

  return await response.json()
}

const checkRatelimits = async (url: string) => {
  const ratelimited = ratelimitedPaths.get(url)
  const global = ratelimitedPaths.get("global")

  const now = Date.now()
  if (ratelimited && now < ratelimited.resetTimestamp) await sleep(now - ratelimited.resetTimestamp)
  if (global && now < global.resetTimestamp) await sleep(now - global.resetTimestamp)
}

const processHeaders = (url: string, headers: Headers) => {
  // If a rate limit response is encountered this will become true and returned
  let ratelimited = false

  // Get all useful headers
  const remaining = headers.get("x-ratelimit-remaining")
  const resetTimestamp = headers.get("x-ratelimit-reset")
  const retryAfter = headers.get("retry-after")
  const global = headers.get("x-ratelimit-global")

  // If there is no remaining rate limit for this endpoint, we save it in cache
  if (remaining && remaining === "0") {
    ratelimited = true

    ratelimitedPaths.set(url, {
      url,
      resetTimestamp: Number(resetTimestamp),
    })
  }

  // If there is no remaining global limit, we save it in cache
  if (global) {
    ratelimited = true

    ratelimitedPaths.set("global", {
      url: "global",
      resetTimestamp: Date.now() + Number(retryAfter),
    })
  }

  // Returns a boolean to check if we need to request again once the rate limit resets
  return ratelimited
}