import { apiBaseURL } from "./config"
import * as sentry from "./sentry"
import * as SSR from "../api/hooks/lib/ssr.js"

// [MIT License](LICENSE.md) © [Jason Miller](https://jasonformat.com/)
const _f = function (url, options): Promise<Response> {
    if (typeof XMLHttpRequest === "undefined") {
        return Promise.resolve(null)
    }

    options = options || {}
    return new Promise((resolve, reject) => {
        const request = new XMLHttpRequest()
        const keys = []
        const all = []
        const headers = {}

        const response = (): Response => ({
            ok: ((request.status / 100) | 0) == 2, // 200-299
            statusText: request.statusText,
            status: request.status,
            url: request.responseURL,
            text: () => Promise.resolve(request.responseText),
            json: () => Promise.resolve(request.responseText).then(JSON.parse),
            blob: () => Promise.resolve(new Blob([request.response])),
            clone: response,
            headers: {
                // @ts-ignore
                keys: () => keys,
                // @ts-ignore
                entries: () => all,
                get: (n) => headers[n.toLowerCase()],
                has: (n) => n.toLowerCase() in headers,
            },
        })

        request.open(options.method || "get", url, true)

        request.onload = () => {
            request
                .getAllResponseHeaders()
                // @ts-ignore
                .replace(/^(.*?):[^\S\n]*([\s\S]*?)$/gm, (m, key, value) => {
                    keys.push((key = key.toLowerCase()))
                    all.push([key, value])
                    headers[key] = headers[key] ? `${headers[key]},${value}` : value
                })
            resolve(response())
        }

        request.onerror = reject

        request.withCredentials = options.credentials == "include"

        for (const i in options.headers) {
            request.setRequestHeader(i, options.headers[i])
        }

        request.send(options.body || null)
    })
}

const _fetch = typeof fetch === "undefined" ? (typeof window === "undefined" ? _f : window.fetch || _f) : fetch

export const api = async <T>(
    endpoint: string,
    options?: {
        method?: string
        filter?: any
        sort?: string
        limit?: number
        offset?: number
        projection?: string
        headers?: {
            [key: string]: string
        }
        params?: {
            [key: string]: string
        }
    }
): Promise<{ data: T; count: number }> => {
    if (typeof window === "undefined") {
        // ssr
        // @ts-ignore
        return context.ssrFetch(endpoint, options)
    }

    // try ssr cache
    const key = SSR.obj2str({ endpoint, options })
    // @ts-ignore
    if (window.__SSR_CACHE__) {
        // @ts-ignore
        const ssrVal = window.__SSR_CACHE__[key]
        console.log("SSR:", key, ssrVal)
        if (ssrVal) {
            return ssrVal
        }
    }

    let method = "GET"

    let query = "&count=1"
    if (options?.filter) query += "&filter=" + encodeURIComponent(JSON.stringify(options.filter))
    if (options?.sort) query += "&sort=" + options.sort + "&sort=_id"
    if (options?.limit) query += "&limit=" + options.limit
    if (options?.offset) query += "&offset=" + options.offset
    if (options?.projection) query += "&projection=" + options.projection

    if (options?.params) {
        Object.keys(options.params).forEach((p) => {
            query += "&" + p + "=" + encodeURIComponent(options.params[p])
        })
    }

    let headers: any = {
        "Content-Type": "application/json",
    }

    if (options?.headers) headers = { ...headers, ...options.headers }

    let url = apiBaseURL + endpoint + (query ? "?" + query : "")

    const span = sentry.currentTransaction()?.startChild({
        op: "fetch",
        description: method + " " + url,
        data: Object.assign({}, options, { url }),
    })
    const trace_id = span?.toTraceparent()
    if (trace_id) {
        headers["sentry-trace"] = trace_id
    }

    const response = await _fetch(url, {
        method,
        mode: "cors",
        headers,
    })

    span?.finish()

    // @ts-ignore
    let data = (await response?.json()) || null

    if (response?.status < 200 || response?.status >= 400) throw { response, data }

    // @ts-ignore
    return { data, count: response?.headers?.get("x-results-count") || 0 }
}

export const getContent = async (path: string): Promise<Content> => {
    const c = await api<Content[]>("content", { limit: 1, filter: { path } })
    if (c?.data?.length) {
        return c.data[0]
    }
    return null
}

export const getGeneralInformation = async (): Promise<GeneralInformation[]> => {
    try {
        let response = await api<GeneralInformation[]>("general", {
            method: "get",
            offset: 0,
            limit: 1,
            filter: {
                active: true,
            },
        })
        return response.data
    } catch (e) {
        return null
    }
}

export const getArticles = async (): Promise<TibiArticle[]> => {
    try {
        let response = await api<TibiArticle[]>("articles", {
            method: "get",
            offset: 0,
            filter: {
                active: true,
            },
        })
        return response.data
    } catch (e) {
        return null
    }
}