Http.alusus

/*
 * Copyright (C) 2026 Sarmad Abdullah
 *
 * This file is part of Alusus Http library.
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 3 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, see <https://www.gnu.org/licenses/>.
 */

import "Srl/Memory.alusus";
import "Srl/Array.alusus";
import "Srl/String.alusus";
import "libcivetweb.so.1" or "libcivetweb.dylib";

module Http {
    use Srl;
    func getBuildDependencies(): Array[String] {
        return Array[String]({ String(getThisSourceDirectory[]) + preprocess {
            if String.isEqual(Process.platform, "macos") {
                Spp.astMgr.insertAst(ast "libcivetweb.dylib");
            } else {
                Spp.astMgr.insertAst(ast "libcivetweb.so.1");
            }
        } });
    }

    class Context{

    };

    def RequestCallback: alias ptr[func (connection: ptr[Connection]): Int];

    class Callbacks{
        def beginRequest: RequestCallback;
        def endRequest: ptr[func (connection: ptr[Connection], replyStatusCode: Int)];
        def logMessage: ptr[func (connection: ptr[Connection], message: CharsPtr): Int];
        def logAccess: ptr[func (connection: ptr[Connection], message: CharsPtr): Int];
        def initSsl: ptr[func (sslContext: ptr[Void], userData: ptr[Void]): Int];
        def initSslDomain: ptr[func (serverDomain: ptr[array[Char]], sslContext: ptr[Void], userData: ptr[Void]): Int];
        def externalSslCtx: ptr[func (sslCtx: ptr[ptr[Void]], userData: ptr[Void]): Int];
        def externalSslCtxDomain: ptr[func (
            serverDomain: ptr[array[Char]], sslCtx: ptr[ptr[Void]], userData: ptr[Void]
        ): Int];
        def connectionClose: ptr[func (connection: ptr[Connection]): Void];
        def connectionClosed: ptr[func (connection: ptr[Connection]): Void];
        def initLua: ptr[func (connection: ptr[Connection], luaContext: ptr[Void]): Void];
        def exitLua: ptr[func (connection: ptr[Connection], luaContext: ptr[Void]): Void];
        def httpError: ptr[func (connection: ptr[Connection], status: Int, msg: ptr[array[Char]]): Int];
        def initContext: ptr[func (context: ptr[Context]): Void];
        def exitContext: ptr[func (context: ptr[Context]): Void];
        def initThread: ptr[func (context: ptr[Context], threadType: Int): Void];
        def exitThread: ptr[func (context: ptr[Context], threadType: Int, threadPtr: ptr[Void]): Void];
        def initConnection: ptr[func (connection: ptr[Connection], connData: ptr[ptr[Void]]): Void];
    };

    class RequestInfo {
        def requestMethod: CharsPtr;        // "GET", "POST", etc
        def requestUri: CharsPtr;           // URL-decoded URI (absolute or relative, as in the request)
        def localUriRaw: CharsPtr;
        def localUri: CharsPtr;             // URL-decoded URI (relative). Can be NULL if the request_uri does not address
                                            // a resource at the server host.
        def httpVersion: CharsPtr;          // E.g. "1.0", "1.1"
        def queryString: CharsPtr;          // URL part after '?', not including '?', or NULL
        def remoteUser: CharsPtr;           // Authenticated user, or NULL if no auth used
        def remoteAddr: array[Char, 48];    // Client's IP address as a string.
        def contentLength: Int[64];         // Length (in bytes) of the request body, can be -1 if no length was given.
        def remotePort: Int;                // Client's port
        def serverPort: Int;
        def isSsl: Int;                     // 1 if SSL-ed, 0 if not
        def userData: ptr[Void];            // User data pointer passed to mg_start()
        def connData: ptr[Void];            // Connection-specific user data
        def numberHeaders: Int;             // Number of HTTP headers
        def httpHeaders: array[Header, 64]; // Maximum 64 headers
    };

    class Header {
        def name: CharsPtr;  // HTTP header name
        def value: CharsPtr; // HTTP header valuue
    };

    class Connection {
    };

    // WebSocket Types
    def WebSocketConnectCallback: alias ptr[func (connection: ptr[Connection], userData: ptr[Void]): Int];
    def WebSocketReadyCallback: alias ptr[func (connection: ptr[Connection], userData: ptr[Void]): Void];
    def WebSocketDataCallback: alias ptr[func (
        connection: ptr[Connection], opcode: Int, data: CharsPtr, dataLen: ArchWord, userData: ptr[Void]
    ): Int];
    def WebSocketCloseCallback: alias ptr[func (connection: ptr[Connection], userData: ptr[Void]): Void];

    @expname[mg_start]
    func startServer(callbacks: ptr[Callbacks], userData: ptr, options: ptr[CharsPtr]): ptr[Context];

    func startServer (callback: RequestCallback, userData: ptr, options: ref[Srl.Array[CharsPtr]]): ptr[Context] {
        def callbacks: Callbacks;
        Srl.Memory.set(callbacks~ptr, 0, Callbacks~size);
        callbacks.beginRequest = callback;

        return startServer(callbacks~ptr, userData, options.buf~ptr);
    }

    func startServer (callback: RequestCallback, options: ref[Srl.Array[CharsPtr]]): ptr[Context] {
        return startServer(callback, 0~cast[ptr], options);
    }

    func startServer (callback: RequestCallback, userData: ptr, optsCount: Int, opts: ...CharsPtr): ptr[Context] {
        def options: Srl.Array[CharsPtr];
        while optsCount-- > 0 options.add(opts~next_arg[CharsPtr]);
        options.add(0);

        return startServer(callback, userData, options);
    }

    func startServer (callback: RequestCallback, optsCount: Int, opts: ...CharsPtr): ptr[Context] {
        def options: Srl.Array[CharsPtr];
        while optsCount-- > 0 options.add(opts~next_arg[CharsPtr]);
        options.add(0);

        return startServer(callback, 0~cast[ptr], options);
    }

    func startServer(callback: RequestCallback, userData: ptr, port: CharsPtr): ptr[Context] {
        return startServer(callback, userData, { "listening_ports", port });
    }

    func startServer(callback: RequestCallback, port: CharsPtr): ptr[Context] {
        return startServer(callback, 0~cast[ptr], port);
    }

    @expname[mg_stop]
    func stopServer(context: ptr[Context]): Void;

    // read data from client
    @expname[mg_read]
    func read(connection: ptr[Connection], buffer: ptr, bufferSize: Int): Int;

    // send data to client
    @expname[mg_write]
    func write(connection: ptr[Connection], buffer: CharsPtr, bufferSize: Int): Int;

    // work like write(), but allows to do message formatting
    @expname[mg_printf]
    func print(connection: ptr[Connection], format: CharsPtr, ...any): Int;

    @expname[mg_send_file]
    func sendFile(connection: ptr[Connection], fileName: CharsPtr): Void;

    @expname[mg_send_mime_file]
    func sendFile(connection: ptr[Connection], filename: CharsPtr, mime: CharsPtr): Void;

    @expname[mg_get_cookie]
    func getCookie(
        cookiesString: CharsPtr, cookieName: CharsPtr, outCookieContent: CharsPtr, outCookieSize: Word[64]
    ): Int;

    @expname[mg_get_header]
    func getHeader(connection: ptr[Connection], headerName: CharsPtr): CharsPtr;

    @expname[mg_get_request_info]
    func getRequestInfo(connection: ptr[Connection]): ptr[RequestInfo];

    @expname[mg_get_var]
    func getVariable(
        data: CharsPtr, dataSize: Int, variableName: CharsPtr, outVariable: CharsPtr, outVariableSize: Int
    ): Int;

    // WebSocket Funnctions

    @expname[mg_set_websocket_handler]
    func setWebSocketHandler(
        context: ptr[Context],
        uri: CharsPtr,
        connectHandler: WebSocketConnectCallback,
        readyHandler: WebSocketReadyCallback,
        dataHandler: WebSocketDataCallback,
        closeHandler: WebSocketCloseCallback,
        userData: ptr[Void]
    ): Void;

    @expname[mg_set_websocket_handler_with_subprotocols]
    func setWebSocketHandlerWithSubprotocols(
        context: ptr[Context],
        uri: CharsPtr,
        subprotocols: ptr[CharsPtr],
        connectHandler: WebSocketConnectCallback,
        readyHandler: WebSocketReadyCallback,
        dataHandler: WebSocketDataCallback,
        closeHandler: WebSocketCloseCallback,
        userData: ptr[Void]
    ): Void;

    func setWebSocketHandler(
        context: ptr[Context],
        uri: CharsPtr,
        connectHandler: WebSocketConnectCallback,
        readyHandler: WebSocketReadyCallback,
        dataHandler: WebSocketDataCallback,
        closeHandler: WebSocketCloseCallback
    ): Void {
        setWebSocketHandler(context, uri, connectHandler, readyHandler, dataHandler, closeHandler, 0~cast[ptr[Void]]);
    }

    @expname[mg_websocket_write]
    func writeToWebSocket(connection: ptr[Connection], opcode: Int, data: CharsPtr, dataLen: ArchWord): Int;

    func writeTextToWebSocket(connection: ptr[Connection], data: CharsPtr, dataLen: ArchWord): Int {
        return writeToWebSocket(connection, 1, data, dataLen);
    }

    func writeTextToWebSocket(connection: ptr[Connection], data: CharsPtr): Int {
        return writeToWebSocket(connection, 1, data, String.getLength(data));
    }

    func writeBinaryToWebSocket(connection: ptr[Connection], data: CharsPtr, dataLen: ArchWord): Int {
        return writeToWebSocket(connection, 2, data, dataLen);
    }

    func closeWebSocket(connection: ptr[Connection]): Int {
        return writeToWebSocket(connection, 8, "", 0);
    }
}