angular.module('appServices').factory('sessionService', ['$q',
    function ($q) {
        function getCurrentLoginSession() {
            var deferred = $q.defer();
            socialid.login.getConnectionStatus(function (response) {
                if (response.status === "success") {
                    deferred.resolve(response.data.connection_id);
                } else {
                    deferred.reject("Could not get info from the current login session.");
                }
            });
            return deferred.promise;
        }

        return {
            getCurrentLoginSession
        };
    }
]);
angular.module('appServices').factory('configService', ['$q', '$http', 'sessionService', 'cbtWorkflows',
    function ($q, $http, sessionService, cbtWorkflows) {
        var data = null;
        var promise = null;

        function get() {
            if (data) {
                return $q.resolve(data);
            }

            if (promise) {
                return promise;
            }

            var deferred = $q.defer();
            promise = deferred.promise;

            sessionService.getCurrentLoginSession().then(function (connectionId) {
                $http.post(cbtWorkflows.url + "/config", {
                    connection_id: connectionId
                }).then(function (response) {
                    deferred.resolve(response.data);
                });
            });

            return promise;
        }

        function reset() {
            data = null;
            promise = null;
        }

        return {
            get,
            reset
        };
    }
]);
// extend original currentUserService with currentUser.permissions

angular.module('appServices').factory('currentUserService', ['$q', 'emailHelperService', 'sidLoginService', 'userModelService', 'sidRaasService', 'configService',
    function ($q, emailHelper, sidLoginService, userModelService, sidRaasService, configService) {
        var currentUser;

        function get() {
            if (currentUser) {
                return $q.resolve(currentUser);
            } else {
                return $q.reject();
            }
        }

        function refresh() {
            return sidLoginService.getUserInfo().then(function (userInfo) {
                currentUser = userModelService.createFromUserInfo(userInfo);
                return sidLoginService.getConnectionStatus().then(function (connection) {
                    userModelService.updateWithConnection(currentUser, connection);
                    return sidLoginService.getUserDatastore().then(function (data) {
                        userModelService.updateWithData(currentUser, data);
                        return configService.get().then(function (config) {
                            currentUser.permissions = config.permissions;
                            return currentUser;
                        });
                    }, function (error) {
                        return currentUser;
                    });
                });
            });
        }

        function logout() {
            currentUser = null;
        }

        function update(user) {
            var extra = {
                confirmation_email: emailHelper.emailParams()
            };
            return sidRaasService.updateUser(currentUser.connection.connection_id, user.email_address, user.email_address_confirmation, user.username, user.data, extra);
        }

        return {
            get: get,
            logout: logout,
            refresh: refresh,
            update: update
        };
    }
]);

angular.module('appServices').factory('manageUserActionService', [
    '$http',
    'sessionService',
    'cbtWorkflows',
    function ($http, sessionService, cbtWorkflows) {

        function deleteUser(userId) {
            return sessionService.getCurrentLoginSession().then(function (connectionId) {
                return $http.delete(
                    cbtWorkflows.url + '/da/users/' + userId,
                    {
                        data: { connection_id: connectionId, user_id: userId  },
                        headers: { 'Content-Type': 'application/json' }
                    }
                );
            });
        }

        return {
            deleteUser: deleteUser
        };
    }
]);
var manageUserResolve = function ($route, manageUserService) {
    const userId = $route.current.params.id;
    return manageUserService.getManageUser(userId);
}

var manageUserDataResolve = function ($route, manageUserService) {
    const userId = $route.current.params.id;
    return manageUserService.getManageUserData(userId);
}

window.customPortalRoutes = window.customPortalRoutes || [];

manageUserResolve.$inject = ['$route', 'manageUserService'];
manageUserDataResolve.$inject = ['$route', 'manageUserService'];

function permissionGuard(resource, action) {
    return function ($q, $location, configService) {
        return configService.get().then(function (config) {

            if (config.permissions?.[resource]?.[action]) {
                return true;
            }

            $location.path('/profile');
            return $q.reject('not_authorized');
        });
    };
}

const manageUsersCustomPortalRoutes = [
    {
        path: '/users',
        templateUrl: 'manage_users.html',
        controller: 'ManageUsersController',
        resolve: {
            user: 'loggedInUser',
            permission: permissionGuard('manage_users', 'read')
        }
    },
    {
        path: '/users/:id',
        templateUrl: 'manage_user.html',
        controller: 'ManageUserController',
        resolve: {
            user: 'loggedInUser',
            manageUser: manageUserResolve,
            manageUserData: manageUserDataResolve,
            permission: permissionGuard('manage_users', 'read')
        }
    },
    {
        path: '/users/:id/credentials',
        templateUrl: 'manage_user_credentials.html',
        controller: 'ManageUserCredentialsController',
        resolve: {
            user: 'loggedInUser',
            manageUser: manageUserResolve,
            manageUserData: manageUserDataResolve,
            permission: permissionGuard('manage_users', 'read')
        }
    },
    {
        path: '/users/:id/credentials/:name/:objectId',
        templateUrl: 'manage_user_edit_credentials.html',
        controller: 'ManageUserEditCredentialsController',
        resolve: {
            user: 'loggedInUser',
            manageUser: manageUserResolve,
            manageUserData: manageUserDataResolve,
            permission: permissionGuard('manage_users', 'update')
        }
    }
];

customPortalRoutes.push(...manageUsersCustomPortalRoutes)

angular.module("appDirectives").directive("manageUsersResultTable",
    function () {
        return {
            restrict: "E",
            templateUrl: "templates/manage_users_result_table.html",
            scope: true,
            link: function (scope, element, attrs) {
                scope.manageUsersPath = attrs.manageUsersPath;
                scope.includeTarget = attrs.includeTarget == "true";
            }
        }
    }
);
angular.module("appDirectives").directive("manageUsersSearchFilters", ['$location',
    function ($location) {
        return {
            restrict: "E",
            templateUrl: "templates/manage_users_search_filters.html",
            scope: true,
            link: function (scope, element, attrs) {
                scope.searchField = 'user.username';

                scope.updateParams = function () {
                    $location.search({
                        searchBy: scope.searchField,
                        searchValue: scope.searchQuery,
                        page: null
                    });

                    scope.searchManageUsers();
                };
            }
        }
    }
]);
angular.module("appDirectives").directive("manageUsersSearch",
    function () {
        return {
            restrict: "E",
            templateUrl: "templates/manage_users_search.html",
            scope: true,
            link: function (scope, element, attrs) {
                scope.includeFilters = attrs.includeFilters == "true";
            }
        }
    }
);
angular.module('appDirectives').directive('manageUserCredentialsTable', function () {
    return {
        restrict: 'E',
        templateUrl: "templates/manage_user_credentials_table.html",
    };
});

function request($http, sessionService, cbtWorkflows) {
    return function (method, path, data) {
        return sessionService.getCurrentLoginSession()
            .then(connection_id =>
                $http({
                    method,
                    url: cbtWorkflows.url + path,
                    data,
                    params: { connection_id }
                })
            )
            .then(r => r.data);
    };
}

function paged($http, sessionService, cbtWorkflows) {
    return function (path) {
        return sessionService.getCurrentLoginSession()
            .then(connection_id => {

                function fetch(page, acc = []) {
                    return $http.get(cbtWorkflows.url + path, {
                        params: { connection_id, page, page_size: 100 }
                    }).then(r => {
                        const data = r.data || {};
                        const results = data.results || [];

                        const merged = acc.concat(results);
                        const total = data.total || merged.length;

                        if (merged.length >= total || results.length < 100) {
                            return { results: merged, total: merged.length };
                        }

                        return fetch(page + 1, merged);
                    });
                }

                return fetch(1);
            });
    };
}

angular.module('appServices').factory('manageUserService',
    function ($http, sessionService, cbtWorkflows) {

        const req = request($http, sessionService, cbtWorkflows);
        const pg = paged($http, sessionService, cbtWorkflows);

        return {
            getManageUser: id =>
                req('GET', `/da/users/${id}`),

            getManageUserData: id =>
                req('GET', `/da/users/${id}/data`),
        };
    });

angular.module('appServices').factory('manageUserCredentialService',
    function ($http, sessionService, cbtWorkflows) {

        function req(method, url, data) {
            return sessionService.getCurrentLoginSession()
                .then(connection_id =>
                    $http({
                        method,
                        url,
                        data,
                        params: { connection_id }
                    })
                )
                .then(r => r.data);
        }

        function base(userId, schema, objectId) {
            const root = `${cbtWorkflows.url}/uc/users/${userId}/credentials/${schema}`;

            if (!objectId || objectId === 'undefined' || objectId === 'null') {
                console.error('[credentials] missing objectId', { userId, schema, objectId });
                return root;
            }

            return `${root}/${objectId}`;
        }

        return {
            getCredential: (u, s, id) =>
                req('GET', base(u, s, id)),

            unlockUser: (u, s, id, f) =>
                req('POST', base(u, s, id) + '/unlock', f),

            resetPassword: (u, s, id, f) =>
                req('POST', base(u, s, id) + '/reset-password', f),
        };
    });

angular.module('appServices').factory('manageUserCredentialPresenterService', [
    function () {

        function formatLogin(schemaName, result) {
            var loginMap = {
                ad_data: result.samaccountname
            };

            return loginMap[schemaName] ||
                result.samaccountname ||
                result.userName ||
                result.username ||
                result.login ||
                '-';
        }

        function buildRow(schemaName, result) {
            return {
                schema_name: schemaName,
                object_id: result.object_id,
                login: formatLogin(schemaName, result),
                raw: result
            };
        }

        function present(payload, allowedCredentials) {
            return (payload || [])
                .filter(function (schema) {
                    return allowedCredentials.indexOf(schema.name) !== -1;
                })
                .reduce(function (rows, schema) {
                    var schemaRows = (schema.results || []).map(function (result) {
                        return buildRow(schema.name, result);
                    });

                    return rows.concat(schemaRows);
                }, []);
        }

        return {
            present: present
        };
    }
]);
angular.module('appControllers').controller('ManageUsersController', ['$scope', '$location', '$http', 'paginationService', 'user', 'sessionService', 'cbtWorkflows', 'manageUserActionService', 'alertService', 'errorService', '$route',
    function ($scope, $location, $http, paginationService, user, sessionService, cbtWorkflows, manageUserActionService, alertService, errorService, $route) {
        function onInit() {
            $scope.user = user;
            $scope.alerts = alertService.get();
        }

        $scope.$on('$locationChangeSuccess', function () {
            var currentParams = $location.search();
            if (!currentParams || Object.keys(currentParams).length === 0) {
                return;
            }
            $scope.searchManageUsers();
        });

        $scope.searchManageUsers = function () {
            $scope.manage_users_search = null;
            var params = $location.search();
            var page = parseInt(params.page, 10) || 1;
            var pageSize = parseInt(params.pageSize, 10) || 10;
            var searchBy = params.searchBy || null;
            var searchValue = params.searchValue || null;
            alertService.clear();

            if (!searchValue) {
                alertService.add('Por favor, insira uma matrícula para pesquisar.');
                return;
            }

            sessionService.getCurrentLoginSession().
                then(function (connectionId) {
                    $scope.manage_users_search_params = { connection_id: connectionId, page: page, page_size: pageSize, search_by: searchBy, search_value: searchValue, manager_name: $scope.user.data.nome };
                    $http.get(cbtWorkflows.url + "/da/users", { params: $scope.manage_users_search_params }).
                        then((response) => {
                            $scope.manage_users_search = response.data;
                            $scope.pagination = paginationService.build(response.data, $scope.manage_users_search_params);
                        });
                });
        };

        onInit();
    }
]);

angular.module('appControllers').controller('ManageUserController', ['$scope', 'user', '$routeParams', 'manageUser', 'manageUserData', 'alertService',
    function ($scope, user, $routeParams, manageUser, manageUserData, alertService) {
        function onInit() {
            $scope.userId = $routeParams.id;
            $scope.user = user;
            $scope.manage_user = manageUser;
            $scope.manage_user.user_data = manageUserData;
            $scope.alerts = alertService.get();
        }

        onInit();
    }
]);

angular.module('appControllers').controller('ManageUserCredentialsController', ['$scope', '$http', 'user', 'manageUser', 'manageUserData', 'sessionService', 'cbtWorkflows', 'alertService', 'errorService', '$route', 'manageUserCredentialPresenterService',
    function ($scope, $http, user, manageUser, manageUserData, sessionService, cbtWorkflows, alertService, errorService, $route, manageUserCredentialPresenterService
    ) {

        function onInit() {
            $scope.user = user;
            $scope.manage_user = manageUser;
            $scope.manage_user.user_data = manageUserData;
            $scope.credentials = [];
            $scope.alerts = alertService.get();

            $scope.allowed_credentials = [
                'ad_data'
            ];

            $scope.allowed_new_credentials = [
                'ad_data'
            ];

            $scope.fetchCredentials();
        }

        $scope.fetchCredentials = function () {

            sessionService.getCurrentLoginSession()
                .then(function (connectionId) {
                    $scope.manage_search_params = {
                        connection_id: connectionId,
                        credentials: $scope.allowed_credentials
                    };

                    return $http.get(
                        cbtWorkflows.url + '/uc/users/' + $scope.manage_user.id + '/credentials',
                        {
                            params: $scope.manage_search_params
                        }
                    );
                })
                .then(function (response) {
                    $scope.credentials = manageUserCredentialPresenterService.present(
                        response.data,
                        $scope.allowed_credentials
                    );
                })
                .catch(function (response) {
                    errorService.handle(response);
                });
        };

        onInit();
    }
]);

angular.module('appControllers').controller('ManageUserEditCredentialsController', ['$scope', 'user', 'manageUser', 'manageUserData', 'alertService', 'errorService', '$routeParams', '$timeout', 'manageUserCredentialService', '$location', 'i18nService',
    function ($scope, user, manageUser, manageUserData, alertService, errorService, $routeParams, $timeout, manageUserCredentialService, $location, i18n) {

        function onInit() {
            $scope.user = user;
            $scope.manage_user = manageUser;
            $scope.manage_user.user_data = manageUserData;
            $scope.alerts = alertService.get();
            $scope.userId = $routeParams.id;
            $scope.credential_name = $routeParams.name;
            $scope.object_id = $routeParams.objectId;
        }

        $scope.unlockUser = function () {
            var payload;

            alertService.clear();

            payload = {
                samaccountname: $scope.manage_user.username,
                email_address: $scope.manage_user.email_address,
                user_email_address: $scope.user.email_address
            };

            manageUserCredentialService.unlockUser(
                $scope.userId,
                $scope.credential_name,
                $scope.object_id,
                payload
            )
                .then(function () {
                    alertService.add(
                        i18n.t(
                            'manage_user.credential.' +
                            $scope.credential_name +
                            '.unlocked_successfully'
                        )
                    );

                    $location.path('/users/' + $scope.userId + '/credentials');
                })
                .catch(function (response) {
                    errorService.handle(response.data, '');
                });
        };

        $scope.resetPassword = function () {
            var payload;

            alertService.clear();

            payload = {
                samaccountname: $scope.manage_user.username,
                email_address: $scope.manage_user.email_address,
                manager_name: $scope.manage_user.user_data.gestor,
                user_email_address: $scope.user.email_address,
                user_data_name: $scope.user.data.nome
            };

            manageUserCredentialService.resetPassword(
                $scope.userId,
                $scope.credential_name,
                $scope.object_id,
                payload
            )
                .then(function (response) {
                    alertService.add(
                        i18n.t(
                            'manage_user.credential.' +
                            $scope.credential_name +
                            '.reset_password_successfully'
                        ) + " " + response
                    );

                    $location.path('/users/' + $scope.userId + '/credentials');
                })
                .catch(function (response) {
                    errorService.handle(response.data, '');
                });
        };

        onInit();
    }
]);

angular.module('appConstants').constant('cbtWorkflows', {
    url: "https://banco-yamaha-staging.workflows.coffeebeantech.com",
    apps: {
        ad: {"loginAppId":2995}
    }
});