(function () {
    'use strict';

    angular
        .module('app')
        .controller('CareProviderProfileEditController', profileEditCareProvider);

    function profileEditCareProvider($scope, userRepository, careProviderRepository,apiMediaUploaderRepository, $state, $q, $filter, 
        convertHelper, errorHandler, uiNotifications, careProviders, stripeAccountStatus, verificationDocumentType, stripeAccountStatusDescription, 
        $translate, FileUploader, localizationHelper) {
        /* jshint validthis:true */
        var vm = this;

        vm.translationObject = {};
        vm.tempFormData = {data: null, isImageSelected: false};
        vm.stgLanguages = null;
        vm.stgSecretQuestion1 = -1;
        vm.stgSecretQuestion2 = -1;
        vm.stgCountryId = null;
        vm.loadTranslation = function () {
            $translate(['Info', 'Success', 'Error', 'CareProviderLocked', 'CareProviderUnlocked', 'CareProviderUpdated',
                'Basic', 'Conversant', 'Proficient', 'Fluent', 'Native']).then(function (tr) {
                    vm.translationObject = tr;
                });
        };

        vm.unsubscribe = localizationHelper.eventEmitter.subscribe('onLanguageChangedEvent', function (lang) {
            if (vm.profile.careProvider.languages) {
                vm.stgLanguages = vm.profile.careProvider.languages.map(function (l) {
                    return {
                        languageId: l.model.id,
                        languageLevel: l.model.languageLevelModel.id,
                        languageName: l.model.name
                    };
                });
            }
            if (vm.questionPair1) {
                vm.stgSecretQuestion1 = vm.questionPair1.id
            }
            if (vm.questionPair2) {
                vm.stgSecretQuestion2 = vm.questionPair2.id
            }
            if (vm.profile.careProvider.countryUI) {
                vm.stgCountryId = vm.profile.careProvider.countryUI.id;
            }

            vm.loadTranslation();
            getServicesCategories(true);
            getSecurityQuestions(true);
            getServicingAreas(true);
            getLanguages(true);
            getSpecialQualities(true);
            getCountries(true);
            getLanguagesLevels();
            vm.onChangeCitizenship();
            refreshCitizenshipSelectComponent();
            refreshDocTypeSelectComponent();
            refreshGenderSelectComponent();
        });
        vm.loadTranslation();

        // Variables.
        vm.defaultImage = "images/media-user.png";
        vm.defaultDocImage = "images/default-image.png";
        vm.defaultAvatar = "images/default-user.png";
        vm.countries = [];
        vm.languages = [];
        vm.citizenship = [
            {id:1, name:"ImAmerican"},
            {id:0, name:"ImNotAmerican"}
        ];
        vm.docTypes = [];
        vm.selectedDocType = null;
        vm.selectedCitizenship = null;
        vm.servicingAreas = [];
        vm.specialQualities = [];
        vm.languageProficiencyLevelsDisplay = [];
        vm.languageProficiencyLevels = careProviders.LANGUAGE_PROFICIENCY_LEVELS; //
        vm.response = null;
        vm.isLoaded = false;
        vm.selectedSpecialQualities = null;
        vm.selectedServicingAreas = null;
        vm.selectedServicesCategories = [];
        vm.stgSelectedServicesCategories = [];
        vm.yearExperienceMaxLength = 3;

        // Tabs Public/Private logic.
        vm.currentTab = null;

        vm.questions = [];
        vm.questionList1 = [];
        vm.questionList2 = [];
        vm.questionPair1 = {};
        vm.questionPair2 = {};
        vm.genders = [
            {
                id:1,
                value:'male',
                key:"Male"
            },
            {
                id:2,
                value:'female',
                key:'Female'
            }
        ];
        vm.selectedGender = null;
        vm.profile = {
            "careProvider": {
                "firstName": "",
                "lastName": "",
                "firstNamePrivate": "",
                "lastNamePrivate": "",
                "phoneNumber": "",
                "email": "",
                "imageUrl": null,
                "imageThumbnailUrl": null,
                "birthDate": "",
                "city": "",
                "countryId": null,
                "yearsOfExperience": null,
                "individualIdNumber": null,
                "languages": [],
                "password": "",
                "confirmPassword": "",
                "summary": "",
                "countryUI": null,
                "addressLine1": "",
                "addressLine2": "",
                "state": "",
                "gender":"",
                "postalCode": "",
                "stripeAccountStatus": 0,
                "stripeDisableReason": null,
                "isResident": 0,
            },
            "careProviderLicenses": [],
            "verification": {
                "securityQuestion1": {
                    "id": 0,
                    "securityQuestionId": 1,
                    "answer": ""
                },
                "securityQuestion2": {
                    "id": 0,
                    "securityQuestionId": 2,
                    "answer": ""
                }
            },
            "bankAccounts": [],
            "specialQualities": [],
            "servicingAreas": [],
            "externalAccounts": [],
            "serviceCategories":[],
            "cardTokens": [],
            "identityDocuments": {
                "documentType":null,
                "document": {
                    "front": {
                        "id": null,
                        "imageUrl": null,
                        "name": null,
                        "createDate": null
                    },
                    "back": {
                        "id": null,
                        "imageUrl": null,
                        "name": null,
                        "createDate": null
                    }
                }
            },
            "languageProficiencyLevels": []
        };
        vm.currentProfileId = $state.params.id;
        window["Profile"] = this;

        // Bind jQuery datePicker to html-element.
        careProviderRepository.updateDate("#BirthDate", null, true, new Date());

        vm.triggerFileInputIdentificationMainFrontClick = function () {
            setTimeout(function () {
                $("#fileInputIdentification-main-front").trigger("click");
            }, 100);
        };

        vm.getAmericanDocumentTypes = function(){
            return [
              {id:verificationDocumentType.VERIFICATION_DOCUMENT_TYPE.PassportOrCard, name:"Passport_DT"},
              {id:verificationDocumentType.VERIFICATION_DOCUMENT_TYPE.DriversLicense, name:"DriversLicense_DT"}
            ]
          }
        
          vm.getNotAmericanDocumentTypes = function(){
            return [
              {id:verificationDocumentType.VERIFICATION_DOCUMENT_TYPE.PermitIdOrGreenCard, name:"ResidentCard_DT"},
                {id:verificationDocumentType.VERIFICATION_DOCUMENT_TYPE.UsVisa, name:"MyVisaCard_DT"}
            ]
          }

          vm.onChangeCitizenship = function(){
            if(vm.selectedCitizenship && vm.selectedCitizenship.id == 1){
                vm.docTypes = vm.getAmericanDocumentTypes();
            }else{
                if(!vm.selectedCitizenship){
                    vm.selectedCitizenship = vm.citizenship.find(function(val){return val.id == 0})
                }
                vm.docTypes = vm.getNotAmericanDocumentTypes();
            }
            refreshDocTypeSelectComponent();
        }
        vm.identificationUploaderMainFront = new FileUploader({ url: 'api/upload/' });

        vm.identificationUploaderMainFront.filters.push({
            name: 'imageFilter',
            fn: function (item, options) {
                var type = '|' + item.type.slice(item.type.lastIndexOf('/') + 1) + '|';
                return '|jpg|jpeg|png|gif|pdf|'.indexOf(type) !== -1;
            }
        });
        
        vm.getDocName = function(docModel, inputFileQueue){
            if(docModel){
                return docModel.name;                
            }else if(inputFileQueue && inputFileQueue.length>0){
                return inputFileQueue[0]._file.name;
            }else{
                return "";
            }
        }

        vm.uploadIdentificationFiles = function () {
            var idsFiles = [];
            idsFiles.push(vm.identificationUploaderMainFront.queue.length > 0 ? vm.identificationUploaderMainFront.queue[0]._file : null);
            return $q(function (resolve, reject) {
                $q.all(idsFiles.map(function (identificationFile) {
                    return $q(function (resolve, reject) {
                        if (identificationFile != null) {
                            var fd = new FormData();
                            var imgBlob = identificationFile;
                            fd.append('file', imgBlob, convertHelper.renderImageName(imgBlob.type));
                            apiMediaUploaderRepository.uploadCareProviderLicense(fd).then(function (response) {
                                if (response.success) {
                                    resolve(response.data.externalId);
                                }
                            });
                        } else {
                            resolve(null);
                        }
                    });
                })).then(function (externalIds) {
                    resolve(externalIds);
                });
            });
        };

        vm.isSelectedUSACountry = function(){
            if(vm.profile.careProvider.countryUI && vm.profile.careProvider.countryUI.code == 'US'){
                return true;
            }
            return false;
        }

        vm.getExternalIdsForIdentification = function () {
            return $q(function (resolve, reject) {
                    vm.uploadIdentificationFiles().then(function (externalIds) {
                        if(externalIds.length>0){
                            externalIds.map(function (exId, index) {
                                switch(index){
                                    case 0:
                                        if(exId != null && (!vm.profile.identityDocuments.document.front || !vm.profile.identityDocuments.document.front.imageUrl)){
                                            vm.profile.identityDocuments.document.front = {externalId: exId};
                                        }
                                        break;
                                }                            
                            });
                        }
                        resolve(vm.profile.identityDocuments);
                    });     
            });
        };

        //Methods.
        vm.updateCareProvider = function () {
            vm.getExternalIdsForIdentification().then(function (identities) {
                vm.profile.identityDocuments = identities;
                vm.profile.careProviderLicenses = vm.response?.careProviderLicenses || [];
                if(vm.profile.careProvider.countryUI.code == 'US'){
                    vm.profile.identityDocuments.documentType = vm.selectedDocType?.id;
                    vm.profile.careProvider.isResident = !!vm.selectedCitizenship.id;
                }else{
                    vm.profile.identityDocuments.documentType = verificationDocumentType.VERIFICATION_DOCUMENT_TYPE.Passport;
                    vm.profile.careProvider.city = null;
                    vm.profile.careProvider.state = null;
                    vm.profile.careProvider.addressLine1 = null;
                    vm.profile.careProvider.addressLine2 = null;
                    vm.profile.careProvider.postalCode = null;
                }
                vm.profile.careProvider.gender = vm.selectedGender.value;
                vm.profile.careProvider.countryId = vm.countries.find(function (c) { return c.id == vm.profile.careProvider.countryUI.id }).id;
                vm.profile.languages = vm.profile.careProvider.languages.map(function (l) { return { languageId: l.model.id, languageLevel: l.model.languageLevelModel.id }; });
                vm.profile.verification.securityQuestion1.securityQuestionId = vm.questionPair1.id;
                vm.profile.verification.securityQuestion2.securityQuestionId = vm.questionPair2.id;
                vm.profile.servicingAreas = vm.selectedServicingAreas.map(function (saMap) {
                    return {id: saMap.id};
                });
                vm.profile.serviceCategories = vm.selectedServicesCategories.map(function (scMap) {
                    return {id: scMap.id};
                });
                if(vm.selectedSpecialQualities && vm.selectedSpecialQualities.length){
                    vm.profile.specialQualities = vm.selectedSpecialQualities.map(function (sqMap) {
                        return {id: sqMap.id};
                    });
                }
                if(vm.tempFormData.data){
                    apiMediaUploaderRepository.uploadImageFormData(vm.tempFormData.data, true).then(function (response) {
                        if (response.success) {
                            vm.profile.careProvider.imageUrl = response.data[0].fileUrl;
                            vm.profile.careProvider.imageThumbnailUrl = response.data[0].fileThumbnailUrl;
                            vm.sendRequestToUpdate();
                        }
                    });
                }else{
                    vm.sendRequestToUpdate();
                }
            });
        };
        vm.sendRequestToUpdate = function () {
            careProviderRepository.updateById(vm.profile.careProvider.id, vm.profile).success(function (response, status, headers, config) {
                if (errorHandler.check(response, status, config) == errorHandler.STATUS.SUCCESS) {
                    uiNotifications.inform(vm.translationObject['CareProviderUpdated'], 'info');
                    $state.reload();
                } else {
                    uiNotifications.inform(response.message, 'error');
                }
            });
        }
        vm.getStripeStatusName = function (statusNumber) {
            return stripeAccountStatus.STRIPE_ACCOUNT_STATUS[statusNumber];
        }
        vm.getStripeStatusDescription = function(statusDescriptionNumber){
            if(statusDescriptionNumber != null && statusDescriptionNumber != undefined){
                return stripeAccountStatusDescription.STRIPE_ACCOUNT_STATUS_DESCRIPTION[statusDescriptionNumber];
            }
            return null;
        }
        vm.updateCareProviderImageLink = function (fileImage) {
            careProviderRepository.uploadImage(fileImage).success(function (response, status, headers, config) {
                if (errorHandler.check(response, status, config) == errorHandler.STATUS.SUCCESS) {
                    vm.profile.careProvider.imageThumbnailUrl = response.data.imageThumbnailUrl;
                }
            });
        };

        vm.questionBoxChanged = function (boxId) {
            if (boxId == 1 && vm.questionPair1) {
                vm.questionList2 = vm.questions.filter(function (q) { return q.id !== vm.questionPair1.id; });
            }
            if (boxId == 2 && vm.questionPair2) {
                vm.questionList1 = vm.questions.filter(function (q) { return q.id !== vm.questionPair2.id; });
            }
            refreshSecurityQuestionsSelectComponent();
        };

        vm.getDocumentImage = function (url) {
            if (url) {
                if (isUrlToImage(url)) {
                    return url;
                } else if(getExtensionByUrl(url) == ".pdf"){
                    return "images/pdf-document-icon.svg";
                }
            }
            return vm.defaultDocImage;
        }

        vm.openDocInNewTab = function(doc){
            if(doc && doc.imageUrl){
                var win = window.open(doc.imageUrl, '_blank');
                win.focus();
            }
        }

        function isUrlToImage(url) {
            if (url) {
                var ext = getExtensionByUrl(url);
                if (ext) {
                    var isImage = false;
                    ['.jpg','.jpeg', '.gif', '.png'].forEach(function(value){
                        if(value == ext){
                            isImage = true;
                        }
                    }.bind(this));
                    return isImage;
                }
            }
            return false;
        }

        function getExtensionByUrl(url){
            if (url) {
                var regArr = url.match(/\.[0-9a-z]+$/i);
                if (regArr.length > 0) {
                    return regArr[0].toLowerCase();
                }
            }
            return null;
        }

        function getSecurityQuestions(isUpdate) {
            userRepository.getSecurityQuestions().success(function (response, status, headers, config) {
                if (errorHandler.check(response, status, config) == errorHandler.STATUS.SUCCESS) {
                    vm.questions = response.data;
                    vm.questionList1 = vm.questions.filter(function (q) {
                        return q.id != vm.profile.verification.securityQuestion2.securityQuestionId;
                    });
                    vm.questionList2 = vm.questions.filter(function (q) {
                        return q.id != vm.profile.verification.securityQuestion1.securityQuestionId;
                    });
                    if (isUpdate) {
                        if (vm.stgSecretQuestion1 && vm.stgSecretQuestion1 != -1) {
                            vm.questionPair1 = vm.questionList1.find(function (q) {
                                return vm.stgSecretQuestion1 == q.id;
                            });
                        }
                        if (vm.stgSecretQuestion2 && vm.stgSecretQuestion2 != -1) {
                            vm.questionPair2 = vm.questionList2.find(function (q) {
                                return vm.stgSecretQuestion2 == q.id;
                            });
                        }
                    }
                    vm.isLoaded = true;
                }
                refreshSecurityQuestionsSelectComponent();
            });
        }

        vm.pushLanguage = function () {
            vm.profile.careProvider.languages.push({
                model: { id: null, name: null },
                list: (function () {
                    var tempList = vm.profile.careProvider.languages.map(function (lang) { return lang.model });
                    var result;
                    result = $.grep(vm.languages, function (n, i) {
                        return tempList.some(function (s) { return s.name == n.name });
                    }, true);
                    return result;
                })()
            });
            refreshLanguagesSelectComponent();

        };

        vm.removeLanguage = function (index) {
            vm.profile.careProvider.languages.splice(index, 1);
            refreshLanguagesSelectComponent();
        };

        vm.removeImage = function () {
            vm.profile.careProvider.imageThumbnailUrl = null;
        };

        vm.isPushLanguageDisabled = function () {
            if (vm.response && vm.profile.careProvider.languages.length && vm.profile.careProvider.languages[0].model) {
                return vm.profile.careProvider.languages[vm.profile.careProvider.languages.length - 1].model.name == undefined;
            }
            return true;
        };

        vm.manageCareProvider = function (action) {
            if (action == "block") {
                careProviderRepository.block(vm.profile.careProvider).success(function (response, status, headers, config) {
                    if (errorHandler.check(response, status, config) == errorHandler.STATUS.SUCCESS) {
                        uiNotifications.inform(vm.translationObject['CareProviderLocked'], 'info');
                        $state.reload();
                    }
                });
            }
            if (action == "unblock") {
                careProviderRepository.unblock(vm.profile.careProvider).success(function (response, status, headers, config) {
                    if (errorHandler.check(response, status, config) == errorHandler.STATUS.SUCCESS) {
                        uiNotifications.inform(vm.translationObject['CareProviderUnlocked'], 'success');
                        $state.reload();
                    }
                });
            }
        };

        vm.selectedServicesCategoriesChanged = function(){
            if(vm.selectedServicesCategories.length > vm.stgSelectedServicesCategories.length){
                var newCategory = null;
                vm.selectedServicesCategories.forEach(function(val){
                    if(!vm.stgSelectedServicesCategories.find(function(stg){
                        return stg.id == val.id
                    })){
                        newCategory = val;
                    }
                });
                if(newCategory && vm.selectedServicesCategories.find(function(val){return val.group != newCategory.group})){
                    vm.selectedServicesCategories = [];
                    vm.selectedServicesCategories.push(newCategory);
                    refreshServicesCategoriesSelectComponent();
                }
            }
            vm.stgSelectedServicesCategories = JSON.parse(JSON.stringify(vm.selectedServicesCategories));
        }

        function getLanguagesLevels() {
            vm.languageProficiencyLevelsDisplay = null;
            setTimeout(function () {
                vm.languageProficiencyLevelsDisplay = [{ "id": 0, "name": vm.translationObject["Basic"] }, { "id": 1, "name": vm.translationObject["Conversant"] },
                { "id": 2, "name": vm.translationObject["Proficient"] }, { "id": 3, "name": vm.translationObject["Fluent"] },
                { "id": 4, "name": vm.translationObject["Native"] }];
            }, 1);
        }

        function getCountries(isUpdate) {
            userRepository.getCountries().success(function (response, status, headers, config) {
                if (errorHandler.check(response, status, config) == errorHandler.STATUS.SUCCESS) {
                    vm.countries = response.data.map(function (c) {
                        return { "id": c.id, "name": c.name, "code": c.iso2Code };
                    });
                    if(!vm.profile.careProvider.countryUI && vm.profile.careProvider.countryId){
                        vm.profile.careProvider.countryUI = vm.countries.find(function (c) {
                            return c.id == vm.profile.careProvider.countryId;
                        });
                    }
                    if (isUpdate && vm.stgCountryId && vm.stgCountryId != -1) {
                        vm.profile.careProvider.countryUI = vm.countries.find(function (c) {
                            return c.id == vm.stgCountryId;
                        });
                    }
                }
                vm.onChangeCountry();
            });
        }

        function getLanguages(isUpdate) {
            userRepository.getLanguages().success(function (response, status, headers, config) {
                if (errorHandler.check(response, status, config) == errorHandler.STATUS.SUCCESS) {
                    vm.languages = response.data.map(function (l) {
                        return { "id": l.id, "name": l.name };
                    });
                    vm.profile.careProvider.languages = [];
                    // Specify care provider's language list with an appropriate keys from response.
                    var languages = isUpdate == true ? vm.stgLanguages : vm.response.languages;
                    if (languages) {
                        languages.forEach(function (lang) {
                            vm.profile.careProvider.languages.push({
                                model: {
                                    id: lang.languageId, name: lang.languageName, level: lang.languageLevel, languageLevelModel: vm.languageProficiencyLevelsDisplay.find(function (level) {
                                        return level.id == lang.languageLevel;
                                    })
                                },
                                list: (function () {
                                    var tempList = vm.profile.careProvider.languages.map(function (lang) {
                                        return lang.model
                                    });
                                    var result;
                                    result = $.grep(vm.languages, function (n, i) {
                                        return tempList.some(function (s) {
                                            return s.name == n.name
                                        });
                                    }, true);
                                    return result;
                                })()
                            });

                            //fill proficiency levels for each language
                            vm.profile.careProvider.languageProficiencyLevels.push({
                                model: { id: lang.languageLevel, name: vm.languageProficiencyLevels[lang.languageLevel] },
                                list: (function () {
                                    var tempList = vm.profile.careProvider.languageProficiencyLevels.map(function (langLevel) {
                                        return langLevel.model
                                    });
                                    var result;
                                    result = $.grep(vm.languageProficiencyLevels, function (n, i) {
                                        return tempList.some(function (s) {
                                            return s.languageLevel == n.languageLevel
                                        });
                                    }, true);
                                    return result;
                                })()
                            });
                        });
                    }

                }
                refreshLanguagesSelectComponent();
            });
        }

        function getServicingAreas(isUpdate) {
            careProviderRepository.getServicingAreas().success(function (response, status, headers, config) {
                if (errorHandler.check(response, status, config) == errorHandler.STATUS.SUCCESS) {
                    var servicingAreaList = [];

                    var mappedServicingArea = [];

                    response.data.forEach(function(servicingArea){
                        if (servicingArea.parentServicingArea) {
                            var foundedParrent = mappedServicingArea.find(function(val){ return val.id == servicingArea.parentServicingArea.id });
                            if (!foundedParrent) {
                                foundedParrent = {
                                id: servicingArea.parentServicingArea.id,
                                name: servicingArea.parentServicingArea.name,
                                order: servicingArea.parentServicingArea.order,
                                children: [],
                                isActive: false
                                };
                                mappedServicingArea.push(foundedParrent);
                            }

                            foundedParrent.children.push({
                                id: servicingArea.id,
                                name: servicingArea.name,
                                order: servicingArea.order,
                                children: [],
                                isActive: false
                            });
                        }else if(servicingArea.isChoosable){
                            mappedServicingArea.push({
                              id: servicingArea.id,
                              name: servicingArea.name,
                              order: servicingArea.order,
                              children: [{
                                id: servicingArea.id,
                                name: servicingArea.name,
                                order: servicingArea.order,
                                children: [],
                                isChoosable:servicingArea.isChoosable,
                                isActive: false
                              }],
                              isChoosable:servicingArea.isChoosable,
                              isActive: false
                            });
                        }
                    }.bind(this));
                    mappedServicingArea.sort(function(a, b){
                        return a.order - b.order;
                    });
                    mappedServicingArea.forEach(function(value){
                        value.children.sort(function(a, b){
                        return a.order - b.order;
                        });
                    })

                    mappedServicingArea.forEach(function(parent){
                        parent.children.forEach(function(child){
                            servicingAreaList.push({"id": child.id, "name": child.name, "group":parent.name, "order":child.order});
                        }.bind(this))
                    }.bind(this))
                    vm.servicingAreas = servicingAreaList;
                    if(!isUpdate){
                        vm.selectedServicingAreas = vm.servicingAreas.filter(function(value){
                            var foundedServicingArea = vm.profile.servicingAreas.find(function(sa){
                                return sa.id == value.id;
                            });
                            return foundedServicingArea != null && foundedServicingArea != undefined;
                        });
                    }
                    else if(isUpdate == true && vm.selectedServicingAreas && vm.selectedServicingAreas.length > 0){
                        var stgServicingAreas = [];
                        vm.selectedServicingAreas.map(function (sa) {
                            var servicingArea = vm.servicingAreas.find(function (selectedServicingArea) {
                                return selectedServicingArea.id == sa.id;
                            });
                            if(servicingArea){
                                stgServicingAreas.push(servicingArea);
                            }
                        });
                        vm.selectedServicingAreas = stgServicingAreas;

                    }

                    refreshServicingAreasSelectComponent();
                }
            });
        }

        function getServicesCategories(isUpdate) {
            careProviderRepository.getServicesCategories().success(function (response, status, headers, config) {
                if (errorHandler.check(response, status, config) == errorHandler.STATUS.SUCCESS) {
                    var mappedServicesCategories = response.data;
                    
                    mappedServicesCategories.sort(function(a, b){
                        return a.order - b.order;
                    });
                    vm.servicesCategories = mappedServicesCategories.map(function (c) {
                        if(c.parentCategory){
                            return {"id": c.id, "name": c.name, "group":c.parentCategory.name};
                        }else{
                            if(!mappedServicesCategories.find(function(fc){
                                return fc.parentCategory && fc.parentCategory.id == c.id;
                            })){
                                return {"id": c.id, "name": c.name, "group":c.name};
                            }
                        }
                    }).filter(function(c){
                        return c != null && c != undefined;
                    });

                    if(!isUpdate){
                        vm.selectedServicesCategories = vm.servicesCategories.filter(function(value){
                            var foundedServicesCategory = vm.profile.serviceCategories.find(function(sc){
                                return sc == value.id;
                            });
                            return foundedServicesCategory != null && foundedServicesCategory != undefined;
                        });
                        vm.stgSelectedServicesCategories = JSON.parse(JSON.stringify(vm.selectedServicesCategories));
                    }
                    else if(isUpdate == true && vm.selectedServicesCategories && vm.selectedServicesCategories.length > 0){
                        var stgServicesCategorie = [];
                        vm.servicesCategories.map(function (sc) {
                            var servicesCategory = vm.selectedServicesCategories.find(function (selectedServicesCategory) {
                                return selectedServicesCategory.id == sc.id;
                            });
                            if(servicesCategory){
                                stgServicesCategorie.push(sc);
                            }
                        });
                        vm.selectedServicesCategories = stgServicesCategorie;
                        vm.stgSelectedServicesCategories = JSON.parse(JSON.stringify(stgServicesCategorie));

                    }
                    
                    refreshServicesCategoriesSelectComponent();
                }
            });
        }

        function getSpecialQualities(isUpdate) {
            careProviderRepository.getSpecialQualities().success(function (response, status, headers, config) {
                if (errorHandler.check(response, status, config) == errorHandler.STATUS.SUCCESS) {
                    vm.specialQualities = response.data.map(function (c) {
                        return {"id": c.id, "name": c.name};
                    });
                    if(!isUpdate){
                        vm.selectedSpecialQualities = vm.specialQualities.filter(function(value){
                            var foundedServicingArea = vm.profile.specialQualities.find(function(sa){
                                return sa.id == value.id;
                            });
                            return foundedServicingArea != null && foundedServicingArea != undefined;
                        })
                    }
                    if(isUpdate == true && vm.selectedSpecialQualities && vm.selectedSpecialQualities.length > 0){
                        var stgSpecialQualities  = [];

                        vm.specialQualities.map(function (sq) {
                            var specialQuality = vm.selectedSpecialQualities.find(function (selectedSpecialQuality) {
                                return selectedSpecialQuality.id == sq.id;
                            });
                            if(specialQuality){
                                stgSpecialQualities.push(specialQuality);
                            }
                        });
                    }
                    refreshSpecialQualitiesSelectComponent();
                }
            });
        }


        // Main.
        careProviderRepository.getById(vm.currentProfileId).success(function (response, status, headers, config) {
            if (errorHandler.check(response, status, config) == errorHandler.STATUS.SUCCESS) {
                vm.onChangeCitizenship();
                vm.response = response.data;

                vm.profile.careProvider.id = response.data.careProvider.id;
                vm.profile.careProvider.isActive = response.data.careProvider.isActive;
                vm.profile.careProvider.firstName = response.data.careProvider.firstName;
                vm.profile.careProvider.lastName = response.data.careProvider.lastName;
                vm.profile.careProvider.firstNamePrivate = response.data.careProvider.firstNamePrivate;
                vm.profile.careProvider.lastNamePrivate = response.data.careProvider.lastNamePrivate;
                vm.profile.careProvider.phoneNumber = response.data.careProvider.phoneNumber;
                vm.profile.careProvider.email = response.data.careProvider.email;
                vm.profile.careProvider.imageUrl = response.data.careProvider.imageUrl;
                vm.profile.careProvider.imageThumbnailUrl = response.data.careProvider.imageThumbnailUrl;
                vm.profile.careProvider.birthDate = $filter('date')(response.data.careProvider.birthDate, "yyyy-MM-dd");
                vm.profile.careProvider.city = response.data.careProvider.city;
                vm.profile.careProvider.countryId = response.data.careProvider.countryId;
                vm.profile.careProvider.addressLine1 = response.data.careProvider.addressLine1;
                vm.profile.careProvider.addressLine2 = response.data.careProvider.addressLine2;
                vm.profile.careProvider.state = response.data.careProvider.state;
                vm.profile.careProvider.postalCode = response.data.careProvider.postalCode;
                vm.profile.careProvider.yearsOfExperience = response.data.careProvider.yearsOfExperience;
                vm.profile.careProvider.summary = response.data.careProvider.summary;
                vm.profile.careProvider.gender = response.data.careProvider.gender;
                vm.selectedGender = vm.genders.find(function(item){
                    return item.value == vm.profile.careProvider.gender;
                });
                vm.profile.careProvider.isResident = response.data.careProvider.isResident;
                vm.selectedCitizenship = vm.citizenship.find((function(item){
                    return +item.id == +response.data.careProvider.isResident;
                }.bind(vm)));
                vm.onChangeCitizenship();
                vm.profile.bankAccounts = response.data.bankAccounts;
                vm.profile.languages = response.data.languages;
                vm.profile.careProvider.languageProficiencyLevels = [];
                vm.profile.servicingAreas = response.data.servicingAreas;
                vm.profile.specialQualities = response.data.specialQualities;
                vm.profile.careProvider.stripeAccountStatus = response.data.careProvider.stripeAccountStatus;
                vm.profile.careProvider.stripeDisableReason = response.data.careProvider.stripeDisableReason;
                vm.profile.careProvider.individualIdNumber = response.data.careProvider.individualIdNumber;
                vm.profile.identityDocuments = response.data.identityDocuments;
                vm.profile.serviceCategories = response.data.serviceCategories;
                vm.profile.externalAccounts = response.data.externalAccounts;
                vm.profile.cardTokens = response.data.cardTokens;

                if (response.data.securityQuestions.length) {
                    vm.questionPair1.id = response.data.securityQuestions[0].questionId;
                    vm.questionPair1.question = response.data.securityQuestions[0].question;
                    vm.profile.verification.securityQuestion1.answer = response.data.securityQuestions[0].answer;
                    vm.profile.verification.securityQuestion1.id = response.data.securityQuestions[0].id;
                    vm.profile.verification.securityQuestion1.securityQuestionId = response.data.securityQuestions[0].questionId;

                    vm.questionPair2.id = response.data.securityQuestions[1].questionId;
                    vm.questionPair2.question = response.data.securityQuestions[1].question;
                    vm.profile.verification.securityQuestion2.answer = response.data.securityQuestions[1].answer;
                    vm.profile.verification.securityQuestion2.id = response.data.securityQuestions[1].id;
                    vm.profile.verification.securityQuestion2.securityQuestionId = response.data.securityQuestions[1].questionId;

                    if (vm.questionPair1) {
                        vm.stgSecretQuestion1 = vm.questionPair1.id
                    }
                    if (vm.questionPair2) {
                        vm.stgSecretQuestion2 = vm.questionPair2.id
                    }
                    if (vm.profile.careProvider.countryUI) {
                        vm.stgCountryId = vm.profile.careProvider.countryUI.id;
                    }
                    getSecurityQuestions(true);

                }
                
                if(vm.profile.identityDocuments && vm.docTypes.length){
                    vm.selectedDocType = vm.docTypes.find(function(docType){
                      return docType.id == +vm.profile.identityDocuments.documentType;
                    });
                }

                $("#care-provider-image").on('change', function () {
                    setTimeout(function () {
                        transformImage();
                    }, 10);
                });
                getServicesCategories();
                getSecurityQuestions();
                getLanguagesLevels();
                getCountries();
                getLanguages();
                getSpecialQualities();
                getServicingAreas();
                refreshGenderSelectComponent();
            }
        });
        vm.onChangeCountry = function(){
            refreshCountrySelectComponent();
            refreshCitizenshipSelectComponent();
            vm.onChangeCitizenship();
            refreshDocTypeSelectComponent();
        }
         //Uploader logic
         function transformImage(newImage) {
            setTimeout(function () {
                try{
                var fd = new FormData();
                var imgBlob = convertHelper.dataURIToBlob(newImage || vm.profile.careProvider.imageThumbnailUrl);
                fd.append('file', imgBlob, convertHelper.renderImageName(imgBlob.type));
                vm.tempFormData.data = fd;
                vm.tempFormData.isImageSelected = true;
               
                }catch(error){
                    console.log(error);
                }
            }, 10);
        }

        function refreshCountrySelectComponent(){
            setTimeout(function(){
                $('#countrySelectPicker').selectpicker('refresh');
                $('#countrySelectPicker option').each(function(){
                    var val = $(this).val();
                    var country = vm.countries.find(function(c){
                        if(val){
                            return c.id == +val;
                        }
                    }.bind(vm));

                    if(country){
                        $(this).attr("lang",country.code);
                    }
                });
            },5);
        }

        function refreshServicingAreasSelectComponent(){
            setTimeout(function(){
                $('#servicingAreaSelectPicker').selectpicker('refresh');
            },5);
        }

        function refreshSpecialQualitiesSelectComponent(){
            setTimeout(function(){
                $('#specialQualitiesSelectPicker').selectpicker('refresh');
            },5);
        }
        function refreshServicesCategoriesSelectComponent(){
            setTimeout(function(){
                $('#servicesCategories').selectpicker('refresh');
            },5);
        }
        
        function refreshCitizenshipSelectComponent(){
            setTimeout(function(){
                $('#Citizenship').selectpicker('refresh');
            },5);
        }

        function refreshDocTypeSelectComponent(){
            setTimeout(function(){
                $('#DocType').selectpicker('refresh');
            },5);
        }

        function refreshLanguagesSelectComponent(){
            setTimeout(function () {
                $(".languages-list").selectpicker('refresh');
                $(".languages-level-list").selectpicker('refresh');
            }, 1);
        }        
        
        function refreshGenderSelectComponent(){
            setTimeout(function(){
                $('#selectGender').selectpicker('refresh');
            },5);
        }

        function refreshSecurityQuestionsSelectComponent(){
            setTimeout(function(){
                $('#securityQuestions1SelectPicker').selectpicker('refresh');
                $('#securityQuestions2SelectPicker').selectpicker('refresh');
            },5);
        }


        $scope.$on("$destroy", function () {
            vm.unsubscribe();
        });

        window.EDIT_CARE_PROVIDER = vm;

    }

    // IoC container.
    profileEditCareProvider.$inject = [
        "$scope",
        "repository.user",
        "repository.careProvider",
        "repository.apiMediaUploader",
        "$state",
        "$q",
        "$filter",
        "helpers.convert",
        "appUtils.errorHandler",
        "appUtils.uiNotifications",
        "appConstant.careProviders",
        "appConstant.stripeAccountStatus",
        "appConstant.verificationDocumentType",
        "appConstant.stripeAccountStatusDescription", 
        "$translate",
        "FileUploader",
        "helpers.localization"
    ];

})();