(function () {
  "use strict";

  angular.module("agora.plus.dashboard.services", [])
  .service("DashboardService", [
    "$http",
    "$q",
    DashboardService
  ]);

  function DashboardService($http, $q) {
    var promise;
    var vm = this;
    var countriesCallingCodes = [];
    vm.getCountriesCallingCodes = getCountriesCallingCodes;
    vm.createAccount = createAccount;
    vm.baseUrl = PCK_GLOBAL_VARIABLES.webservice_path_API_DASHBOARD;

    return {
      /**
      * Get all streets given some parameters
      * @param  {string} zipCode      The zip code selected
      * @param  {integer} idStreetType The street type selected
      * @param  {string} querySearch  The search done by the user
      * @param  {string} cityName  The name of the city
      * @return {object}              A promise is returned
      */
     streetsSync: function (zipCode, idStreetType, querySearch, cityName) {
       if (typeof idStreetType === "undefined" || idStreetType !== parseInt(idStreetType, 10)) {
         throw new Error("Invalid parameter idStreetType: " + idStreetType + " id Street Type must be an integer");
       }

       return $http.get(PCK_GLOBAL_VARIABLES.webservice_path_API_DASHBOARD + "streets" + "/", {
         params: {
           zipCode: zipCode,
           idStreetType: idStreetType,
           querySearch: querySearch,
           city: cityName
         },
         paramOrder: ['zipCode', 'idStreetType', 'querySearch', 'city']
       })
       .then(function (response) {
         return response.data.DATA;
       }).catch(function () {
         console.log("Error occured fetching streets");
       });
     },

     /**
      * Fetch all the BTQs availble
      * @return {object} Returns the response of the request
      */
     btq: function() {
       return $http.get(PCK_GLOBAL_VARIABLES.webservice_path_API_DASHBOARD + "BTQ")
       .then(function(response) {
         return response;
       })
       .catch(function() {
         console.log("Error occured");
       });
     },

     /**
      * Get all street tyes available
      * @return {object} Returns the response of the request
      */
     streetType: function() {
       return $http.get(PCK_GLOBAL_VARIABLES.webservice_path_API_DASHBOARD + "streetType")
       .then(function(response) {
         return response;
       }).catch(function() {
         console.log("Error occured");
       });
     },

     /**
      * Get all available zip codes
      * @return {[type]} [description]
      */
     zipCode: function() {
       return $http.get(PCK_GLOBAL_VARIABLES.webservice_path_API_DASHBOARD + "zipCode")
       .then(function(response) {
         return response;
       })
       .catch(function() {
         console.log("Error occured");
       });
     },

     /**
      * Get all available zip codes
      * @return {[type]} [description]
      */
     zipCodeAdr: function(search) {
       return $http.get(PCK_GLOBAL_VARIABLES.webservice_path_API_DASHBOARD + "zipCodeAdr", {
         params:{search:search}
       })
       .then(function(response) {
         return response;
       }).catch(function() {
         console.log("Error occured");
       });
     },

     /**
      * [getCountries Get all countries based on a query search and translated to a given language]
      * @param  {[string]} currentLanguage [The curent language being used (one of fr, en or pt)]
      * @param  {[string]} querySearch     [The search being made by the user]
      * @return {[object]}                 [A promise is returned]
      */
     getCountries: function(currentLanguage, querySearch) {
       return $http.get(PCK_GLOBAL_VARIABLES.webservice_path_API_DASHBOARD + "countries/", {
         params: {
           lang: currentLanguage,
           querySearch: querySearch
         },
         paramOrder: ["lang", "querySearch"]
       })
       .then(function(response){
         return response.data.DATA;
       })
       .catch(function() {
         console.log("Error occured fetching countries");
       });
     },

     getCountriesCallingCodes: vm.getCountriesCallingCodes,

     getSchoolYears: function (schoolYear) {
       if (!schoolYear) {
         schoolYear = 5;
       }

       return $http.get(PCK_GLOBAL_VARIABLES.webservice_path_API_DASHBOARD + "schoolYear/" + schoolYear);
     },

     /**
      * getPerimetreArea Get the possible motives to chose other school
      * @param  {Integer} idStreet    street identifier
      * @param  {Integer} idBTQ       Btq identifier
      * @param  {Integer} num         Number in the address
      * @param  {Integer} schoolLevel School level
      * @return {Object}             A promise is returned
      */
     getPerimetreArea: function (idStreet,idBTQ, num, schoolLevel) {
       var promise = $http.get(PCK_GLOBAL_VARIABLES.webservice_path_API_DASHBOARD + "perimeters/?idStreet=" + idStreet + "&idBTQ=" + idBTQ + "&num=" + num + "&idLevel=" + schoolLevel + "")
       .then(function (response) {
         return response;
       })
       .catch(function () {
         console.log("error occured");
       });

       return promise;
     },

     /**
      * getSchoolLevels get available school levels
      * @param  {String} birthDate   date of birth
      * @param  {Integer} schoolLevel school level
      * @return {Object}             A promise is returned
      */
     getSchoolLevels: function (birthDate, schoolLevel) {
       if (!birthDate) {
         birthDate = "01/01/1700";
       }

       return $http.get(PCK_GLOBAL_VARIABLES.webservice_path_API_DASHBOARD + "schoolLevels/?birthDate=" + birthDate + '&idSchoolYear=' + schoolLevel);
     },

     /**
      * getSchools get list of available schools for a given address, or all of
      * them
      * @param  {Street} street Address street
      * @param  {Integer} btq    Address BTQ
      * @param  {Integer} num    Address number
      * @param  {Integer} level  School level
      * @return {Object}        A promise is returned
      */
     getSchools: function (street, btq, num, level) {
       if (!street) {
         street = -1;
       }

       if (!btq) {
         btq = -1;
       }

       if (!num) {
         num = -1;
       }

       if (!level) {
         level = -1;
       }

       return $http.get(PCK_GLOBAL_VARIABLES.webservice_path_API_DASHBOARD + "schools/?idStreet=" + street + "&idBTQ=" + btq + "&num=" + num + "&idLevel=" + level);
     },

     /**
      * getFiliation get filiation data
      * @return {Object} A promise is returned
      */
     getFiliation: function () {
       var defer = $q.defer();
       $http.get(PCK_GLOBAL_VARIABLES.webservice_path_API_DASHBOARD + "filiation/")
       .then(function (response) {
         defer.resolve(response);
       })
       .catch(function () {
         defer.reject("Error fetching filiation data");
       });

       return defer.promise;
     },

     /**
      * reloadMenu reload sidenav menus
      * @return {Object} A promise is returned
      */
     reloadMenu: function () {
       return $http.get(PCK_GLOBAL_VARIABLES.webservice_path_API_DASHBOARD + "reloadMenu")
       .then(function (response) {
         return response.data.DATA;
       })
       .catch(function () {
         console.log("Error reloading the menus");
       });
     },

     /**
      * createAccount Create account
      */
     createAccount: vm.createAccount,

     /**
      * sendEmail Send email with the data provided, if, at least an email
      * and a body are provided
      * @param  {String} from      Email fom property
      * @param  {Array} to         Array of emails
      * @param  {String} subject   Email subject
      * @param  {String} body      Email body
      * @return {Object}           Promise
      */
     sendEmail: function(from, to, subject, body, id_log) {
       var defer = $q.defer(),
       responseResult,
       emailData = {
         "EMAIL_FROM": from,
         "EMAIL_SUBJECT": subject,
         "EMAIL_BODY": body,
         "EMAIL_TO": to,
         "ID_NOTIFICATION_LOG": id_log
       };

       if (!to || !body) {
         defer.reject("At least 'to' and 'body' are needed");
         return defer.promise;
       }

       $http.post(PCK_GLOBAL_VARIABLES.webservice_path_API_DASHBOARD + "email",
       emailData,
       {"headers": {"Content-Type": "application/json"}})
       .then(function (response) {
         responseResult = parseInt(response.data.TYPE_RESULT, 10);
         if (responseResult > 0) {
           defer.resolve(response.data);
         } else {
           defer.reject(response.data.ERROR.MESSAGE);
         }
       }).catch(function(error) {
         defer.reject(error);
       });

       return defer.promise;
     },

     /**
      * sendSMS If SMS_INFO property not null in submit response, send SMS
      * @param  {Integer} id_compte_notif      id of the compte notif
      * @param  {String} sms_text             text to send
      * @param  {Integer} id_log             Log identifier
      */
     sendSMS: function (id_compte_notif, sms_text, id_log) {
       var defer = $q.defer(),
       responseResult,
       smsData = {
         "SMS_ID_COMPTE_NOTIF": id_compte_notif,
         "SMS_TEXT": sms_text,
         "ID_NOTIFICATION_LOG": id_log
       };

       $http.post(PCK_GLOBAL_VARIABLES.webservice_path_API_DASHBOARD + "sms", smsData)
       .then(function (response) {
         responseResult = parseInt(response.data.TYPE_RESULT, 10);

         if (responseResult > 0) {
           defer.resolve(response.data);
         } else {
           defer.reject(response.data.ERROR.MESSAGE);
         }
       }).catch(function (error) {
         defer.reject(error);
       });

       return defer.promise;
     },

     /**
      * validateLoginContext Validate the context of a logged in user
      * @return {Object} Returns a $http promise
      */
     validateLoginContext: function() {
       var defer = $q.defer(),
       responseResult;

       if (sessionHandler.sessionStorage.get("SESSION_ID")) {
          $http.get(PCK_GLOBAL_VARIABLES.webservice_path_API_DASHBOARD + "validateContext")
          .then(function(response) {
            responseResult = parseInt(response.data.TYPE_RESULT, 10);
  
            if (responseResult > 0) {
              defer.resolve(response.data);
            } else {
              defer.reject(response.data.ERROR.MESSAGE);
            }
          })
          .catch(function(error) {
            defer.reject(error);
          });
       } else {
         defer.resolve(null);
       }

       return defer.promise;
     },

     /**
      * getRefYearDates Get list of ref year dates
      * @return {Object} A promise is returned
      */
     getRefYearDates: function () {
       var defer = $q.defer(),
       responseResult;

       $http.get(PCK_GLOBAL_VARIABLES.webservice_path_API_DASHBOARD + "getRefYearDates/?refYear=" + sessionHandler.sessionStorage.get("REF_YEAR"))
       .then(function (response) {
         responseResult = parseInt(response.data.TYPE_RESULT, 10);

         if (responseResult > 0) {
           defer.resolve(response);
         } else {
           defer.reject(response.data.ERROR.MESSAGE);
         }
       })
       .catch(function (error) {
         defer.reject(error);
       });

       return defer.promise;
     },

     /**
 * getRefYearDates Get list of ref year dates
 * @return {Object} A promise is returned
 */
     getIHMConfigJSON: function (idIHM) {
         var defer = $q.defer(),
             responseResult;

         $http.get(PCK_GLOBAL_VARIABLES.webservice_path_API_BACKOFFICE_CONFIG + "getIHMConfigJSON/?idIHM=" + idIHM)
             .then(function (response) {
                 responseResult = parseInt(response.data.TYPE_RESULT, 10);

                 if (responseResult > 0) {
                     defer.resolve(response);
                 } else {
                     defer.reject(response.data.ERROR.MESSAGE);
                 }
             })
             .catch(function (error) {
                 defer.reject(error);
             });

         return defer.promise;
     },

     /**
      * getKidsAuthorizationList obtain kids authorization list
      * @return {Object} A promise is returned
      */
     getKidsAuthorizationList: function () {
       var defer = $q.defer(),
       responseResult;

       $http.get(PCK_GLOBAL_VARIABLES.webservice_path_API_DASHBOARD + "getAuthorizationList")
       .then(function (response) {
         responseResult = parseInt(response.data.TYPE_RESULT, 10);

         if (responseResult > 0) {
           defer.resolve(response);
         } else {
           defer.reject(response.data.ERROR.MESSAGE);
         }
       })
       .catch(function (error) {
         defer.reject(error);
       });

       return defer.promise;
     },

     /**
      * getListOfAvailableLanguages Get a list of available languages
      * @return {Object} A promise is returned
      */
     getListOfAvailableLanguages: function() {
       var defer = $q.defer();

       $http.get(vm.baseUrl+"getLanguagesList",{
         params: {
           isActive: 1,
           isActiveCLient: 1
         }
       })
       .then(function (response) {
         if (parseInt(response.data.TYPE_RESULT, 10) === 1) {
           defer.resolve(response.data.DATA);
         } else {
           defer.reject(response.data.ERROR.MESSAGE);
         }
       })
       .catch(function (error) {
         defer.reject(error);
       });

       return defer.promise;
     },

     getIdUser: function() {
      let defer = $q.defer();
      $http.get(PCK_GLOBAL_VARIABLES.webservice_path_API_DASHBOARD + "UserId")
        .then(function (data) {
          if (data.data.TYPE_RESULT === 1) {
            defer.resolve(data.data.DATA);
          } else {
            defer.reject(data.data.ERROR.MESSAGE);
          }
        })
        .catch(function (error) {
          defer.reject(error);
        });
      return  defer.promise;
    }
   };

   /**
    * getCountriesCallingCodes get countries calling codes by lang
    * @return {Object} A promise is returned
    */
   function getCountriesCallingCodes() {
     var defer = $q.defer(),
     countries = [],
     currentLang = [sessionHandler.sessionStorage.get("currentLang"), "-", sessionHandler.sessionStorage.get("currentLang").toUpperCase()].join(""),
     savedData = sessionHandler.localStorage.get(currentLang);

     if (typeof(savedData) !== "undefined" && savedData !== null) {
       defer.resolve((typeof(savedData) === "string") ? JSON.parse(savedData)  : savedData);
     } else {
       if (countriesCallingCodes.length) {
         defer.resolve(countriesCallingCodes);
       } else {
         var responseResult,
         response = {};

         $http.get(PCK_GLOBAL_VARIABLES.webservice_path_API_DASHBOARD + "countriesAndPhone/?lang="+currentLang)
         .then(function (res) {
           responseResult = parseInt(res.data.TYPE_RESULT, 10);
           if (responseResult > 0) {
             for (var i = 0; i < res.data.DATA.COUNTRIES.length; i++) {
               if (!res.data.DATA.COUNTRIES[i].CALLING_CODE) {
                 continue;
               }

               if (res.data.DATA.COUNTRIES[i].COUNTRY_CODE == sessionHandler.sessionStorage.get("currentLang").toUpperCase()) {
                 countries.unshift({
                   alpha:       res.data.DATA.COUNTRIES[i].COUNTRY_CODE.toLowerCase(),
                   callingCode: res.data.DATA.COUNTRIES[i].CALLING_CODE.toString(),
                   name:        res.data.DATA.COUNTRIES[i].COUNTRY_NAME,
                   id:          res.data.DATA.COUNTRIES[i].ID_COUNTRIES,
                 });
               } else {
                 countries.push({
                   alpha:       res.data.DATA.COUNTRIES[i].COUNTRY_CODE.toLowerCase(),
                   callingCode: res.data.DATA.COUNTRIES[i].CALLING_CODE.toString(),
                   name:        res.data.DATA.COUNTRIES[i].COUNTRY_NAME,
                   id:          res.data.DATA.COUNTRIES[i].ID_COUNTRIES,
                 });
               }
             }
           } else {
             response = res;
           }
         }).finally(function () {
           if (responseResult > 0) {
             countriesCallingCodes = countries;
             sessionHandler.localStorage.set(currentLang, countriesCallingCodes);

             defer.resolve(countriesCallingCodes);
           } else {
             defer.reject(response.data.ERROR.MESSAGE);
           }
         });
       }
     }

     return defer.promise;
   }

   /**
    * createAccount create account request
    * @param  {Object} payload Necessary data to create an account
    * @return {Object}         A promise is returned
    */
   function createAccount(payload) {
     var defer = $q.defer();

     $http.post(vm.baseUrl+"account", payload,
     {"headers": {"Content-Type": "application/json"}})
     .then(function (data) {
       if (data.data.TYPE_RESULT == "1") {
         defer.resolve(data);
       } else {
         defer.reject(data.data.ERROR.MESSAGE);
       }
     })
     .catch(function (error) {
       defer.reject(error);
     });

     return defer.promise;
   }
 }
}).call();