Http.alusus

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

module Http {
    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 stopFlag: int; // Should we stop event loop
    };

    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 {
    };

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

    func startServer (callback: RequestCallback, 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, 0, options.buf~ptr);
    }

    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, options);
    }

    func startServer(callback: RequestCallback, port: CharsPtr): ptr[Context] {
        return startServer(callback, { "listening_ports", 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;
};