(function () {
    'use strict';

    angular
        .module('app')
        .controller('CreateCareProviderController', createCareProvider);

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

        vm.translationObject = {};

        vm.loadTranslation = function () {
            $translate(['Info', 'Success', 'Warning', 'Error', 'CareProviderCreated', 'CareProviderIdentificationNeeded', 'CareProviderLicenseNeeded',
                'CareProviderPhotoIsEmpty', 'Basic', 'Conversant', 'Proficient', 'Fluent', 'Native']).then(function (tr) {
                    vm.translationObject = tr;
                });
        };
        vm.stgLanguages = null;
        vm.stgCountryId = -1;
        vm.stgSecretQuestion1 = -1;
        vm.stgSecretQuestion2 = -1;
        vm.unsubscribe = localizationHelper.eventEmitter.subscribe('onLanguageChangedEvent', function (lang) {
            if (vm.profile.careProvider.languages) {
                vm.stgLanguages = vm.profile.careProvider.languages.map(function (l) {
                    if (l.model.languageLevelModel && l.model.name) {
                        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);
            getLanguages(true);
            getCountries(true);
            getServicingAreas(true);
            getSpecialQualities(true);
            getCountries(true);
            getSecurityQuestions(true);
            getLanguagesLevels();
            vm.onChangeCitizenship();
            refreshCitizenshipSelectComponent();
            refreshDocTypeSelectComponent();
            refreshGenderSelectComponent();
        });
        vm.loadTranslation();

        // Variables.
        vm.defaultImage = "images/default-image.png";
        vm.defaultAvatar = "images/default-user.png";
        vm.yearExperienceMaxLength = 3;
        vm.countries = [];
        vm.languages = [];
        vm.citizenship = [
            { id: 1, name: "ImAmerican" },
            { id: 0, name: "ImNotAmerican" }
        ];
        vm.docTypes = [];
        vm.selectedDocType = null;
        vm.selectedCitizenship = null;
        vm.languageProficiencyLevelsDisplay = [];
        vm.languageProficiencyLevels = careProviders.LANGUAGE_PROFICIENCY_LEVELS;
        vm.servicingAreas = [];
        vm.specialQualities = [];
        vm.careProviderLicensesFormData = [];
        vm.identityDocumentsExternalIds = [];
        vm.selectedServicesCategories = [];
        vm.stgSelectedServicesCategories = [];
        vm.bankInfoForm = 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": "",
                "PhoneNumber": "",
                "Email": "",
                "ImageThumbnailUrl": vm.defaultAvatar,
                "BirthDate": "",
                "City": "",
                "countryId": null,
                "YearsOfExperience": null,
                "individualIdNumber": null,
                "languages": [
                    {
                        model: {
                            id: -1,
                            name: null
                        },
                        list: []
                    }
                ],
                "addressLine1": "",
                "addressLine2": "",
                "summary": "",
                "state": "",
                "gender": "",
                "postalCode": "",
                "languageProficiencyLevels": [],
                countryUI: null,
                "isResident": 0,
            },
            "verification": {
                "securityQuestion1": {
                    "securityQuestionId": 1,
                    "answer": ""
                },
                "securityQuestion2": {
                    "securityQuestionId": 2,
                    "answer": ""
                }
            },
            "Password": "",
            "ConfirmPassword": "",
            "bankAccounts": [],
            "servicingAreas": [],
            "serviceCategories": [],
            "specialQualities": [],
            "careProviderLicenses": [],
            "identityDocuments": {
                "documentType": null,
                "document": {
                    "front": {
                        "id": null,
                        "imageUrl": null,
                        "name": null,
                        "createDate": null
                    }
                }
            },
        };
        window["Create"] = this;
        // Bind jQuery datePicker to html-element.
        careProviderRepository.updateDate("#BirthDate", null, true, new Date());

        vm.tempFormData = { data: null, isImageSelected: false };
        $("#care-provider-image").on('change', function () {
            setTimeout(function () {
                transformImage();
            }, 20);
        });
        vm.selectedSpecialQualities = null;
        vm.selectedServicingAreas = null;

        //Methods.
        vm.createCareProvider = function () {
            if (vm.checkIfIdentificationsUploaded()) {
                vm.profile.verification.securityQuestion1.securityQuestionId = vm.questionPair1.id;
                vm.profile.verification.securityQuestion2.securityQuestionId = vm.questionPair2.id;
                vm.profile.careProvider.countryId = vm.countries.find(function (c) {
                    return c.name == vm.profile.careProvider.countryUI.name
                }).id;

                var requestModel = angular.copy(vm.profile);
                requestModel.languages = vm.profile.careProvider.languages.map(function (l) {
                    return { languageId: l.model.id, languageLevel: l.model.languageLevelModel.id };
                });
                requestModel.careProvider.imageThumbnailUrl = null;
                vm.profile.careProvider.imageThumbnailUrl = null;

                requestModel.servicingAreas = vm.selectedServicingAreas.map(function (saMap) {
                    return { id: saMap.id };
                });
                requestModel.careProvider.gender = vm.selectedGender.value;
                if (vm.selectedSpecialQualities && vm.selectedSpecialQualities.length) {
                    requestModel.specialQualities = vm.selectedSpecialQualities.map(function (sqMap) {
                        return { id: sqMap.id };
                    });
                }
                requestModel.serviceCategories = vm.selectedServicesCategories.map(function (scMap) {
                    return { id: scMap.id };
                });
                vm.getExternalIdsForIdentification().then(function (identities) {
                    requestModel.identityDocuments = identities;
                    if (vm.profile.careProvider.countryUI.code == 'US') {
                        requestModel.identityDocuments.documentType = vm.selectedDocType.id;
                    } else {
                        requestModel.identityDocuments.documentType = verificationDocumentType.VERIFICATION_DOCUMENT_TYPE.PassportOrCard;
                    }
                    vm.getExternalIdsForLicense().then(function (licenses) {
                        requestModel.careProviderLicenses = licenses;

                        apiMediaUploaderRepository.uploadImageFormData(vm.tempFormData.data, true).then(function (response) {

                            if (response.success) {
                                requestModel.careProvider.imageUrl = response.data[0].fileUrl;
                                requestModel.careProvider.imageThumbnailUrl = response.data[0].fileThumbnailUrl;
                                if (requestModel.careProvider.countryUI.code !== 'US') {
                                    requestModel.careProvider.city = null;
                                    requestModel.careProvider.state = null;
                                    requestModel.careProvider.addressLine1 = null;
                                    requestModel.careProvider.addressLine2 = null;
                                    requestModel.careProvider.postalCode = null;
                                    requestModel.careProvider.individualIdNumber = null;
                                } else {
                                    console.log('vm.selectedCitizenship.id', vm.selectedCitizenship.id);
                                    vm.profile.careProvider.isResident = vm.selectedCitizenship.id;
                                }
                                console.log('requestModel', requestModel);
                                careProviderRepository.add(requestModel).success(function (response, status, headers, config) {
                                    if (errorHandler.check(response, status, config) == errorHandler.STATUS.SUCCESS) {
                                        uiNotifications.inform(vm.translationObject['CareProviderCreated'], 'success');
                                        var careProviderId = response.data.careProvider.id;
                                        appLocalStorage.delete("currentTabUrl");
                                        $state.go('careProviders.profile', { "id": careProviderId });

                                    } else if (response && !response.success) {
                                        uiNotifications.inform(response.message, 'warning');
                                    }
                                });
                            }
                        });
                    })
                });
            } else {
                uiNotifications.inform(vm.translationObject['CareProviderIdentificationNeeded'], 'error');
            }
        };

        vm.pushBankAccount = function () {
            vm.profile.bankAccounts.push(new BankAccount());
        };

        vm.pushLanguage = function () {
            vm.profile.careProvider.languages.push({
                model: { id: null, name: null, level: 0, languageLevelModel: vm.languageProficiencyLevelsDisplay[0] },
                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;
                })(),
                levelsList: vm.languageProficiencyLevelsDisplay
            });
            refreshLanguagesSelectComponent();
        };

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

        vm.removeBankAccount = function (index) {
            vm.profile.bankAccounts.splice(index, 1);
        };

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

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

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

        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() {
            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.stgCountryId && vm.stgCountryId != -1) {
                        vm.profile.careProvider.countryUI = vm.countries.find(function (c) {
                            return c.id == vm.stgCountryId;
                        });
                    }
                }
                refreshCountrySelectComponent();
            });
        }

        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 == 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 == true && vm.selectedServicesCategories && vm.selectedServicesCategories.length > 0) {
                        var stgServicesCategorie = [];
                        vm.selectedServicesCategories.map(function (sc) {
                            var servicesCategory = vm.servicesCategories.find(function (selectedServicesCategory) {
                                return selectedServicesCategory.id == sc.id;
                            });
                            if (servicesCategory) {
                                stgServicesCategorie.push(servicesCategory);
                            }
                        });
                        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 == 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();
                }
            });
        }

        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 };
                    });

                    if (isUpdate && vm.stgLanguages && vm.stgLanguages.length > 0 && vm.stgLanguages[0]) {
                        vm.profile.careProvider.languages = [];

                        vm.stgLanguages.forEach(function (lang) {
                            if (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;
                                    })(),
                                    levelsList: vm.languageProficiencyLevelsDisplay
                                });

                                //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;
                                    })()
                                });
                            }
                        });

                    } else {
                        vm.profile.careProvider.languages[0].list = vm.languages.map(function (lang) {
                            return lang
                        });
                        vm.profile.careProvider.languages[0].levelsList = vm.languageProficiencyLevelsDisplay;
                    }
                }
                refreshLanguagesSelectComponent();
            });
        }

        //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);
        }

        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();
        }
        /*Identifications*/
        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.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.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 = { externalId: exId };
                                    }
                                    break;
                                case 1:
                                    if (exId != null) {
                                        vm.profile.identityDocuments.document.back = { externalId: exId };
                                    }
                                    break;
                            }
                        });
                    }
                    resolve(vm.profile.identityDocuments);
                });
            });
        };

        /*Licenses*/
        vm.licenceUploader = new FileUploader({
            url: 'api/upload/'
        });
        vm.licenceUploader.filters.push({
            name: 'imageFilter',
            fn: function (item, options) {
                var type = '|' + item.type.slice(item.type.lastIndexOf('/') + 1) + '|';
                return '|jpg|png|jpeg|bmp|gif|'.indexOf(type) !== -1;
            }
        });
        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));
        }
        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.triggerFileInputLicenseClick = function () {
            setTimeout(function () {
                $("#fileInputLicense").trigger("click");
            }, 100);
        };

        vm.uploadLicenceFiles = function () {
            var licenseFiles = vm.licenceUploader.queue.map(function (item) {
                return item._file
            });
            return $q(function (resolve, reject) {
                $q.all(licenseFiles.map(function (licenseFile) {
                    return $q(function (resolve, reject) {
                        var fd = new FormData();
                        var imgBlob = licenseFile;
                        fd.append('file', imgBlob, convertHelper.renderImageName(imgBlob.type));
                        apiMediaUploaderRepository.uploadCareProviderLicense(fd).then(function (response) {
                            if (response.success) {
                                resolve(response.data.externalId);
                            }
                        });
                    });
                })).then(function (externalIds) {
                    resolve(externalIds);
                });
            });
        };


        vm.onChangeCountry = function () {
            refreshCountrySelectComponent();
            vm.onChangeCitizenship();
            refreshCitizenshipSelectComponent();
            refreshDocTypeSelectComponent();
        }

        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;
                    vm.questionList2 = vm.questions;
                    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;
                            });
                        }
                    }
                }
                resetBrowserAutocompletedFields();
                refreshSecurityQuestionsSelectComponent();
            });
        }
        function resetBrowserAutocompletedFields() {
            //vm.profile.careProvider.BirthDate = "";
            vm.profile.Password = "";
        }
        vm.getExternalIdsForLicense = function () {
            if (vm.licenceUploader.queue && vm.licenceUploader.queue.length > 0) {
                return $q(function (resolve, reject) {
                    vm.uploadLicenceFiles().then(function (externalIds) {
                        externalIds.map(function (exId) {
                            vm.profile.careProviderLicenses.push({ externalId: exId });
                        });
                        resolve(vm.profile.careProviderLicenses)
                    });
                });
            } else {
                return $q(function (resolve, reject) {
                    resolve(null)
                });
            }
        };

        vm.checkIfLicenseUploaded = function () {
            return vm.licenceUploader.queue.length > 0;
        };

        vm.checkIfIdentificationsUploaded = function () {
            return vm.identificationUploaderMainFront.queue.length > 0;
        };

        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 refreshLanguagesSelectComponent() {
            setTimeout(function () {
                $(".languages-list").selectpicker('refresh');
                $(".languages-level-list").selectpicker('refresh');
            }, 5);
        }

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

        function refreshGenderSelectComponent() {
            setTimeout(function () {
                $('#selectGender').selectpicker('refresh');
            }, 5);
        }

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

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


        // Entities
        function BankAccount() {
            return {
                "bankName": "",
                "nameOnAccount": "",
                "routingNumber": "",
                "accountNumber": "",
                "address": "",
                "city": "",
                "state": "",
                "countryId": null,
                "postalCode": "",
                "default": true
            }
        }


        // Main.
        getSecurityQuestions();
        getLanguagesLevels();
        getCountries();
        getServicingAreas();
        getSpecialQualities();
        getLanguages();
        getServicesCategories();
        vm.onChangeCitizenship();
        refreshCitizenshipSelectComponent();
        refreshDocTypeSelectComponent();
        refreshGenderSelectComponent();
        vm.pushBankAccount();

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

        window.CREATE_CARE_PROVIDER = vm;

    }

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

})();