/**
* @purpose: BatchJob to evaluate if users are currently locked, 
*           frozen or green (=active) and update a flag on User.
*
* @author:  Christian Schwabe
*
* @history:
* version                   | author                                    | changes
* ====================================================================================
* 0.1 29.01.2020            | Christian.Schwabe@colliers.com            | Inital version.
*/


global with sharing class EvaluateLockedUserBatch implements Schedulable{
    global void execute(SchedulableContext schedulableContext) {
        List<User> toBeUpdatedUser = new List<User>();

        //Retrieve all active users.
        Map<Id, User> mapOfActiveUserById = new Map<Id, User>([SELECT
                                                                    Id, Status__c 
                                                                FROM
                                                                    User 
                                                                WHERE
                                                                    IsActive = true AND
                                                                    UserType = 'Standard'
                                                                ]);

        List<Object> listOfGenericUserLogin = new List<Object>();
        //If no running test: select from existing data
        if(Test.isRunningTest() == false){
            listOfGenericUserLogin = [SELECT
                                            UserId, IsPasswordLocked, IsFrozen 
                                        FROM
                                            UserLogin 
                                        WHERE
                                            UserId = :mapOfActiveUserById.keySet()
                                    ];
        } else {//If running test: use a wrapper class (CustomUserLogin)
            User frozenUser = mapOfActiveUserById.values().get(0);
            CustomUserLogin frozenUserLogin = new CustomUserLogin(true, false, frozenUser.Id);
            listOfGenericUserLogin.add(frozenUserLogin);

            User passwordLockedUser = mapOfActiveUserById.values().get(1);
            CustomUserLogin passwordLockedUserLogin = new CustomUserLogin(false, true, passwordLockedUser.Id);
            listOfGenericUserLogin.add(passwordLockedUserLogin);
        
            User user = mapOfActiveUserById.values().get(2);
            CustomUserLogin userLogin = new CustomUserLogin(false, false, user.Id);
            listOfGenericUserLogin.add(userLogin);
        }

        //Check UserLogin to evaluate if a user is frozen, locked or active.
        for(Object genericUserLogin : listOfGenericUserLogin){
            Id userId;
            Boolean isFrozen;
            Boolean isPasswordLocked;

            if(Test.isRunningTest() == false){
                UserLogin userLogin = (UserLogin) genericUserLogin;
                userId = userLogin.Id;
                isFrozen = userLogin.IsFrozen;
                isPasswordLocked = userLogin.IsPasswordLocked;
            } else {
                CustomUserLogin customUserLogin = (CustomUserLogin) genericUserLogin;
                userId = customUserLogin.userId;
                isFrozen = customUserLogin.isFrozen;
                isPasswordLocked = customUserLogin.isPasswordLocked;
            }

            User user                   = mapOfActiveUserById.get(userId);
            String oldStatus            = '' + user.Status__c;
            Boolean statusHasChanged    = false;

            if(isFrozen){
                user.Status__c = 'Frozen';
            } else if(isPasswordLocked){
                user.Status__c = 'Locked';
            } else {
                user.Status__c = 'Green';
            }

            statusHasChanged = this.hasChanged(oldStatus, user.Status__c);

            if(statusHasChanged == true){//Apply update on records, only if status has changed to minimize dmls.
                toBeUpdatedUser.add(user);
            }
        }

        List <Database.SaveResult> saveResult = Database.update(toBeUpdatedUser, false);
        System.debug('>>>saveResult: ' + saveResult);

        this.reschedule(schedulableContext);
    }

    /**
    * Check if status has changed.
    *
    * @param oldValue - String: source string.
    * @param newValue - String: to be compared string.
    *
    * @return Boolean - If comparison is not equals -> true - Otherwise: false
    */
    private Boolean hasChanged(String oldValue, String newValue){
        return ! oldValue.equalsIgnoreCase(newValue);
    }

    private void reschedule(SchedulableContext schedulableContext){
        System.debug('>>>Abort job, rescheduling');
        Id jobId = schedulableContext.getTriggerId();
        System.abortJob(jobId);

        //Reschedule Job after 15 minutes.
        Datetime dateTimee  = System.now().addMinutes(15);
        String day          = String.valueOf(dateTimee.day());
        String month        = String.valueOf(dateTimee.month());
        String hour         = String.valueOf(dateTimee.hour());
        String minute       = String.valueOf(dateTimee.minute());
        
        String strSchedule = '0 ' + minute + ' ' + hour + ' ' + day + ' ' + month + ' ?';
        System.schedule('>>>EvaluateLockedUserBatch', strSchedule, new EvaluateLockedUserBatch());
        System.debug('>>Scheduled new EvaluateLockedUserBatch() for time: ' + strSchedule);
    }

    private class CustomUserLogin{
        private Boolean isFrozen;
        private Boolean isPasswordLocked;
        private Id userId;

        public CustomUserLogin(Boolean isFrozen, Boolean isPasswordLocked, Id userId){
            this.isFrozen = isFrozen;
            this.isPasswordLocked = isPasswordLocked;
            this.userId = userId;
        }
    }
}

@isTest
private class EvaluateLockedUserBatchTest {

    @isTest
    private static void testFrozenUser(){
        List<User> listOfFrozenUser = new List<User>([SELECT Id, Status__c FROM User WHERE Status__c = 'Frozen']);
        Integer expected = 0;
        Integer actual = listOfFrozenUser.size();
        System.assertEquals(expected, actual, 'No user should be frozen.');

        /*
        * To test a schedulable, schedule a run in your test method using System.schedule(),
        * and wrap that call in Test.startTest() and Test.stopTest(). 
        * This will ensure that the scheduled job is finished when Test.stopTest() completes and the next line of code runs. 
        */ 
        Test.startTest();
            System.runAs(getUser()){
                Id jobId = executeBatchJob();
            }
        Test.stopTest();

        listOfFrozenUser = new List<User>([SELECT Id, Status__c FROM User WHERE Status__c = 'Frozen']);
        expected = 1;
        actual = listOfFrozenUser.size();
        System.assertEquals(expected, actual, 'Exactly one user should be frozen.');
    }

    @isTest
    private static void testLockedUser(){
        List<User> listOfFrozenUser = new List<User>([SELECT Id, Status__c FROM User WHERE Status__c = 'Locked']);
        Integer expected = 0;
        Integer actual = listOfFrozenUser.size();
        System.assertEquals(expected, actual, 'No user should be locked.');

        /*
        * To test a schedulable, schedule a run in your test method using System.schedule(),
        * and wrap that call in Test.startTest() and Test.stopTest(). 
        * This will ensure that the scheduled job is finished when Test.stopTest() completes and the next line of code runs. 
        */ 
        Test.startTest();
            System.runAs(getUser()){
                Id jobId = executeBatchJob();
            }
        Test.stopTest();

        listOfFrozenUser = new List<User>([SELECT Id, Status__c FROM User WHERE Status__c = 'Locked']);
        expected = 1;
        actual = listOfFrozenUser.size();
        System.assertEquals(expected, actual, 'Exactly one user should be locked.');
    }

    @isTest
    private static void testActiveUser(){
        List<User> listOfFrozenUser = new List<User>([SELECT Id, Status__c FROM User WHERE Status__c = 'Green']);
        Integer expected = 0;
        Integer actual = listOfFrozenUser.size();
        System.assertEquals(expected, actual, 'No user should be active.');

        /*
        * To test a schedulable, schedule a run in your test method using System.schedule(),
        * and wrap that call in Test.startTest() and Test.stopTest(). 
        * This will ensure that the scheduled job is finished when Test.stopTest() completes and the next line of code runs. 
        */ 
        Test.startTest();
            System.runAs(getUser()){
                Id jobId = executeBatchJob();
            }
        Test.stopTest();

        listOfFrozenUser = new List<User>([SELECT Id, Status__c FROM User WHERE Status__c = 'Green']);
        expected = 1;
        actual = listOfFrozenUser.size();
        System.assertEquals(expected, actual, 'Exactly one user should be active.');
    }

    private static User getUser(){
        User user = new User();
        user.LastName           = 'Heinz';
        user.Alias              = 'H1';
        user.Email              = 'H1@abc.de';
        user.Username           = user.Email;
        user.CommunityNickname  = 'Crazy ' + user.LastName;
        user.ProfileId          = getSystemAdministratorProfile().Id;
        user.EmailEncodingKey   = 'UTF-8'; 
        user.LanguageLocaleKey  = 'en_US';
        user.LocaleSidKey       = 'en_US';
        user.TimeZoneSidKey     = 'America/Los_Angeles';
        return user;
    }

    private static Profile getSystemAdministratorProfile(){
        List<String> listOfProfileName = new List<String>{ 'Systemadministrator', 'System Administrator' };
        return [SELECT Id FROM Profile WHERE Name IN :listOfProfileName LIMIT 1];
    }

    private static Id executeBatchJob(){
        //Reschedule Job after 15 minutes.
        Datetime dateTimee  = System.now().addMinutes(15);
        String day          = string.valueOf(dateTimee.day());
        String month        = string.valueOf(dateTimee.month());
        String hour         = string.valueOf(dateTimee.hour());
        String minute       = string.valueOf(dateTimee.minute());
        
        String schedule = '0 ' + minute + ' ' + hour + ' ' + day + ' ' + month + ' ?';
        Id jobId = System.schedule('>>>EvaluateLockedUserBatch', schedule, new EvaluateLockedUserBatch());

        return jobId;
    }
}