export module Context {
    const state: { connection: null | any } = { connection: null };

    export const Handler = async function () {
        /*** mongodb://localhost:27017 */
        const uri = process.env[ "DOCUMENTDB_URI" ] as string;

        if ( state.connection == null ) {
            state.connection = Mongoose.connect( uri, {
                /***
                 * Defaults to "test"; Personally, I also capitalize
                 * database name(s) and always keep them singular.
                 *
                 * The reasoning behing, say we're attempting to perform
                 * an action, programatically (psuedo-code):
                 *
                 * @example
                 * FILTER Authorization.username WHERE username === "Segmentational";
                 *
                 * Overall, it makes programattic usage seemingly more object-oriented
                 */
                dbName: "Authorization",
                /*** Required */
                replicaSet: "rs0",
                /*** Required */
                directConnection: true,
                /*** Required (Redacted) */
                user: process.env[ "DOCUMENTDB_USERNAME" ],
                /*** Required (Redacted) */
                pass: process.env[ "DOCUMENTDB_PASSWORD" ],
                /*** Optional (But Helps Time Spent Debugging) */
                serverSelectionTimeoutMS: 5000,
                /*** Required */
                retryWrites: false,
                /*** Required */
                tlsAllowInvalidHostnames: true,
                tlsAllowInvalidCertificates: true,
                /*** Required */
                tls: true,
                /*** Required */
                tlsCAFile: Path.join( __dirname, "us-east-2-bundle.pem" )
            } ).then( () => Mongoose );

            // `await`ing connection after assigning to the `conn` variable
            // to avoid multiple function calls, which creates new connections
            void await state.connection;
        }

        return state.connection;
    };

    void ( async () => Handler() );
}

/// See mongoose example for better inline annotations regarding
/// connection configuration
export const Connection = async function (): Promise<void> {
    if ( !( Connection.lock ) ) {
        const validator = new RegExp( "^(mongodb:(?:\\/{2})?)((\\w+?):(\\w+?)@|:?@?)(\\S+?):(\\d+)(\\/(\\S+?))?(\\?replicaSet=(\\S+?))?$", "gm" );

        const options: import("mongodb").MongoClientOptions = {
            auth: {
                username: "...",
                password: "..."
            },
            connectTimeoutMS: 5000,
            directConnection: true,
            replicaSet: "rs0",
            appName: "Nexus-API",
            authMechanism: "DEFAULT",
            tlsCAFile: Path.join( __dirname, "us-east-2-bundle.pem" ),
            tls: true,
            tlsAllowInvalidHostnames: true,
            tlsAllowInvalidCertificates: true,
            retryWrites: false
        } as const;

        Connection.options = options;

        // validator.test( (URI) ? URI : "" ) || ( () => {
        //     console.log( "Error - Invalid URI" );
        //     process.exit( 1 );
        // } )();
    }

    async function Handler(): Promise<import("mongodb").MongoClient | undefined> {
        return new Promise( async (resolve) => {
            const Client = await import("mongodb").then( (Module) => Module.MongoClient );

            /*** mongodb://localhost:27017 */
            Client.connect( process.env[ "MONGO_URI" ]!, Connection.options!, (exception, connection) => {
                if ( exception ) throw exception;

                Connection.client = connection;

                resolve( connection );
            } );
        } );
    }

    void await Handler();

    ( Connection?.client?.readyState !== 1 ) && Reflect.set( Connection, "lock", false );

    return ( Connection?.lock ) ? Connection?.client : Handler();
};

Connection.lock = false;

Connection.data = Object.create( {} );
Connection.options = Object.create( {} );
Connection.client = Object.create( {} );