(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.teachersapi = (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: "/teachersapi/"
  };

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

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

    return promise;
  };

  //#region TeacherProfile

  const getProfileById = (requestData) => {
    return processRequest({
      type: 'post',
      URL: settings.apiUrl + 'Profile/GetProfileById',
      data: requestData,
      validationParams: ['profileId']
    });
  };
  const getSchoolByExternalId = (requestData) => {
    return processRequest({
      type: 'post',
      URL: settings.apiUrl + 'Profile/GetSchoolByExternalId',
      data: requestData,
      validationParams: ['profileId']
    });
  };
  const getTeacherSchools = (requestData) => {
    return processRequest({
      type: 'post',
      URL: settings.apiUrl + 'Profile/GetTeacherSchools',
      data: requestData,
      validationParams: ['profileId']
    });
  };
  const getTeacherAgeGrades = (requestData) => {
    return processRequest({
      type: 'post',
      URL: settings.apiUrl + 'Profile/GetTeacherAgeGrades',
      data: requestData,
      validationParams: ['teacherProfileId', 'schoolProfileId']
    });
  };
  const getTeacherDisciplines = (requestData) => {
    return processRequest({
      type: 'post',
      URL: settings.apiUrl + 'Profile/GetTeacherDisciplines',
      data: requestData,
      validationParams: ['teacherProfileId', 'schoolProfileId', 'ageGradeId']
    });
  };
  const getTeacherData = (requestData) => {
    return processRequest({
      type: 'post',
      URL: settings.apiUrl + 'Profile/GetTeacherData',
      data: requestData,
      validationParams: ['profileId']
    });
  };
  const updateProfile = (requestData) => {
    return processRequest({
      type: 'post',
      URL: settings.apiUrl + 'Profile/UpdateProfile',
      data: requestData,
      validationParams: ['userId']
    });
  };
  const updateSchool = (requestData) => {
    return processRequest({
      type: 'post',
      URL: settings.apiUrl + 'Profile/UpdateSchool',
      data: requestData,
      validationParams: ['schoolId']
    });
  };
  const addTeacherSchool = (requestData) => {
    return processRequest({
      type: 'post',
      URL: settings.apiUrl + 'Profile/AddTeacherSchool',
      data: requestData,
      validationParams: ['teacherProfileId', 'schoolProfileId']
    });
  };
  const removeTeacherSchool = (requestData) => {
    return processRequest({
      type: 'post',
      URL: settings.apiUrl + 'Profile/RemoveTeacherSchool',
      data: requestData,
      validationParams: ['teacherProfileId', 'schoolProfileId']
    });
  };
  const addTeacherAgeGrade = (requestData) => {
    return processRequest({
      type: 'post',
      URL: settings.apiUrl + 'Profile/AddTeacherAgeGrade',
      data: requestData,
      validationParams: ['teacherProfileId', 'schoolProfileId']
    });
  };
  const updateTeacherAgeGrade = (requestData) => {
    return processRequest({
      type: 'post',
      URL: settings.apiUrl + 'Profile/UpdateTeacherAgeGrade',
      data: requestData,
      validationParams: ['teacherProfileId', 'schoolProfileId']
    });
  };
  const deleteTeacherAgeGrade = (requestData) => {
    return processRequest({
      type: 'post',
      URL: settings.apiUrl + 'Profile/DeleteTeacherAgeGrade',
      data: requestData,
      validationParams: ['teacherProfileId', 'schoolProfileId', 'ageGradeId']
    });
  };
  const addTeacherDisciplines = (requestData) => {
    return processRequest({
      type: 'post',
      URL: settings.apiUrl + 'Profile/AddTeacherDisciplines',
      data: requestData,
      validationParams: ['teacherProfileId', 'schoolProfileId', 'ageGradeId']
    });
  };
  const deleteTeacherDisciplines = (requestData) => {
    return processRequest({
      type: 'post',
      URL: settings.apiUrl + 'Profile/DeleteTeacherDisciplines',
      data: requestData,
      validationParams: ['teacherProfileId', 'schoolProfileId', 'ageGradeId']
    });
  };
  const setUILanguage = (requestData) => {
    return processRequest({
      type: 'post',
      URL: settings.apiUrl + 'Profile/SetUILanguage',
      data: requestData,
      validationParams: ['userId', 'lastUILanguage']
    });
  };
  const setCurrentSchool = (requestData) => {
    return processRequest({
      type: 'post',
      URL: settings.apiUrl + 'Profile/SetCurrentSchool',
      data: requestData,
      validationParams: ['userId', 'lastSchoolId']
    });
  };
  
  const updateIsExtendedCatalog = (requestData) => {
      return processRequest({
          type: 'post',
          URL: settings.apiUrl + 'Profile/UpdateIsExtendedCatalog',
          data: requestData,
          validationParams: ['userId', 'isExtendedCatalog']
      });
    };


    const isTeacherHasOfekFlag = (requestData) => {
      return processRequest({
          type: 'post',
          URL: settings.apiUrl + 'Profile/IsTeacherHasOfekFlag',
          data: requestData,
          validationParams: ['profileId']
      });
  };

  const setTeacherGradesAndDisciplines = (requestData) => {
    return processRequest({
      type: 'post',
      URL: settings.apiUrl + `Profile/SetTeacherGradesAndDisciplines`,
      data: requestData,
      validationParams: ['userId', 'schoolId', 'ageGrades']
    });

  };

  //#endregion

  //#region ChatTokens

  const getUserChatTokens = (requestData) => {
    return processRequest({
      type: 'post',
      URL: settings.apiUrl + 'ChatTokens/GetUserChatTokens',
      data: requestData,
      validationParams: ['userId']
    });
  };
  
  //#endregion
  
  //#region Favorites

  const getFavorites = (requestData) => {
    return processRequest({
      type: 'post',
      URL: settings.apiUrl + 'Favorites/GetFavorites',
      data: requestData,
      validationParams: ['teacherId']
    });
  };
  const setCategory = (requestData) => {
    return processRequest({
      type: 'post',
      URL: settings.apiUrl + 'Favorites/SetCategory',
      data: requestData,
      validationParams: ['teacherId', 'name']
    });
  };
  const addFavorite = (requestData) => {
    return processRequest({
      type: 'post',
      URL: settings.apiUrl + 'Favorites/AddFavorite',
      data: requestData,
      validationParams: ['teacherId', 'categoryId', 'contentCatalogId']
    });
  };
  const assigningFavoriteToCategories = (requestData) => {
    return processRequest({
      type: 'post',
      URL: settings.apiUrl + 'Favorites/AssigningFavoriteToCategories',
      data: requestData,
      validationParams: ['teacherId', 'contentCatalogId']
    });
  };
  const deleteCategory = (requestData) => {
    return processRequest({
      type: 'post',
      URL: settings.apiUrl + 'Favorites/DeleteCategory',
      data: requestData,
      validationParams: ['teacherId', 'categoryId']
    });
  };
  const deleteFavorite = (requestData) => {
    return processRequest({
      type: 'post',
      URL: settings.apiUrl + 'Favorites/DeleteFavorite',
      data: requestData,
      validationParams: ['teacherId', 'favoriteId']
    });
  };
  const deleteFavoriteByContentCatalogId = (requestData) => {
    return processRequest({
      type: 'post',
      URL: settings.apiUrl + 'Favorites/DeleteFavoriteByContentCatalogId',
      data: requestData,
      validationParams: ['teacherId', 'contentCatalogId']
    });
  };
  const deleteAllFavoritesByTeacherId = (requestData) => {
    return processRequest({
      type: 'post',
      URL: settings.apiUrl + 'Favorites/DeleteAllFavoritesByTeacherId',
      data: requestData,
      validationParams: ['teacherId']
    });
  };

  //#endregion

  //#region LMSActivity

  const getActivityByExernalId = (requestData) => {
    return processRequest({
      type: 'post',
      URL: settings.apiUrl + 'LMSActivity/GetActivityByExernalId',
      data: requestData,
      validationParams: ['teacherId', 'externalId']
    });
  };
  const getActivitiesByType = (requestData) => {
    return processRequest({
      type: 'post',
      URL: settings.apiUrl + 'LMSActivity/GetActivitiesByType',
      data: requestData,
      validationParams: ['teacherId', 'activityType']
    });
  };
  const getActivitiesByTeacherId = (requestData) => {
    return processRequest({
      type: 'post',
      URL: settings.apiUrl + 'LMSActivity/GetActivitiesByTeacherId',
      data: requestData,
      validationParams: ['profileId']
    });
  };
  const hideActivityFromView = (requestData) => {
    return processRequest({
      type: 'post',
      URL: settings.apiUrl + 'LMSActivity/HideActivityFromView',
      data: requestData,
      validationParams: ['teacherId', 'externalId']
    });
  };
  const getEnvironmentsByCourseId = (requestData) => {
    return processRequest({
      type: 'post',
      URL: settings.apiUrl + 'LMSActivity/GetEnvironmentsByCourseId',
      data: requestData,
      validationParams: ['teacherId', 'courseId']
    });
  };
  const updateTeacherActivity = (requestData) => {
    return processRequest({
      type: 'post',
      URL: settings.apiUrl + 'LMSActivity/UpdateTeacherActivity',
      data: requestData,
      validationParams: ['teacherId', 'externalId', 'activityType', 'name', 'additionalInfo']
    });
  };
  //#endregion

  //region Mybag

  const getTaskData = (requestData) => {
    return processRequest({
      type: 'post',
      URL: settings.apiUrl + 'Mybag/GetTaskData',
      data: requestData,
      validationParams: ['cultureName', 'cetLanguage', 'siteKey', 'userID', 'schoolID']
    });
  };

  const saveTask = (requestData) => {
    var _requestData = { ...requestData };
    if (_requestData.task) {
      _requestData.task = JSON.stringify(_requestData.task);
    }

    return processRequest({
      type: 'post',
      URL: settings.apiUrl + 'Mybag/SaveTask',
      data: _requestData,
      validationParams: ['userID', 'task']
    });
  };

  const getProductSubscriptions = (requestData) => {
      var _requestData = { ...requestData };
      if (_requestData.task) {
          _requestData.task = JSON.stringify(_requestData.task);
      }

      return processRequest({
          type: 'post',
          URL: settings.apiUrl + 'Mybag/GetProductSubscriptions',
          data: _requestData,
          validationParams: ['teacherId']
      });
  };

  //#endregion

  //region Last/Popular Searches

  const getLastSearches = (requestData) => {
    return processRequest({
      type: 'post',
      URL: settings.apiUrl + 'Searches/GetLastSearches',
      data: requestData,
      validationParams: ['teacherId', 'numResults']
    });
  };

  const getPopularSearches = (requestData) => {
    return processRequest({
      type: 'post',
      URL: settings.apiUrl + 'Searches/GetPopularSearches',
      data: requestData,
      validationParams: ['teacherId', 'numResults']
    });
  };

  const addSearch = (requestData) => {
    return processRequest({
      type: 'post',
      URL: settings.apiUrl + 'Searches/AddSearch',
      data: requestData,
      validationParams: ['teacherId', 'searchString']
    });
    };

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

  };

  //endregion

  return {
    profile: {
      getProfileById: getProfileById,
      getSchoolByExternalId: getSchoolByExternalId,
      getTeacherSchools: getTeacherSchools,
      getTeacherAgeGrades: getTeacherAgeGrades,
      getTeacherDisciplines: getTeacherDisciplines,
      getTeacherData: getTeacherData,
      updateProfile: updateProfile,
      updateSchool: updateSchool,
      addTeacherSchool: addTeacherSchool,
      removeTeacherSchool: removeTeacherSchool,
      addTeacherAgeGrade: addTeacherAgeGrade,
      updateTeacherAgeGrade: updateTeacherAgeGrade,
      deleteTeacherAgeGrade: deleteTeacherAgeGrade,
      addTeacherDisciplines: addTeacherDisciplines,
      deleteTeacherDisciplines: deleteTeacherDisciplines,
      setUILanguage: setUILanguage,
      setCurrentSchool: setCurrentSchool,
      setTeacherGradesAndDisciplines: setTeacherGradesAndDisciplines,
      getUserChatTokens: getUserChatTokens,
      updateIsExtendedCatalog: updateIsExtendedCatalog,
      isTeacherHasOfekFlag: isTeacherHasOfekFlag
    },
    favorites: {
      getFavorites: getFavorites,
      setCategory: setCategory,
      addFavorite: addFavorite,
      assigningFavoriteToCategories: assigningFavoriteToCategories,
      deleteCategory: deleteCategory,
      deleteFavorite: deleteFavorite,
      deleteFavoriteByContentCatalogId: deleteFavoriteByContentCatalogId,
      deleteAllFavoritesByTeacherId: deleteAllFavoritesByTeacherId
    },
    lmsActivity: {
      getActivityByExernalId: getActivityByExernalId,
      getActivitiesByType: getActivitiesByType,
      getActivitiesByTeacherId: getActivitiesByTeacherId,
      hideActivityFromView: hideActivityFromView,
      getEnvironmentsByCourseId: getEnvironmentsByCourseId,
      updateTeacherActivity: updateTeacherActivity
    },
    mybag: {
      getTaskData: getTaskData,
      saveTask: saveTask,
      getProductSubscriptions: getProductSubscriptions
    },
    searches: {
      getLastSearches: getLastSearches,
      getPopularSearches: getPopularSearches,
      addSearch: addSearch
      },
      import: {
          importCourseEnvironments: importCourseEnvironments
      }
  };
})();