local Future = require("@lib/Future")
local Net = require("@lune/net")
local Serde = require("@lune/serde")

type headers = {
    [string]: any
}

type body = {
    [any]: any
}

export type Response = {
    endpoint: any,
    data: Net.ServeResponse,
    hasFinished: boolean,
    future: Future.Future<Net.ServeResponse>,
    setHeaders: (self: Response, headers: headers? | {}) -> Response,
    getHeaders: (self: Response) -> headers,
    setHeader: (self: Response, name: string, value: any) -> Response,
    setBody: (self: Response, Data: any) -> Response,
    json: (self: Response) -> Response,
    setStatus: (self: Response, statusCode: number) -> Response,
    finished: (self: Response) -> boolean,
    finish: (self: Response) -> Response,
    await: (self: Response) -> Net.ServeResponse,
    new: (endpoint: any) -> Response
}

local Response: Response = {
    hasFinished = false
} :: Response

function Response:setHeaders(headers: headers? | {}): Response
    self.data.headers = headers or {}
    return self
end

function Response:getHeaders(): headers
    return self.data.headers
end

function Response:setHeader(name: string, value: any): Response
    self:setHeaders(self:getHeaders()) -- init with an empty table if non-existent
    self.data.headers[name] = value

    return self
end

function Response:setBody(data: any): Response
    self.data.body = data
    return self
end

function Response:json(data: any): Response
    self:setHeader("Content-Type", "application/json")
    self:setBody(Serde.encode("json", data))
    return self
end

function Response:setStatus(statusCode: number): Response
    self.data.status = statusCode
    return self
end

function Response:finish(): Response
    self.hasFinished = true
    self.future:resolve(self)

    return self
end

function Response:finished(): boolean
    return self.hasFinished
end

function Response:await(): Net.ServeResponse
    return self.future:await()
end

function Response.new(endpoint: any): Response
    local NewResponse = setmetatable({
        hasFinished = false,
        data = {},
        future = Future.defer(),
        endpoint = endpoint
    }, {__index = Response})

    return NewResponse
end

return Response