/*
* The purpose of this class is to allow for access to and use of dependent picklists in Visualforce and/or Lightning pages. 
* Values for any picklist field in the UI are obtained simply from the Schema tables, but their relationship to any related
* controlling field are contained in a Base64 hash that needs to be deciphered to access and utilize.  
*/

public class DependentPicklistController {
    /*
	 * Method to convert the Base64 "validFor" values for dependent picklist options into actual text options
	 */
    
    public Map<String,List<String>> getOptions(String obj, String controllingField, String dependentField){
        
        // Base64 > Integer values Map
        
        Map<String, Integer> base64Codes = new Map<String,Integer> {
            'A' => 0,'B' => 1,'C' => 2,'D' => 3,'E' => 4,'F' => 5,'G' => 6,
            'H' => 7,'I' => 8,'J' => 9,'K' => 10,'L' => 11,'M' => 12,
            'N' => 13,'O' => 14,'P' => 15,'Q' => 16,'R' => 17,'S' => 18,
            'T' => 19,'U' => 20,'V' => 21,'W' => 22,'X' => 23,'Y' => 24,
            'Z' => 25,'a' => 26,'b' => 27,'c' => 28,'d' => 29,'e' => 30,
            'f' => 31,'g' => 32,'h' => 33,'i' => 34,'j' => 35,'k' => 36,
            'l' => 37,'m' => 38,'n' => 39,'o' => 40,'p' => 41,'q' => 42,
            'r' => 43,'s' => 44,'t' => 45,'u' => 46,'v' => 47,'w' => 48,
            'x' => 49,'y' => 50,'z' => 51,'0' => 52,'1' => 53,'2' => 54,
            '3' => 55,'4' => 56,'5' => 57,'6' => 58,'7' => 59,'8' => 60,
            '9' => 61,'+' => 62,'/' => 63};
                    
		// Get all values for the corresponding controlling and dependent fields
                
		Map<String,Schema.SObjectType> globalMap = Schema.getGlobalDescribe();
        Schema.SObjectType objectType = Schema.getGlobalDescribe().get(obj);
        Map<String, Schema.SObjectField> fieldMap = objectType.getDescribe().fields.getMap();
        
        Schema.DescribeFieldResult controllingFieldResults = fieldMap.get(controllingField).getDescribe();
        List<Schema.PicklistEntry> controllingPles = controllingFieldResults.getPicklistValues();
        
        Schema.DescribeFieldResult dependentFieldResults = fieldMap.get(dependentField).getDescribe();
        List<Schema.PicklistEntry> dependentPles = dependentFieldResults.getPicklistValues();
        
        List<PicklistEntryWrapper> dependentPleEntries = new List<PicklistEntryWrapper>();
        dependentPleEntries = (List<PicklistEntryWrapper>)JSON.deserialize(JSON.serialize(dependentPles), List<PicklistEntryWrapper>.class);
        
        Map<String,List<String>> binaryStrings = new Map<String,List<String>>();
        
        // Loop through the "validFor" values for each dependent picklist entry
        
        for(PicklistEntryWrapper dependentPle : dependentPleEntries){
            String base64Entry = dependentPle.validFor;
            Integer base64Length = base64Entry.length();
            String base64Value;
            Integer base64IntegerValue;
            Integer value32;
            Integer value16;
            Integer value8;
            Integer value4;
            Integer value2;
            Integer value1;
            String binaryString = '';
            List<String> binaryValues = new List<String>();
            
            // Loop through each value in the "validFor" data returned
            
            for(Integer i = 1; i <= base64Length; i++){
                
                // Get the Integer value for this "validFor" value in the loop using the Map above
                
                if(i < base64Length){
                    base64Value = base64Entry.subString(i-1,i);
                    base64IntegerValue = base64Codes.get(base64Value);
                }
                else{
                    base64Value = base64Entry.subString(i-1,base64Length);
                    base64IntegerValue = base64Codes.get(base64Value);
                }
                
                /* 
                 * Get Binary values for each integer; the statements below assign a value to each of the 6 bits in a Base64
                 * binary string; values of each bit in the 6-bit string are, from left to right, 32-16-8-4-2-1; the functions
                 * below determine whether the base64IntegerValue requires a 1 or a 0 in each bit position
                 */
                
                if(base64IntegerValue/32 >= 1){
                    value32 = 1;
                } 
                else{value32 = 0;}
                
                if((base64IntegerValue-(32*value32))/16 >= 1){
                    value16 = 1;
                } 
                else{value16 = 0;}
                
                if((base64IntegerValue-(32*value32)-(16*value16))/8 >= 1){
                    value8 = 1;
                } 
                else{value8 = 0;}
                
                if((base64IntegerValue-(32*value32)-(16*value16)-(8*value8))/4 >= 1){
                    value4 = 1;
                } 
                else{value4 = 0;}
                
                if((base64IntegerValue-(32*value32)-(16*value16)-(8*value8)-(4*value4))/2 >= 1){
                    value2 = 1;
                } 
                else{value2 = 0;}
                
                if((base64IntegerValue-(32*value32)-(16*value16)-(8*value8)-(4*value4)-(2*value2))/1 >= 1){
                    value1 = 1;
                } 
                else{value1 = 0;}
                
                // Add the string value of each bit value (0 or 1) as a list entry
                
                binaryValues.add(value32.format());
                binaryValues.add(value16.format());
                binaryValues.add(value8.format());
                binaryValues.add(value4.format());
                binaryValues.add(value2.format());
                binaryValues.add(value1.format());
            }
            
            // Add the complete set of binaryValues, the number of which is equivalent to the total number of controlling
            // field values, to a Map with the dependent picklist option as its key
            
            binaryStrings.put(dependentPle.label,binaryValues);
        }
        
        /* 
         * The final Map contains a key/value pair for each dependent picklist entry, the key being the label 
         * of the dependent picklist entry and the value being a list of 0's and 1's, which, when read from 
         * left to right, correspond to an "include" or "exclude" for the corresponding controlling value
         */ 
        
        Map<String,List<String>> optionsMap = new Map<String,List<String>>();
        
        for(Schema.PicklistEntry controllingOption : controllingPles){
            optionsMap.put(controllingOption.value,new List<String>());
        }
        
        for(String dependentOptionName : binaryStrings.keyset()){
            for(Integer i = 0; i < optionsMap.size(); i++){
                if(binaryStrings.get(dependentOptionName)[i] == '1'){
                    optionsMap.get(controllingPles[i].value).add(dependentOptionName);
                }
            }
        }
        
        return optionsMap;
    }
}