import debugLog from "../logging/debug-log";
import { DSQLErrorObject } from "../../types";
import type { ConnectionConfig, Pool } from "mariadb";

export type ConnDBHandlerQueryObject = {
    query: string;
    values?: (string | number | undefined)[];
};

type Return<ReturnType = any> =
    | ReturnType
    | ReturnType[]
    | null
    | { error?: string; errors?: DSQLErrorObject[]; config?: ConnectionConfig };

/**
 * # Run Query From MySQL Connection
 * @description Run a query from a pre-existing MySQL/Mariadb Connection
 * setup with `serverless-mysql` npm module
 */
export default async function connDbHandler<ReturnType = any>(
    /**
     * MariaDB Connection Pool Object
     */
    connPool?: Pool,
    /**
     * String Or `ConnDBHandlerQueryObject` Array
     */
    query?: ConnDBHandlerQueryObject["query"] | ConnDBHandlerQueryObject[],
    /**
     * Array of Values to Sanitize and Inject
     */
    values?: ConnDBHandlerQueryObject["values"],
    debug?: boolean
): Promise<Return<ReturnType>> {
    try {
        if (!connPool) throw new Error("No Connection Found!");
        if (!query) throw new Error("Query String Required!");

        let queryErrorArray: DSQLErrorObject[] = [];

        if (typeof query == "string") {
            const res = await connPool.query(trimQuery(query), values);

            if (debug) {
                debugLog({
                    log: res,
                    addTime: true,
                    label: "res",
                });
            }

            if (Array.isArray(res)) {
                return Array.from(res);
            }

            return res;
        } else if (typeof query == "object") {
            const resArray = [];

            for (let i = 0; i < query.length; i++) {
                let currentQueryError: DSQLErrorObject = {};

                try {
                    const queryObj = query[i];

                    currentQueryError.sql = queryObj.query;
                    currentQueryError.sqlValues = queryObj.values;

                    const queryObjRes = await connPool.query(
                        trimQuery(queryObj.query),
                        queryObj.values
                    );

                    if (debug) {
                        debugLog({
                            log: queryObjRes,
                            addTime: true,
                            label: "queryObjRes",
                        });
                    }

                    if (Array.isArray(queryObjRes)) {
                        resArray.push(Array.from(queryObjRes));
                    } else {
                        resArray.push(queryObjRes);
                    }
                } catch (error: any) {
                    global.ERROR_CALLBACK?.(
                        `Connection DB Handler Query Error`,
                        error as Error
                    );
                    resArray.push(null);
                    currentQueryError["error"] = error.message;
                    queryErrorArray.push(currentQueryError);
                }
            }

            if (debug) {
                debugLog({
                    log: resArray,
                    addTime: true,
                    label: "resArray",
                });
            }

            if (queryErrorArray[0]) {
                return {
                    errors: queryErrorArray,
                };
            }

            return resArray;
        } else {
            return null;
        }
    } catch (error: any) {
        global.ERROR_CALLBACK?.(`Connection DB Handler Error`, error as Error);

        if (debug) {
            debugLog({
                log: `Connection DB Handler Error: ${error.message}`,
                addTime: true,
                label: "Error",
            });
        }

        return {
            error: `Connection DB Handler Error: ${error.message}`,
            // config: conn,
        };
    } finally {
        connPool?.end();
    }
}

function trimQuery(query: string) {
    return query.replace(/\n/gm, " ").replace(/ {2,}/g, " ").trim();
}