(function () {
  if (!window.cet || !window.cet.microservices || !window.cet.microservices.apiready) {
    window.cet = window.cet || {};
    cet.microservices = cet.microservices || {};

    let apiready = new Promise(function (resolve, reject) {
      var scriptElement = document.createElement("script");
      scriptElement.addEventListener('load', resolve);
      scriptElement.addEventListener('error', reject);
      var origin = document.currentScript.src.split('/', 3).join('/');
      scriptElement.src = origin + "/provider/ApiProvider.js?8dc3062e1069100";
      document.head.appendChild(scriptElement);
    });
    cet.microservices.apiready = apiready;
  }
  let selfUrl = document.currentScript.src;
  cet.microservices.apiready.then(() => {
    cet.microservices.api.system.addService(selfUrl);
  });
})();
window.cet = window.cet || {};
window.cet.microservices = window.cet.microservices || {};

cet.microservices.contentapi = (function () {
    const isSafe = true;

    // in order to call 'safe' api safely, load authapi in a promise:
    const accessManagementApiReady = isSafe ? cet.microservices.apiready.then(() => {
       
        return cet.microservices.api.loadApi("/accessmngapi/provider/accessmanagement.js", "apigateway");
    }) : cet.microservices.apiready;

    const settings = {
        apiUrl: "/contentapi/"
    }; 

    const isDevEnvironment = (location.host.indexOf('.dev') > 0 || location.host.indexOf('.testing') > 0);

    const baseURI = new URL(document.currentScript.src).origin;

    /*------------------------------------------------------------------------------*/
    /* Build URL query from the given payload object. */
    const buildQueryFromPayload = function (payload) {
        if (payload && typeof payload === 'object') {
            var str = [];

            for (var p in payload) {
                if (payload.hasOwnProperty(p)) {
                    if (Array.isArray(payload[p])) {
                        for (var i = 0; i < payload[p].length; i++) {
                            str.push(encodeURIComponent(p) + "=" + encodeURIComponent(payload[p][i]));
                        }
                    } else {
                        str.push(encodeURIComponent(p) + "=" + encodeURIComponent(payload[p]));
                    }
                }
            }

            return str.length > 0 ? '?' + str.join('&') : '';
        }

        return '';
    };

    /*------------------------------------------------------------------------------*/
    /* Validate single parameter. */
    const validateParameter = function (pName, pValue) {
        if ((typeof pValue === 'string' && pValue.trim().length === 0) ||
            (Array.isArray(pValue) && pValue.length === 0)) {
            return pName + ' cannot be empty';
        }

        return '';
    };

    /*------------------------------------------------------------------------------*/
    /* Validate request object. */
    const validateRequest = function (request, relevantParameters) {
        if (!request) {
            return 'request data is missing';
        }

        for (var i = 0; i < relevantParameters.length; i++) {
            var param = relevantParameters[i];
            var paramParts = param.split('.');

            var subRequest = request;

            if (paramParts.length > 1) {
                for (var p = 0; p < paramParts.length - 1; p++) {
                    subRequest = subRequest && subRequest[paramParts[p]];
                    param = paramParts[p + 1];
                }
            }

            if (!subRequest || !subRequest.hasOwnProperty(param)) {
                return relevantParameters[i] + ' is missing';
            } else {
                var error = validateParameter(relevantParameters[i], subRequest[param]);

                if (error) {
                    return error;
                }
            }
        }

        return '';
    };

    /*------------------------------------------------------------------------------*/
    const processRequest = (request) => {
        var promise = new Promise(function (resolve, reject) {
            var validationErrorMsg = request.validationParams ? validateRequest(request.data, request.validationParams) : '';
            if (validationErrorMsg) {
                isDevEnvironment && alert(validationErrorMsg);
                reject({
                    'name': 'ProviderValidationError',
                    'message': validationErrorMsg
                });
            } else {
                accessManagementApiReady.then(async () => {
                    try {
                        var result = null;
                        var _cetms = isSafe ? cetms.safe : cetms;

                        if (request.type === 'get') {
                            result = await _cetms.get(request.URL + buildQueryFromPayload(request.data));
                        } else if (request.type === 'post') {
                            result = await _cetms.post(request.URL, request.data);
                        }

                        resolve(result);
                    } catch (error) {
                        reject(error);
                    }
                }).catch(error => {
                    reject(error);
                });
            }
        });

        return promise;
    };

    //#region Mybag

    /*------------------------------------------------------------------------------*/
    const isBookAllowedToUser = (requestData) => {
        return processRequest({
            type: 'post',
            URL: settings.apiUrl + 'Mybag/isBookAllowedToUser',
            data: requestData,
            validationParams: []
        });
    };
    /*------------------------------------------------------------------------------*/
    const getAuthorizationInfo = (requestData) => {
        return processRequest({
            type: 'post',
            URL: settings.apiUrl + 'Mybag/getAuthorizationInfo',
            data: requestData,
            validationParams: []
        });
    };

    /*------------------------------------------------------------------------------*/
   
    //#region CONTENT

    /*------------------------------------------------------------------------------*/
    const getAllDimensions = (requestData) => {
        return processRequest({
            type: 'post',
            URL: settings.apiUrl + 'Content/GetAllDimensions',
            data: requestData,
            validationParams: []
        });
    };

    /*------------------------------------------------------------------------------*/
    const refreshDimensionsCache = (requestData) => {
        return processRequest({
            type: 'post',
            URL: settings.apiUrl + 'Content/RefreshDimensionsCache',
            data: requestData,
            validationParams: []
        });
    };

    /*------------------------------------------------------------------------------*/
    const CopyHeContentItemToAr = (requestData) => {
        return processRequest({
            type: 'post',
            URL: settings.apiUrl + 'Content/CopyHeContentItemToAr',
            data: requestData,
            validationParams: []
        });
    };

    /*------------------------------------------------------------------------------*/
    const getAllDimensionsByLanguage = (requestData) => {
        return processRequest({
            type: 'post',
            URL: settings.apiUrl + 'Content/GetAllDimensionsByLanguage',
            data: requestData,
            validationParams: ["lang"]
        });
    };

    /*------------------------------------------------------------------------------*/
    const getAllDimensionsAndDependencies = (requestData) => {
        return processRequest({
            type: 'post',
            URL: settings.apiUrl + 'Content/GetAllDimensionsAndDependencies',
            data: requestData,
            validationParams: []
        });
    };

    /*------------------------------------------------------------------------------*/
    const getDimension = (requestData) => {
        return processRequest({
            type: 'post',
            URL: settings.apiUrl + 'Content/GetDimension',
            data: requestData,
            validationParams: ["lang", "dimension"]
        });
    };

    /*------------------------------------------------------------------------------*/
    const getItemById = (requestData) => {
        return processRequest({
            type: 'post',
            URL: settings.apiUrl + 'Content/GetItemById',
            data: requestData,
            validationParams: ['itemId']
        });
    };

    /*------------------------------------------------------------------------------*/
    const getItemDimensions = (requestData) => {
        return processRequest({
            type: 'post',
            URL: settings.apiUrl + 'Content/GetItemDimensions',
            data: requestData,
            validationParams: ['itemId']
        });
    };

    /*------------------------------------------------------------------------------*/
    const getItemAndDimensionsById = (requestData) => {
        return processRequest({
            type: 'post',
            URL: settings.apiUrl + 'Content/GetItemAndDimensionsById',
            data: requestData,
            validationParams: ['itemId', 'lang']
        });
    };

    /*------------------------------------------------------------------------------*/
    const getItemAndDimensionsByIdFast = (requestData) => {
        return processRequest({
            type: 'post',
            URL: settings.apiUrl + 'Content/GetItemAndDimensionsByIdFast',
            data: requestData,
            validationParams: ['itemId', 'lang']
        });
    };

    /*------------------------------------------------------------------------------*/
    const updateItem = (requestData) => {
        return processRequest({
            type: 'post',
            URL: settings.apiUrl + 'Content/UpdateItem',
            data: requestData,
            validationParams: ['id', 'isMobileSupported', 'itemSource', 'itemContext', 'contextLanguage', 'contextURL', 'title', 'isPublished', 'doNotImport']
        });
    };

    /*------------------------------------------------------------------------------*/
    const updateItemDimensions = (requestData) => {
        return processRequest({
            type: 'post',
            URL: settings.apiUrl + 'Content/UpdateItemDimensions',
            data: requestData,
            validationParams: ['itemId', 'dimensions']
        });
    };

    /*------------------------------------------------------------------------------*/
    const updateItemAndDimensions = (contentItem, thumbnail) => {
        var formData = new FormData();
        formData.append('contentItem', JSON.stringify(contentItem));
        if (thumbnail) {
            formData.append('thumbnail', thumbnail);
        }

        return processRequest({
            type: 'post',
            URL: settings.apiUrl + 'Content/UpdateItemAndDimensions',
            data: formData
        });
    };

    /*------------------------------------------------------------------------------*/
    const createItem = (requestData) => {
        return processRequest({
            type: 'post',
            URL: settings.apiUrl + 'Content/CreateItem',
            data: requestData,
            validationParams: ['id', 'isMobileSupported', 'itemSource', 'itemContext', 'contextLanguage', 'contextURL', 'title', 'isPublished', 'doNotImport']
        });
    };
    /*------------------------------------------------------------------------------*/
    const GetItemByExternalId = (requestData) => {
        return processRequest({
            type: 'post',
            URL: settings.apiUrl + 'Content/GetItemByExternalId',
            data: requestData,
            validationParams: ['ExternalContextId', 'ContextLanguage']
        });
    };

    /*------------------------------------------------------------------------------*/
    const createItemDimensions = (requestData) => {
        return processRequest({
            type: 'post',
            URL: settings.apiUrl + 'Content/CreateItemDimensions',
            data: requestData,
            validationParams: ['itemId', 'dimensions']
        });
    };

    /*------------------------------------------------------------------------------*/
    const createItemAndDimensions = (requestData) => {
        return processRequest({
            type: 'post',
            URL: settings.apiUrl + 'Content/createItemAndDimensions',
            data: requestData,
            validationParams: ['content', 'content.id', 'content.isMobileSupported', 'content.itemSource', 'content.itemContext', 'content.contextLanguage', 'content.contextURL', 'content.title', 'content.doNotSearch', 'content.doNotImport', 'dimensions']
        });
    };

    /*------------------------------------------------------------------------------*/
    const deleteItem = (requestData) => {
        return processRequest({
            type: 'post',
            URL: settings.apiUrl + 'Content/DeleteItem',
            data: requestData,
            validationParams: ['itemId']
        });
    };

    /*------------------------------------------------------------------------------*/
    const addDimensionValues = (requestData) => {
        return processRequest({
            type: 'post',
            URL: settings.apiUrl + 'Content/AddDimensionValues',
            data: requestData,
            validationParams: ['dimensionName', 'values']
        });
    };

    /*------------------------------------------------------------------------------*/

    /*------------------------------------------------------------------------------*/
    const updateDimensionValues = (requestData) => {
        return processRequest({
            type: 'post',
            URL: settings.apiUrl + 'Content/UpdateDimensionValues',
            data: requestData,
            validationParams: ['dimensionName', 'values']
        });
    };

    /*------------------------------------------------------------------------------*/
    const getDependentDimension = (requestData) => {
        return processRequest({
            type: 'post',
            URL: settings.apiUrl + 'Content/GetDependentDimension',
            data: requestData,
            validationParams: ['targetDimension', 'sourceDimensions']
        });
    };

    /*------------------------------------------------------------------------------*/
    const getDependeeDimensions = (requestData) => {
        return processRequest({
            type: 'post',
            URL: settings.apiUrl + 'Content/GetDependeeDimensions',
            data: requestData,
            validationParams: ['lang', 'sourceDimensionName', 'sourceDimensionIds']
        });
    };

    const getAllDependencies = (requestData = {}) => {
        return processRequest({
            type: 'post',
            URL: settings.apiUrl + 'Content/GetAllDependencies',
            data: requestData,
            validationParams: []
        });
    };

    /*------------------------------------------------------------------------------*/
    const getNewestItemsIds = (requestData) => {
        return processRequest({
            type: 'post',
            URL: settings.apiUrl + 'Content/GetNewestItemsIds',
            data: requestData,
            validationParams: ['numResults']
        });
    };
    /*------------------------------------------------------------------------------*/
    /*------------------------------------------------------------------------------*/
    const getItemParentsById = (requestData) => {
        return processRequest({
            type: 'post',
            URL: settings.apiUrl + 'Content/GetItemParentsById',
            data: requestData,
            validationParams: ['itemId']
        });
    };
    /*------------------------------------------------------------------------------*/
    /*------------------------------------------------------------------------------*/
    const getRelatedItemActivitiesByIds = (requestData) => {
        return processRequest({
            type: 'post',
            URL: settings.apiUrl + 'Content/getRelatedItemActivitiesByIds',
            data: requestData,
            validationParams: ['ids']
        });
    };
    /*------------------------------------------------------------------------------*/

    const getRealtedNanoCoursesByAgeGrades = (requestData) => {
        return processRequest({
            type: 'post',
            URL: settings.apiUrl + 'Content/getRealtedNanoCoursesByAgeGrades',
            data: requestData,
            validationParams: ['ageGrades']
        });
    };

    /*------------------------------------------------------------------------------*/

    const getDimensionsByProfile = (requestData) => {
        return processRequest({
            type: 'post',
            URL: settings.apiUrl + 'Content/getDimensionsByProfile',
            data: requestData,
            validationParams: ['ageGrade', 'discipline','itemTypes','sectors']
        });
    };

    /*------------------------------------------------------------------------------*/
    const getDisciplinesByAgeGrades = (requestData) => {
        return processRequest({
            type: 'post',
            URL: settings.apiUrl + 'Content/getDisciplinesByAgeGrades',
            data: requestData,
            validationParams: []
        });
    };
    /*------------------------------------------------------------------------------*/
    const getSectorsByDisciplines = (requestData) => {
        return processRequest({
            type: 'post',
            URL: settings.apiUrl + 'Content/getSectorsByDisciplines',
            data: requestData,
            validationParams: []
        });
    };


    /*------------------------------------------------------------------------------*/

    //#endregion

    //#region SEARCH

    /*------------------------------------------------------------------------------*/
    const search = (requestData) => {
        return processRequest({
            type: 'post',
            URL: settings.apiUrl + 'Search/Search',
            data: requestData,
            validationParams: ["lang", "retrieveParams"]
        });
    };
    
    const filter = (requestData) => {
        return processRequest({
            type: 'post',
            URL: settings.apiUrl + 'Search/Filter',
            data: requestData,
            validationParams: ["lang", "retrieveParams"]
        });
    };

    const parallelSearch = (requestData) => {
        return processRequest({
            type: 'post',
            URL: settings.apiUrl + 'Search/ParallelSearch',
            data: requestData
        });
    };

    const parallelSearchFast = (requestData) => {
        return processRequest({
            type: 'post',
            URL: settings.apiUrl + 'Search/ParallelSearchFast',
            data: requestData
        });
    };

    /*------------------------------------------------------------------------------*/
    const autocomplete = (requestData) => {
        return processRequest({
            type: 'post',
            URL: settings.apiUrl + 'Search/Autocomplete',
            data: requestData,
            validationParams: ["searchString", "totalMaxResults", "retrieveParams"]
        });
    };
    /*------------------------------------------------------------------------------*/
    const searchItemsForUpcomingEvents = (requestData) => {
        return processRequest({
            type: 'post',
            URL: settings.apiUrl + 'Search/SearchItemsForUpcomingEvents',
            data: requestData,
            validationParams: ["lang", "clientTime", "daysWindow", "dimensionParams", "contentParams", "textParams", "retrieveParams"]
        });
    };
    /*------------------------------------------------------------------------------*/
    //#endregion

    //#region thumbnails
    const upload = (file, id) => {
        var formData = new FormData();
        formData.append('id', '');
        formData.append('thumbnail', file);

        return processRequest({
            type: 'post',
            URL: settings.apiUrl + 'Thumbnails/Upload',
            data: formData
        });
    };

    const getUrl = (requestData) => {
        return processRequest({
            type: 'get',
            URL: settings.apiUrl + 'Thumbnails/GetUrl',
            data: requestData,
            validationParams: ["id"]
        });
    };



    const getImageUrl = (requestData) => {

        var url = baseURI + settings.apiUrl + 'Thumbnails/GetImage';
        var params = [];
        if (requestData.id) {
            params.push('id=' + requestData.id);
        }
        if (requestData.width) {
            params.push('width=' + requestData.width);
        }
        if (requestData.height) {
            params.push('height=' + requestData.height);
        }
        if (params.length > 0) {
            url = url + '?' + params.join('&');
        }
        return url;







        //return processRequest({
        //    type: 'get',
        //    URL: settings.apiUrl + 'Thumbnails/GetImage',
        //    data: requestData,
        //    validationParams: ["id"]
        //});
    };



    /*------------------------------------------------------------------------------*/
    //region Import

    const importItem = (requestData) => {
        return processRequest({
            type: 'post',
            URL: settings.apiUrl + 'Import/ImportItem',
            data: requestData,
            validationParams: ["url", "userName"]
        });
    };








    //end region
    /*------------------------------------------------------------------------------*/
    //#endregion

    return {
        'content': {
            getAllDimensions: getAllDimensions,
            CopyHeContentItemToAr: CopyHeContentItemToAr,
            refreshDimensionsCache: refreshDimensionsCache,
            getAllDimensionsByLanguage: getAllDimensionsByLanguage,
            getAllDependencies: getAllDependencies,
            getAllDimensionsAndDependencies: getAllDimensionsAndDependencies,
            getItemById: getItemById,
            GetItemByExternalId: GetItemByExternalId,
            getItemDimensions: getItemDimensions,
            getItemAndDimensionsById: getItemAndDimensionsById,
            updateItem: updateItem,
            updateItemDimensions: updateItemDimensions,
            updateItemAndDimensions: updateItemAndDimensions,
            createItem: createItem,
            createItemDimensions: createItemDimensions,
            createItemAndDimensions: createItemAndDimensions,
            deleteItem: deleteItem,
            addDimensionValues: addDimensionValues,
            updateDimensionValues: updateDimensionValues,
            getDimension: getDimension,
            getDependentDimension: getDependentDimension,
            getDependeeDimensions: getDependeeDimensions,
            getNewestItemsIds: getNewestItemsIds,
            getItemParentsById: getItemParentsById,
            getRelatedItemActivitiesByIds: getRelatedItemActivitiesByIds,
            getDisciplinesByAgeGrades: getDisciplinesByAgeGrades,
            getSectorsByDisciplines: getSectorsByDisciplines,
            getRealtedNanoCoursesByAgeGrades: getRealtedNanoCoursesByAgeGrades,
            getDimensionsByProfile: getDimensionsByProfile,
            getItemAndDimensionsByIdFast: getItemAndDimensionsByIdFast,
            parallelSearchFast: parallelSearchFast,
           
        },
        'search': {
            search: search,
            filter: filter,
            parallelSearch: parallelSearch,
            parallelSearchFast: parallelSearchFast,
            autocomplete: autocomplete,
            searchItemsForUpcomingEvents: searchItemsForUpcomingEvents
        },
        'thumbnails': {
            upload: upload,
            getUrl: getUrl,
            getImageUrl: getImageUrl
        },
        'import': {
            importItem: importItem
        },
        'mybag': {
            isBookAllowedToUser: isBookAllowedToUser,
            getAuthorizationInfo: getAuthorizationInfo
        }
    };
})();

/*

test: function () {
        var accept = ".jpeg, .jpg, .png";
        var suportedTypes = ["image/jpeg", "image/jpg", "image/png"];
        var maxSize = 100 * 1024 * 1024; //100MB

        var inputFile = document.createElement("input");
        inputFile.type = "file";
        inputFile.accept = accept;
        inputFile.onchange = function (e) {
            var formData = new FormData();
            formData.append('id', '');
            //formData.append('contentItem', {id: 'ddddddddddddddddddd'});


            var file = e.target.files && e.target.files.length > 0 ? e.target.files[0] : false;
            if (file) {
                formData.append('thumbnail', file);
            }

            fetch('/api/Thumbnails/Upload', {
                method: 'POST',
                headers: {
                    // 'Content-Type': 'application/x-www-form-urlencoded',
                    //'Content-Type': 'application/json',
                },
                body: formData
            });

            //processRequest({
            //    type: 'post',
            //    URL: settings.apiUrl + 'Thumbnails/Upload',
            //    data: formData,
            //});
        };
        inputFile.click();
    }

*/