public with sharing class OpportunityStageHandler {
    
    public OpportunityStageHandler() {
    }

    public static void init(List<Opportunity> opportunities){
        
        String debug = 'Opportunity Stage Handler';
        
        insertOpportunityStageDurations(opportunities);
    }

    public static void insertOpportunityStageDurations(List<Opportunity> opportunities){

        List<Opportunity_Stage_Duration__c> existing = new List<Opportunity_Stage_Duration__c>();
        Map<Id, Opportunity_Stage_Duration__c> existingMap = new Map<Id, Opportunity_Stage_Duration__c>();
        Map<Id, String> existingStageMap = new Map<Id, String>();
        List<Opportunity_Stage_Duration__c> inserts = new List<Opportunity_Stage_Duration__c>();
        DateTime stageStart = DateTime.now();

        existing = [SELECT Id, 
                           Stage__c,
                           Stage_Started__c,
                           Stage_Ended__c,
                           Opportunity__r.Id
                    FROM Opportunity_Stage_Duration__c
                    WHERE Opportunity__c IN :opportunities
                    AND Stage_Ended__c = null];
        
        for(Opportunity_Stage_Duration__c opportunityStageDuration : existing){            
            existingMap.put(opportunityStageDuration.Opportunity__r.Id, opportunityStageDuration);
            existingStageMap.put(opportunityStageDuration.Opportunity__r.Id, opportunityStageDuration.Stage__c);
        }       
        
        for(Opportunity opportunity : opportunities){
            if(existingStageMap.get(opportunity.Id) == null || existingStageMap.get(opportunity.Id) != opportunity.StageName){
                Opportunity_Stage_Duration__c osd = new Opportunity_Stage_Duration__c();

                Integer stageLength = opportunity.StageName.length() + 3;
                Integer nameLength = opportunity.Name.length();

                if(stageLength + nameLength > 80){                    
                    Integer trim = stageLength + nameLength - 80;
                    Integer endIndex = nameLength - trim - 1;
                    osd.Name = (opportunity.Name.substring(0, endIndex)) + ' - ' + opportunity.StageName;
                }else{
                    osd.Name = opportunity.Name + ' - ' + opportunity.StageName;
                }
                
                osd.Opportunity__c = opportunity.Id;        
                osd.Stage_Started__c = stageStart;
                osd.Stage__c = opportunity.StageName;
                inserts.add(osd);
            }
        }

        insert inserts;

        updateOpportunityStageDurations(opportunities, existingMap);
    }

    public static void updateOpportunityStageDurations(List<Opportunity> opportunities,
                                                       Map<Id, Opportunity_Stage_Duration__c> existingMap){
        
        List<Opportunity_Stage_Duration__c> updates = new List<Opportunity_Stage_Duration__c>();
        DateTime stageEnded = DateTime.now();

        for(Opportunity opportunity : opportunities){
            if(existingMap.get(opportunity.Id) != null &&
               existingMap.get(opportunity.Id).Stage__c != opportunity.StageName){
                
                Opportunity_Stage_Duration__c osd = existingMap.get(opportunity.Id);

                osd.Stage_Ended__c = stageEnded;
                Date startDay = Date.newInstance(osd.Stage_Started__c.year(), osd.Stage_Started__c.month(), osd.Stage_Started__c.day());
                Date endDay = Date.newInstance(stageEnded.year(), stageEnded.month(), stageEnded.day());
                osd.Stage_Duration__c = startDay.daysBetween(endDay);
                updates.add(existingMap.get(opportunity.Id));
            }
        }

        update updates;
    }

}