Http.ttslua

local Base64 = require('ge_tts.Base64')
local Logger = require('ge_tts.Logger')
local Json = require('ge_tts.Json')
local TableUtils = require('ge_tts.TableUtils')

---@shape ge_tts__Http_Response
---@field statusCode number
---@field headers table<string, string>
---@field body string | number[] | table

---@alias ge_tts__Http_Callback fun(response: nil | ge_tts__Http_Response, error: nil | string): void
---
---@type nil | string
local proxyUrl

---@type nil | string
local decodeJsonContentType = 'application/json'

---@class ge_tts__Http
local Http = {}

---@param url string
function Http.setProxyUrl(url)
    proxyUrl = url
end

---@return nil | string
function Http.getProxyUrl()
    return proxyUrl
end

---@param type nil | string
function Http.setDecodeJsonContentType(type)
    decodeJsonContentType = type
end

---@return nil | string
function Http.getDecodeJsonContentType()
    return decodeJsonContentType
end

---@param headers table<string, string>
---@param name string
---@return nil | string, nil | string @value, headerName - `headerName` being the case-sensitive variant of `name` found within headers
function Http.getHeader(headers, name)
    name = name:lower()

    return TableUtils.detect(headers, function(_, key)
        return key:lower() == name
    end)
end

---@param method string
---@param url string
---@param options table<string, any>
---@param callback ge_tts__Http_Callback
function Http.request(method, url, options, callback)
    Logger.assert(proxyUrl, 'Http must be configured with Http.setProxyUrl(\'YOUR_TTS_PROXY_URL\'). Please refer to https://gitlab.com/BenjaminDobell/tts-proxy for details.')

    content = Json.encode(TableUtils.merge(
        {
            headers={},
        },
        options,
        {
            method=method:upper(),
            url=url,
        }
    ))

    WebRequest.put(--[[---@not nil]] proxyUrl, content, function(request)
        if request.is_error then
            callback(nil, request.error)
        elseif request.is_done then
            Json.decodeAsync(request.text, {
                ---@param responseContent table
                onCompletion = function(responseContent)
                    ---@type ge_tts__Http_Response
                    local response = {
                        statusCode = responseContent.status_code,
                        headers = responseContent.headers,
                        body = responseContent.body or ""
                    }

                    if responseContent.base64 then
                        response.body = Base64.decode(response.body)
                        callback(response, nil)
                        return
                    end

                    local contentType = Http.getHeader(response.headers, 'Content-Type')

                    if contentType and (--[[---@not nil]] contentType):lower() == decodeJsonContentType then
                        Json.decodeAsync(request.text, {
                            ---@param value table
                            onCompletion = function(value)
                                response.body = value
                                callback(response, nil)
                            end,
                            onError = function(message)
                                callback(nil, "Failed to parse JSON body: " .. message)
                            end,
                        })
                        return
                    end

                    callback(response, nil)
                end,
                onError = function(message)
                    callback(nil, "Failed to parse proxy wrapper: " .. message)
                end,
            })
        end
    end)
end

---@param method string
---@param url string
---@param body number[] | table<string, any> | string @If provided as a table, it will be JSON encoded. If provided as a number array, numbers are assumed to be [0, 255] and Base64 encoded. Otherwise, the body is a string.
---@param headersOrNil nil | table<string, string>
---@param callback ge_tts__Http_Callback
function Http.submit(method, url, body, headersOrNil, callback)
    ---@type table<string, string>
    local headers = headersOrNil or {}

    ---@type table<string, any>
    local options = {headers = headers}

    if type((--[[---@type number[] ]] body)[1]) == 'number' then
        options = TableUtils.copy(options)
        options.base64 = true
        body = Base64.encode(--[[---@type number[] ]] body)
    elseif type(body) == 'table' then
        local contentType, contentTypeHeader = Http.getHeader(headers, 'Content-Type')
        contentTypeHeader = contentTypeHeader or 'Content-Type'

        if not (contentType and (--[[---@not nil]] contentType):sub(-4) == 'json') then
            headers = TableUtils.copy(headers)
            headers[--[[---@not nil]] contentTypeHeader] = 'application/json'
        end

        body = Json.encode(body)
    end

    options.body = body

    Http.request(method, url, options, callback)
end

---@param url string
---@param headers nil | table<string, string>
---@param callback ge_tts__Http_Callback
function Http.delete(url, headers, callback)
    Http.request('DELETE', url, {headers=headers}, callback)
end

---@param url string
---@param headers nil | table<string, string>
---@param callback ge_tts__Http_Callback
function Http.get(url, headers, callback)
    Http.request('GET', url, {headers=headers}, callback)
end

---@param url string
---@param body number[] | table<string, any> | string @If provided as a table, it will be JSON encoded. If provided as a number array, numbers are assumed to be [0, 255] and Base64 encoded. Otherwise, the body is a string.
---@param headers nil | table<string, string>
---@param callback ge_tts__Http_Callback
function Http.patch(url, body, headers, callback)
    Http.submit('PATCH', url, body, headers, callback)
end

---@param url string
---@param body number[] | table<string, any> | string @If provided as a table, it will be JSON encoded. If provided as a number array, numbers are assumed to be [0, 255] and Base64 encoded. Otherwise, the body is a string.
---@param headers nil | table<string, string>
---@param callback ge_tts__Http_Callback
function Http.post(url, body, headers, callback)
    Http.submit('POST', url, body, headers, callback)
end

---@param url string
---@param body number[] | table<string, any> | string @If provided as a table, it will be JSON encoded. If provided as a number array, numbers are assumed to be [0, 255] and Base64 encoded. Otherwise, the body is a string.
---@param headers nil | table<string, string>
---@param callback ge_tts__Http_Callback
function Http.put(url, body, headers, callback)
    Http.submit('PUT', url, body, headers, callback)
end

return Http