const DEFAULT_LOG_LEVELS_TO_LOG = ["debug","warn","info","error"];
const DEFAULT_LOG_AJAX_REQUESTS = true;

const DEFAULT_LOG_AJAX_REQUESTS_TO_CONSOLE = true;
const DEFAULT_LOG_AJAX_REQUESTS_TO_CONSOLE_ERROR_ONLY = true;
const DEFAULT_LOG_AJAX_REQUESTS_TO_CONSOLE_MAX_RESPONSE_CHARS = 200

///CURRENTLY THESE INDEXEDDB CONSTS ARE NOT USED, LEAVING HERE IN CASE I FIGURE OUT HOW TO WIRE THEM UP.
const DEFAULT_LOG_AJAX_REQUESTS_TO_INDEXEDDB = true;
const DEFAULT_LOG_AJAX_REQUESTS_TO_INDEXEDDB_ERROR_ONLY = true;
const DEFAULT_LOG_AJAX_REQUESTS_TO_INDEXEDDB_MAX_RESPONSE_CHARS = -1 //< 0 = log all, 0 = log none, > 0 log that # of chars
const DEFAULT_LOG_URL = 'https://usahaulerslog.solutionsmith.net/WebServices/LoggingMethods.aspx/SaveLogs';

const INTERNAL_LOG_URLS = {
    DEFAULT: "https://usahaulerslogdev.solutionsmith.net/WebServices/LoggingMethods.aspx/SaveLogs",
    DEV: "https://usahaulerslogdev.solutionsmith.net/WebServices/LoggingMethods.aspx/SaveLogs",
    PROD: "https://usahaulerslog.solutionsmith.net/WebServices/LoggingMethods.aspx/SaveLogs"
}
const DEFAULT_LOG_CONFIG_OBJECT = {
    id: 0,
    defaultLogLevelsToLog: DEFAULT_LOG_LEVELS_TO_LOG,
    logAjaxRequests: DEFAULT_LOG_AJAX_REQUESTS,
    logAjaxRequestsToConsole: DEFAULT_LOG_AJAX_REQUESTS_TO_CONSOLE,
    logAjaxRequestsToConsoleErrorOnly: DEFAULT_LOG_AJAX_REQUESTS_TO_CONSOLE_ERROR_ONLY,
    logAjaxRequestsToConsoleMaxResponseChars: DEFAULT_LOG_AJAX_REQUESTS_TO_CONSOLE_MAX_RESPONSE_CHARS,
    logAjaxRequestsToIndexedDB: DEFAULT_LOG_AJAX_REQUESTS_TO_INDEXEDDB,
    logAjaxRequestsToIndexedDBErrorOnly: DEFAULT_LOG_AJAX_REQUESTS_TO_INDEXEDDB_ERROR_ONLY,
    logAjaxRequestsToIndexedDBMaxResponseChars: DEFAULT_LOG_AJAX_REQUESTS_TO_INDEXEDDB_MAX_RESPONSE_CHARS
}

const OLD_CONSOLE_LOG = console.log;
const OLD_CONSOLE_DEBUG = console.debug;
const OLD_CONSOLE_WARN = console.warn;
const OLD_CONSOLE_INFO = console.info;
const OLD_CONSOLE_ERROR = console.error;

const USAHAULERSLOGGING_DATABASE_NAME = "usahaulerslogging";
const USAHAULERSLOGGING_DATABASE_VERSION = 1;

const INTERNAL_USAHAULERSLOGGING_USEHAULERSLOGGINGDBCONFIG_OBJECT_STORE = "usahaulersloggingdb.config";
const INTERNAL_USAHAULERSLOGGING_LOG_REFRESH_PERIOD = INTERNAL_MINUTE_MS * 5;

const INTERNAL_USAHAULERSLOGGING_LOG_OBJECT_STORE = "logs";
const INTERNAL_USAHAULERSLOGGING_LOG_INDEX_DATE = "date";
const INTERNAL_USAHAULERSLOGGING_LOG_INDEX_LEVEL = "level";
const INTERNAL_USAHAULERSLOGGING_LOG_INDEX_UPLOADED = "uploaded";
const INTERNAL_USAHAULERSLOGGING_MAXUPLOADQTY = 100

$.usaHaulersLoggingDB = {
    config: DEFAULT_LOG_CONFIG_OBJECT,
    shouldLogLevel: (level) => {
        var config = $.usaHaulersLoggingDB.config;
        if (config == null)
            config = DEFAULT_LOG_CONFIG_OBJECT;
        return config.defaultLogLevelsToLog.includes(level.trim().toLowerCase());
    },
    shouldLogAjaxRequests: function () {
        var config = $.usaHaulersLoggingDB.config;
        if (config == null)
            config = DEFAULT_LOG_CONFIG_OBJECT;
        return config.logAjaxRequests && (config.logAjaxRequestsToConsole || config.logAjaxRequestsToIndexedDB);
    },
    shouldLogAjaxRequestsToConsole: function () {
        var config = $.usaHaulersLoggingDB.config;
        if (config == null)
            config = DEFAULT_LOG_CONFIG_OBJECT;
        return config.logAjaxRequests && config.logAjaxRequestsToConsole;
    },
    shouldLogAjaxRequestsToConsoleErrorOnly: function () {
        var config = $.usaHaulersLoggingDB.config;
        if (config == null)
            config = DEFAULT_LOG_CONFIG_OBJECT;
        return config.logAjaxRequests && config.logAjaxRequestsToConsole && config.logAjaxRequestsToConsoleErrorOnly;
    },
    logAjaxRequestsToConsoleMaxResponseChars: function () {
        var config = $.usaHaulersLoggingDB.config;
        if (config == null)
            config = DEFAULT_LOG_CONFIG_OBJECT;
        return (config.logAjaxRequests && config.logAjaxRequestsToConsole ? config.logAjaxRequestsToConsoleMaxResponseChars : 0);
    },
    shouldLogAjaxRequestsToIndexedDB: function () {
        var config = $.usaHaulersLoggingDB.config;
        if (config == null)
            config = DEFAULT_LOG_CONFIG_OBJECT;
        return config.logAjaxRequests && config.logAjaxRequestsToIndexedDB && $.usaHaulersLoggingDB.dbInitialized;
    },
    shouldLogAjaxRequestsToIndexedDBErrorOnly: function () {
        var config = $.usaHaulersLoggingDB.config;
        if (config == null)
            config = DEFAULT_LOG_CONFIG_OBJECT;
        return config.logAjaxRequests && config.logAjaxRequestsToIndexedDB && config.logAjaxRequestsToIndexedDBErrorOnly;
    },
    logAjaxRequestsToIndexedDBMaxResponseChars: function () {
        var config = $.usaHaulersLoggingDB.config;
        if (config == null)
            config = DEFAULT_LOG_CONFIG_OBJECT;
        return (config.logAjaxRequests && config.logAjaxRequestsToIndexedDB ? config.logAjaxRequestsToIndexedDBMaxResponseChars : 0);
    },
    prepareLog: function (argumentArray) {
        var LOG_PREFIX = new Date().toISOString();
        var args = Array.from(argumentArray);
        args.unshift(LOG_PREFIX + ": ");
        return args;
    },
    getLogMsgFromArguments: function (argumentArray) {
        if (argumentArray === undefined || argumentArray === null)
            return "Unknown log request: null/undefined passed to getLogMsgFromArguments";

        var args = Array.from(argumentArray);

        var msg = "";

        args.forEach((arg) => {
            var msg1 = "";
            if (arg !== undefined && arg !== null) {
                if (typeof arg === 'object')
                    msg1 = JSON.stringify(arg);
                else
                    msg1 = arg.toString();

                if (msg.length > 0)
                    msg += ", ";

                msg += msg1;
            }
        });
        return msg;
    },
    getBoolean: function (variable) {
        if ($.getBoolean)
            return $.getBoolean(variable);

        var vtype;
        var toReturn;

        if (variable != null) {
            switch (typeof (variable)) {
                case 'boolean':
                    vtype = "boolean";
                    return variable;
                    break;

                case 'number':
                    vtype = "number";
                    if (variable == 0)
                        toReturn = false;
                    else toReturn = true;
                    break;

                case 'string':
                    vtype = "string";
                    if (variable.toLowerCase() == "true" || variable.toLowerCase() == "yes")
                        toReturn = true;
                    else if (variable.toLowerCase() == "false" || variable.toLowerCase() == "no")
                        toReturn = false;
                    else if (variable.length > 0)
                        toReturn = true;
                    else if (variable.length == 0)
                        toReturn = false;
                    break;

            }

            return toReturn;
        }
    },
    removeObjectMethodsForSerialization: function (obj) {
        try {
            return JSON.parse(JSON.stringify(obj));
        }
        catch (error) {
            return obj;
        }
    }
}

console.log = console.debug = function () {
    var args = $.usaHaulersLoggingDB.prepareLog(arguments);
    OLD_CONSOLE_DEBUG.apply(console, args);
    if ($.usaHaulersLoggingDB && $.usaHaulersLoggingDB.addLog && $.usaHaulersLoggingDB.dbInitialized && $.usaHaulersLoggingDB.shouldLogLevel("debug")) {
        var msg = $.usaHaulersLoggingDB.getLogMsgFromArguments(arguments);
        var dbArgs = Array.from(arguments);
        $.usaHaulersLoggingDB.addLog("DEBUG", msg, dbArgs);
    }
}
console.warn = function () {
    var args = $.usaHaulersLoggingDB.prepareLog(arguments);
    OLD_CONSOLE_WARN.apply(console, args);
    if ($.usaHaulersLoggingDB && $.usaHaulersLoggingDB.addLog && $.usaHaulersLoggingDB.dbInitialized && $.usaHaulersLoggingDB.shouldLogLevel("warn")) {
        var msg = $.usaHaulersLoggingDB.getLogMsgFromArguments(arguments);
        var dbArgs = Array.from(arguments);
        $.usaHaulersLoggingDB.addLog("WARN", msg, dbArgs);
    }
}
console.info = function () {
    var args = $.usaHaulersLoggingDB.prepareLog(arguments);
    OLD_CONSOLE_INFO.apply(console, args);
    if ($.usaHaulersLoggingDB && $.usaHaulersLoggingDB.addLog && $.usaHaulersLoggingDB.dbInitialized && $.usaHaulersLoggingDB.shouldLogLevel("info")) {
        var msg = $.usaHaulersLoggingDB.getLogMsgFromArguments(arguments);
        var dbArgs = Array.from(arguments);
        $.usaHaulersLoggingDB.addLog("INFO", msg, dbArgs);
    }
}
console.error = function () {
    var args = $.usaHaulersLoggingDB.prepareLog(arguments);
    OLD_CONSOLE_ERROR.apply(console, args);
    if ($.usaHaulersLoggingDB && $.usaHaulersLoggingDB.addLog && $.usaHaulersLoggingDB.dbInitialized && $.usaHaulersLoggingDB.shouldLogLevel("error")) {
        var msg = $.usaHaulersLoggingDB.getLogMsgFromArguments(arguments);
        var dbArgs = Array.from(arguments);
        $.usaHaulersLoggingDB.addLog("ERROR", msg, dbArgs);
    }
}

if ($ && $.ajaxSetup) {
    $(document).ready(function () {
        $(document).ajaxSuccess(function (event, xhr, settings) {
            if ($.usaHaulersLoggingDB.shouldLogAjaxRequests()) {
                var responseText = "";
                var isSuccess = true;
                if (xhr.responseJson != null && xhr.responseJson.d != null && xhr.responseJson.d.success != null && !xhr.responseJson.d.success)
                    isSuccess = false;

                if (!$.usaHaulersLoggingDB.shouldLogAjaxRequestsToConsoleErrorOnly() || !isSuccess) {
                    if (xhr.responseText && xhr.responseText != null) {
                        if ($.usaHaulersLoggingDB.logAjaxRequestsToConsoleMaxResponseChars() <= 0 || xhr.responseText.length <= $.usaHaulersLoggingDB.logAjaxRequestsToConsoleMaxResponseChars())
                            responseText = "response = '" + xhr.responseText + "';";
                        else
                            responseText = "responseSnippet='" + xhr.responseText.substring(0, $.usaHaulersLoggingDB.logAjaxRequestsToConsoleMaxResponseChars()) + "';";
                    }
                }
                else {
                    return;
                }

                if ($.usaHaulersLoggingDB.shouldLogAjaxRequestsToConsole()) {
                    if (!isSuccess)
                        console.debug("Ajax Success, returned success:false", {
                            url: settings.url,
                            httpMethod: settings.type,
                            responseText: responseText
                        });
                    else {
                        console.debug("Ajax Success", {
                            url: settings.url,
                            httpMethod: settings.type,
                            responseText: responseText
                        });
                    }
                }
            }
            if (xhr.responseJson != null && xhr.responseJson.d != null && xhr.responseJson.d.success != null && xhr.responseJson.d.success) {
                var lg_session_guid = request.getResponseHeader('lg_session_guid');
                var lg_access_token = $.getBoolean(request.getResponseHeader('lg_access_token'));
                var lg_application_code = $.getBoolean(request.getResponseHeader('lg_application_code'));
                var lg_application_user_id = $.getBoolean(request.getResponseHeader('lg_application_user_id'));
                if ($.cookie) {
                    $.cookie.raw = true;
                    $.cookie('lg_session_guid', lg_session_guid, { path: '/' });
                    $.cookie('lg_access_token', lg_access_token, { path: '/' });
                    $.cookie('lg_application_code', lg_application_code, { path: '/' });
                    $.cookie('lg_application_user_id', lg_application_user_id, { path: '/' });
                }
            }
        });
        $(document).ajaxError(function (event, xhr, settings) {
            if ($.usaHaulersLoggingDB.shouldLogAjaxRequests()) {
                var responseText = "";

            if (xhr.responseText && xhr.responseText != null) {
                    if ($.usaHaulersLoggingDB.logAjaxRequestsToConsoleMaxResponseChars() <= 0 || xhr.responseText.length <= $.usaHaulersLoggingDB.logAjaxRequestsToConsoleMaxResponseChars())
                        responseText = "response = '" + xhr.responseText + "';";
                    else
                        responseText = "responseSnippet='" + xhr.responseText.substring(0, $.usaHaulersLoggingDB.logAjaxRequestsToConsoleMaxResponseChars()) + "';";
                }

                if ($.usaHaulersLoggingDB.shouldLogAjaxRequestsToConsole()) {
                    console.error("Ajax Error", {
                        url: settings.url,
                        httpMethod: settings.type,
                        responseText: responseText,
                        xhr: $.usaHaulersLoggingDB.removeObjectMethodsForSerialization(xhr),
                        settings: $.usaHaulersLoggingDB.removeObjectMethodsForSerialization(settings)
                    });
                }
            }
        });
    });
}

const INTERNAL_USAHAULERSLOGGING_ONUPGRADEDNEEDED = function (event) {
    const db = event.target.result;
    const transaction = event.currentTarget.transaction;
    let oldVersion = event.oldVersion;
    let newVersion = event.newVersion;

    if (oldVersion < 1 && newVersion >= 1) {

        //setup object stores
        db.createObjectStore(INTERNAL_USAHAULERSLOGGING_USEHAULERSLOGGINGDBCONFIG_OBJECT_STORE, { keyPath: 'id' });

        if (db.objectStoreNames.contains(INTERNAL_USAHAULERSLOGGING_LOG_OBJECT_STORE)) {
            db.deleteObjectStore(INTERNAL_USAHAULERSLOGGING_LOG_OBJECT_STORE);
        }
        db.createObjectStore(INTERNAL_USAHAULERSLOGGING_LOG_OBJECT_STORE, { keyPath: 'id' });


        //setup indexes
        let store = transaction.objectStore(INTERNAL_USAHAULERSLOGGING_LOG_OBJECT_STORE);

        if (store.indexNames.contains(INTERNAL_USAHAULERSLOGGING_LOG_INDEX_DATE)) {
            store.deleteIndex(INTERNAL_USAHAULERSLOGGING_LOG_INDEX_DATE);
        }
        store.createIndex(INTERNAL_USAHAULERSLOGGING_LOG_INDEX_DATE, "date", { unique: false });

        if (store.indexNames.contains(INTERNAL_USAHAULERSLOGGING_LOG_INDEX_LEVEL)) {
            store.deleteIndex(INTERNAL_USAHAULERSLOGGING_LOG_INDEX_LEVEL);
        }
        store.createIndex(INTERNAL_USAHAULERSLOGGING_LOG_INDEX_LEVEL, "level", { unique: false });

        if (store.indexNames.contains(INTERNAL_USAHAULERSLOGGING_LOG_INDEX_UPLOADED)) {
            store.deleteIndex(INTERNAL_USAHAULERSLOGGING_LOG_INDEX_UPLOADED);
        }
        store.createIndex(INTERNAL_USAHAULERSLOGGING_LOG_INDEX_UPLOADED, "upload_status", { unique: false });

    }

    if (oldVersion < 2 && newVersion >= 2) {
        //
    }

}

$.extend($.usaHaulersLoggingDB, {
    dbInitialized: false,
    database: null,
    initializeDB: function () {
        let currentDB = this;
        return new Promise(function (resolve, reject) {
            if (currentDB.dbInitialized) {
                resolve();
                return;
            }

            currentDB.refreshConfigObject().then(function () {
                currentDB.dbInitialized = true;
                resolve();
            });
        });
    },
    createConfigObject: function () {
        let currentDB = this;
        var config = (!currentDB.config || currentDB.config == null ? DEFAULT_LOG_CONFIG_OBJECT : currentDB.config);
        return config;
    },
    refreshConfigObject: function () {
        let currentDB = this;
        return new Promise(async function (resolve, reject) {
            try {
                let config = await currentDB.getObjects(INTERNAL_USAHAULERSLOGGING_USEHAULERSLOGGINGDBCONFIG_OBJECT_STORE);
                let configDefault = currentDB.createConfigObject();

                if (!config || config.length == 0) {
                    currentDB.config = configDefault;
                    await currentDB.persistConfigObject();
                }
                else {
                    currentDB.config = config[0];
                    let updatedConfig = false;
                    for (const prop in configDefault) {
                        if (prop !== "id" || currentDB.config[prop] === undefined) {
                            updatedConfig = true;
                            currentDB.config[prop] = configDefault[prop];
                        }
                    }
                    if (updatedConfig)
                        await currentDB.persistConfigObject();
                }
                resolve();
            }
            catch (error) {
                reject(error);
            }
        });
    },
    persistConfigObject: function () {
        let currentDB = this;
        return currentDB.runTransactionReadWrite(INTERNAL_USAHAULERSLOGGING_USEHAULERSLOGGINGDBCONFIG_OBJECT_STORE, async function (transaction) {
            const configStore = transaction.objectStore(INTERNAL_USAHAULERSLOGGING_USEHAULERSLOGGINGDBCONFIG_OBJECT_STORE);

            configStore.put(currentDB.config);

            return transaction.complete;
        });
    }
});

//#region basic indexeddb methods
$.extend($.usaHaulersLoggingDB, {
    create: function (deleteIfExists = true) {
        return new Promise(async function (resolve, reject) {
            if (deleteIfExists === true) {
                try {
                    await $.dbManager.deleteDatabase(USAHAULERSLOGGING_DATABASE_NAME);
                }
                catch (error) {
                    reject(error);
                    return;
                }
            }
            try {
                await $.dbManager.openDatabase(USAHAULERSLOGGING_DATABASE_NAME, USAHAULERSLOGGING_DATABASE_VERSION, INTERNAL_USAHAULERSLOGGING_ONUPGRADEDNEEDED);
            }
            catch (error) {
                reject(error);
                return;
            }
            resolve();
        });
    },
    delete: function () {
        let currentDB = this;
        return $.dbManager.deleteDatabase(USAHAULERSLOGGING_DATABASE_NAME);
    },
    open: function () {
        let currentDB = this;
        return $.dbManager.openDatabase(USAHAULERSLOGGING_DATABASE_NAME, USAHAULERSLOGGING_DATABASE_VERSION, INTERNAL_USAHAULERSLOGGING_ONUPGRADEDNEEDED).then(
            function onSuccessInternal(db) {
                currentDB.database = db;
                if (!currentDB.dbInitialized)
                    return currentDB.initializeDB();
                else
                    return currentDB.refreshConfigObject();
            },
            function onErrorInternal(error) {
            }
        );
    },
    close: function () {
        let currentDB = this;

        return $.dbManager.closeDatabase(USAHAULERSLOGGING_DATABASE_NAME).then(
            function onSuccessInternal(db) {
                currentDB.database = null;
            },
            function onErrorInternal(error) {
            }
        );
    },
    runTransactionReadOnly: function (objectNames, transactionCode) {
        let currentDB = this;
        return new Promise(function (resolve, reject) {
            if (transactionCode != null) {
                let didOpenDB = false;
                var onSuccessInternal = function () {
                    let transaction = currentDB.database.transaction(objectNames, "readonly");

                    transactionCode(transaction);

                    //if (didOpenDB)
                    //    currentDB.close();

                    transaction.oncomplete = function (event) {
                        resolve();
                    };

                    transaction.onerror = function (event) {
                        reject(error.error);
                    };
                    //Transactions auto-commit after scope ends, cannot manually commit
                };
                if ($.usaHaulersLoggingDB.database == null) {
                    didOpenDB = true;
                    currentDB.open().then(
                        onSuccessInternal,
                        function onErrorInternal(error) {
                            reject(error);
                        });
                }
                else {
                    onSuccessInternal();
                }
            }
            else {
                reject("No transactionCode passed");
            }
        });
    },
    runTransactionReadWrite: function (objectNames, transactionCode) {
        let currentDB = this;
        return new Promise(function (resolve, reject) {
            if (transactionCode != null) {
                let didOpenDB = false;
                var onSuccessInternal = function () {
                    let transaction = currentDB.database.transaction(objectNames, "readwrite");

                    transactionCode(transaction);

                    //if (didOpenDB)
                    //    currentDB.close();

                    transaction.oncomplete = function (event) {
                        resolve();
                    };

                    transaction.onerror = function (event) {
                        reject(error.error);
                    };
                    //Transactions auto-commit after scope ends, cannot manually commit
                };
                if ($.usaHaulersLoggingDB.database == null) {
                    didOpenDB = true;
                    currentDB.open().then(
                        onSuccessInternal,
                        function onErrorInternal(error) {
                            reject(error);
                        });
                }
                else {
                    onSuccessInternal();
                }
            }
            else {
                reject("No transactionCode passed");
            }
        });
    },
    getObjects: function (objectName, query, indexes) {
        let currentDB = this;
        return new Promise(function (resolve, reject) {
            currentDB.runTransactionReadOnly(objectName, function (transaction) {
                const objectStore = transaction.objectStore(objectName);
                let request = {};
                if (indexes && ((typeof indexes === "string" || indexes instanceof String) == false || indexes.length > 0))
                    if (query
                        && (typeof query === "IDBKeyRange" || query instanceof IDBKeyRange || typeof query === "string" || query instanceof String))
                        request = objectStore.index(indexes).getAll(query);
                    else
                        request = objectStore.index(indexes).getAll();
                else
                    if (query
                        && (typeof query === "IDBKeyRange" || query instanceof IDBKeyRange || typeof query === "string" || query instanceof String))
                        request = objectStore.getAll(query);
                    else
                        request = objectStore.getAll()
                request.onsuccess = function () {
                    if (request.result !== undefined) {
                        objects = request.result;
                        resolve(objects);
                    }
                    else {
                        console.log("no objects found: ", objectName);
                        reject("no objects found: ", objectName);
                    }
                };
                request.onerror = function (error) {
                    console.log("Error getting objects(", objectName, ") from db: ", error);
                    reject(error);
                };
            });
        });
    },
    getObjectsCustom: function (objectName, query, indexes, predicateBlock) {
        let currentDB = this;
        return new Promise(function (resolve, reject) {
            currentDB.runTransactionReadOnly(objectName, function (transaction) {
                const objectStore = transaction.objectStore(objectName);
                let request = {};
                if (indexes && ((typeof indexes === "string" || indexes instanceof String) == false || indexes.length > 0))
                    request = (query && ((typeof query === "string" || query instanceof String) == false || query.length > 0) ? objectStore.index(indexes).getAll(query) : objectStore.index(indexes).getAll());
                else
                    request = (query && ((typeof query === "string" || query instanceof String) == false || query.length > 0) ? objectStore.getAll(query) : objectStore.getAll());

                request.onsuccess = function () {
                    if (request.result !== undefined) {
                        let objectsUnfiltered = request.result;
                        let objects = [];
                        for (ix in objectsUnfiltered) {
                            if (!predicateBlock || predicateBlock(objectsUnfiltered[ix])) {
                                objects.push(objectsUnfiltered[ix]);
                            }
                        }
                        resolve(objects);
                    }
                    else {
                        console.log("no objects found: ", objectName);
                        reject("no objects found: ", objectName);
                    }
                };
                request.onerror = function (error) {
                    console.log("Error getting objects(", objectName, ") from db: ", error);
                    reject(error);
                };
            });
        });
    },
    deleteAllObjects: function () {
        let currentDB = this;
        var error = null;
        var objectNames = INTERNAL_USAHAULERSLOGGING_LOG_OBJECT_STORE;
        return this.runTransactionReadWrite(objectNames, async function (transaction) {
            const logStore = transaction.objectStore(INTERNAL_USAHAULERSLOGGING_LOG_OBJECT_STORE);
            try {
                await logStore.clear();
            }
            catch (error2) {
                error = error2;
            }
            return transaction.complete;
        });
        if (error) {
            throw error;
        }
    }
});
//#endregion

//ADD NON-GENERIC METHODS
$.extend($.usaHaulersLoggingDB, {
    newGuid: function () {
        return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, function (c) {
            const r = Math.random() * 16 | 0,
                v = c == 'x' ? r : (r & 0x3 | 0x8);
            return v.toString(16);
        });
    },
    createLogObjectInternal: function (id, level, msg, args, date) {
        return {
            id: (id == null ? this.newGuid() : id),
            version: '1.0',
            url: window.location.href,
            application_code: $.cookie('lg_application_code'),
            application_user_id: $.cookie('lg_application_user_id'),
            environment_code: $.cookie('lg_environment_code'),
            level: level,
            msg: msg,
            arguments: args,
            date: (date == null ? new Date() : date),
            time: (date == null ? new Date() : date).toISOString(),
            uploaded: false,
            upload_status: 'Not Uploaded',
            upload_date: null
        }
    },
    createLogObject: function (level, msg, args) {
        return this.createLogObjectInternal(null, level, msg, args, null);
    },
    addLog: async function (level, msg, args) {
        let currentDB = this;

        args = currentDB.removeObjectMethodsForSerialization(args);
        try {
            await currentDB.refreshConfigObject();
            var error = null;
            var log = currentDB.createLogObject(level, msg, args);
            return this.runTransactionReadWrite(INTERNAL_USAHAULERSLOGGING_LOG_OBJECT_STORE, async function (transaction) {
                const logStore = transaction.objectStore(INTERNAL_USAHAULERSLOGGING_LOG_OBJECT_STORE);
                logStore.put(log);
                return transaction.complete;
            }).then(
                function () {
                },
                function (errorInternal) {
                    error = errorInternal;
                }
            );

            if (error) {
                throw error;
            }
        }
        catch (error) {
            console.log(error);
            throw error;
        }
    },
    deleteLogs: async function (logs) {
        let currentDB = this;

        try {
            await currentDB.refreshConfigObject();
            var error = null;
            return this.runTransactionReadWrite(INTERNAL_USAHAULERSLOGGING_LOG_OBJECT_STORE, async function (transaction) {
                const logStore = transaction.objectStore(INTERNAL_USAHAULERSLOGGING_LOG_OBJECT_STORE);

                logs.forEach((log) => {
                    logStore.delete(log.id);
                });
                return transaction.complete;
            }).then(
                function () {
                },
                function (errorInternal) {
                    error = errorInternal;
                }
            );

            if (error) {
                throw error;
            }
        }
        catch (error) {
            console.log(error);
            throw error;
        }
    },
    getLogsByLevel: async function (level, startDate, endDate) {
        let currentDB = this;
        let levelText = "";
        if (level != undefined && level != null)
            levelText = level.toUpperCase();

        let query = levelText;

        let indexes = INTERNAL_USAHAULERSLOGGING_LOG_INDEX_LEVEL;
        let logs = await currentDB.getObjects(INTERNAL_USAHAULERSLOGGING_LOG_OBJECT_STORE, query, indexes);
        let logs2 = [];
        logs.forEach((log) => {
            if ((startDate == null || log.date >= startDate) && (endDate == null || log.date <= endDate))
                logs2.push(log);
        });

        logs2.sort(function (l1, l2) {
            return l1.date - l2.date;
        });

        return logs2;
    },
    getLogsAll: async function (startDate, endDate) {
        let currentDB = this;
        let query = "";
        let logs = await currentDB.getObjects(INTERNAL_USAHAULERSLOGGING_LOG_OBJECT_STORE, query);
        let logs2 = [];
        logs.forEach((log) => {
            if ((startDate == null || log.date >= startDate) && (endDate == null || log.date <= endDate))
                logs2.push(log);
        });

        logs2.sort(function (l1, l2) {
            return l1.date - l2.date;
        });

        return logs2;
    },
    getLogsByUploaded: async function (uploaded, startDate, endDate) {
        let currentDB = this;
        let query = uploaded ? "Uploaded" : "Not Uploaded";

        let indexes = INTERNAL_USAHAULERSLOGGING_LOG_INDEX_UPLOADED;
        let logs = await currentDB.getObjects(INTERNAL_USAHAULERSLOGGING_LOG_OBJECT_STORE, query, indexes);
        let logs2 = [];
        logs.forEach((log) => {
            if ((startDate == null || log.date >= startDate) && (endDate == null || log.date <= endDate))
                logs2.push(log);
        });

        logs2.sort(function (l1, l2) {
            return l1.date - l2.date;
        });

        return logs2;
    },
    getLogsByUploadStatus: async function (uploadStatus, startDate, endDate) {
        let currentDB = this;
        let query = uploadStatus

        let indexes = INTERNAL_USAHAULERSLOGGING_LOG_INDEX_UPLOADED;
        let logs = await currentDB.getObjects(INTERNAL_USAHAULERSLOGGING_LOG_OBJECT_STORE, query, indexes);
        let logs2 = [];
        logs.forEach((log) => {
            if ((startDate == null || log.date >= startDate) && (endDate == null || log.date <= endDate))
                logs2.push(log);
        });

        logs2.sort(function (l1, l2) {
            return l1.date - l2.date;
        });

        return logs2;
    },
    markLogsUploaded: async function (logs) {
        let currentDB = this;

        try {
            await currentDB.refreshConfigObject();
            var error = null;

            logs.forEach((log) => {
                log.uploaded = true;
                log.upload_status = "Uploaded";
                log.upload_date = new Date();
            });
            return this.runTransactionReadWrite(INTERNAL_USAHAULERSLOGGING_LOG_OBJECT_STORE, async function (transaction) {
                const logStore = transaction.objectStore(INTERNAL_USAHAULERSLOGGING_LOG_OBJECT_STORE);
                logs.forEach((log) => {
                    logStore.put(log);
                });
                return transaction.complete;
            }).then(
                function () {
                },
                function (errorInternal) {
                    error = errorInternal;
                }
            );

            if (error) {
                throw error;
            }
        }
        catch (error) {
            console.error(error);
            //throw error;
        }

    },
    uploadLogs: async function () {
        var currentDB = this;
        try {
            await currentDB.refreshConfigObject();
            var logs = null;
            var maxUploadQty = INTERNAL_USAHAULERSLOGGING_MAXUPLOADQTY;
            if (maxUploadQty <= 0)
                maxUploadQty = 999999;

            do {
                logs = await currentDB.getLogsByUploaded(false, maxUploadQty);
                if (logs != null && logs.length > 0) {
                    var success = false;

                    //try {
                        success = await currentDB.uploadLogChunk(logs);
                    //}
                    //catch {
                    //    throw;
                    //}
                    if (!success) {
                        console.debug("currentDB.uploadLogChunk returned false");
                        return false;
                    }
                    //await currentDB.markLogsUploaded(logs);
                    await currentDB.deleteLogs(logs);
                    if (logs.length < maxUploadQty)
                        break;
                }
            } while (logs != null && logs.length > 0);
            return true;
        }
        catch (error) {
            if (!(error instanceof Error))
                console.error(JSON.stringify(error));
            else
                console.error(error);
            return false;
            //throw error;
        }
    },
    getLogURL: function () {
        var environmentCode = $.cookie('lg_environment_code');
        if (environmentCode === null || environmentCode.trim().length == 0)
            environmentCode = "DEFAULT";

        environmentCode = environmentCode.toUpperCase();
        var logUrl = INTERNAL_LOG_URLS[environmentCode];
        if (logUrl === null || logUrl.trim().length == 0)
            logUrl = INTERNAL_LOG_URLS['DEFAULT'];
        return logUrl;
    },
    uploadLogChunk: async function (logs) {
        var currentDB = this;

        var success = false;
        await $.ajax({
            type: "POST",
            url: currentDB.getLogURL(),
            data: JSON.stringify({ "jsonData": JSON.stringify(logs) }),
            contentType: 'application/json; charset=utf-8',
            dataType: 'json',
            async: true,
            cache: false,
            timeout: 30000,
            disable_auth_token:true,
            headers: {
                lg_session_id: $.cookie('lg_session_guid'),
                lg_access_token: $.cookie('lg_access_token')
            },
            success: function (value, textStatus, request) {
                var json = value.hasOwnProperty("d") ? $.parseJSON(value.d) : $.parseJSON(value);
                if (currentDB.getBoolean(json.success)) {
                    success = true;
                    return true;
                }
                success = false;
                return false;
            },
            error: function (xhr, error, errorThrown) {
                //if ((error instanceof jqXHR) 
                //    console.error(JSON.stringify(error));
                //else if (!(error instanceof Error))
                //    console.error(JSON.stringify(error));
                //else
                //    console.error(error);
                success = false;
                return false;
            }
        });
        return success;
    }
});

//TODO: Decide what to do here.  This PROBABLY should be a method call that the UI calls on page load, otherwise some calls could happen before this is done/ready.  Can't put await on this method, jquery .ready queue will not wait correctly. 
$(document).ready(function () {
    $.usaHaulersLoggingDB.open().then(() => {
        console.log("$.usaHaulersLoggingDB.open() success");
        return $.usaHaulersLoggingDB.initializeDB();
    })
    .then(() => {
        console.log("$.usaHaulersLoggingDB.initializeDB() success");
        return $.usaHaulersLoggingDB.uploadLogs();
    },
    (error) => {
        console.error(error);
    });
});

$(document).ajaxSend(function (event, xhr, settings) {
    if (settings.disable_auth_token) {
        xhr.setRequestHeader('Auth-Token', null);
        xhr.setRequestHeader('Auth-Impersonate-Guid', null);
        xhr.setRequestHeader('Auth-Current-Franchise', null);
    }
});