/**
 * Description:   Added TriggerFactory to make sure qwe call each function only once

 */

trigger OrderTrigger on Order (after delete, after insert, after undelete, after update, before delete, before insert, before update) {
              
    TriggerFactory.getOrderService().execute();
    
}

public with sharing class OrderTriggerDispatcher extends TriggerDispatcher {
    
    public OrderTriggerService getService() {
            return (OrderTriggerService)this.svr;
        }
       
    public override void doAfterInsert(){
        this.getService().updateOrderUpgrade();
       
        
    }
      public override void doAfterUpdate(){
         this.getService().updateOrderUpgrade();
       
    }  
    public override void doBeforeUpdate(){
        this.getService().updateOrderUpgradeCancellationDate();
        this.getService().updateOpportunityStage();
       
    }
          
}

public with sharing class OrderTriggerService extends TriggerService {
    
    public void updateOrderUpgradeCancellationDate(){
        //Set<Id> setIds = new Set<Id>();
        Map<Id,Order> orderOldMap =(Map<Id,Order>)oldMap;
    DateTime dT = System.now();
    Date myDate = date.newinstance(dT.year(), dT.month(), dT.day());
       
        for (Order childObj : (List<Order>) newList) {
         if(childObj.Account_Record_Type_Name__c == 'Recipient' && childObj.Record_Type_Dev_Name__c == 'Upgrade_Order' && childObj.Status!=orderOldMap.get(childObj.Id).Status && childObj.Status=='Cancelled')  {
                    childObj.Order_Cancellation_Date__c=myDate;
             
         
           }
        }
          //System.debug('updateOrderUpgradeCancellationDate Order_Cancellation_Date__c: ' + Order_Cancellation_Date__c);
        System.debug(myDate);
        
    }
    
    /*
     * find the latest upgrade order under recipients and copy order value to account level
     */
    public void updateOrderUpgrade() {
        Set<Id> setIds = new Set<Id>();  
        for (Order childObj : (List<Order>) newList) {
            if(childObj.Account_Record_Type_Name__c == 'Recipient' && childObj.Record_Type_Dev_Name__c == 'Upgrade_Order'  ) {
                setIds.add(childObj.AccountId);
            }
        }
        System.debug('updateOrderUpgrade setIds: ' + setIds);
        
        if (setIds.isEmpty()) { return; }
        
        Map<ID, Account> parentAccts = new Map<Id, Account>(
                                          [select id, Upgrade_Order_Booked_Date__c, Upgrade_Order_Status__c, Order_Cancellation_Reason__c,Upgrade_Order_Number__c,Order_Cancellation_Date__c,
                                          (select id, Name, Booked_Date__c, Status ,Order_Cancellation_Reason__c,Oracle_Order_Number__c,Order_Cancellation_Date__c
                                            from Orders where Booked_Date__c != null order by Booked_Date__c desc limit 1) 
                                           from Account where id in :setIds]);
        System.debug('updateOrderUpgrade parentAccts: ' + parentAccts);
        
        // put account <-> latest order map value
        Map<Account, Order> accountToLatestOrder = new Map<Account, Order>();
        for (Account acc : parentAccts.values()) {
            if (acc.orders.isEmpty() == false) {
                accountToLatestOrder.put(acc, acc.orders[0]);
            }
        }
        System.debug('updateOrderUpgrade accountToLatestOrder: ' + accountToLatestOrder);
        
        Map<String, String> accFieldToOrderField = new Map<String, String>();
        
        accFieldToOrderField.put('Upgrade_Order_Booked_Date__c', 'Booked_Date__c');
        accFieldToOrderField.put('Upgrade_Order_Status__c', 'Status');
        accFieldToOrderField.put('Order_Cancellation_Reason__c','Order_Cancellation_Reason__c');
    accFieldToOrderField.put('Upgrade_Order_Number__c','Oracle_Order_Number__c');    
         accFieldToOrderField.put('Order_Cancellation_Date__c', 'Order_Cancellation_Date__c');
        
        Map<Id, Account> needUpdate = this.populateAccountFields(accountToLatestOrder, accFieldToOrderField);
        if (needUpdate.isEmpty() == false) { update needUpdate.values(); }
    }
 
    /*
     * if field is diff then copy field value from order to account based on field mapping
     */
    private Map<Id, Account> populateAccountFields(Map<Account, Order> accountToLatestOrder, Map<String, String> accFieldToOrderField) {
        Map<Id, Account> needUpdate = new Map<Id, Account>();
        
        for (Account acc : accountToLatestOrder.keySet()) {
            Order ord = accountToLatestOrder.get(acc);
            for (String accField : accFieldToOrderField.keySet()) {
                String orderField = accFieldToOrderField.get(accField);
                if (acc.get(accField) != ord.get(orderField)) {
                    acc.put(accField, ord.get(orderField));
                    needUpdate.put(acc.id, acc);
                }
            }
        }
        
        System.debug('populateAccountFields needUpdate: ' + needUpdate);
        return needUpdate;
    }
    
    
    // Update opps to Closed-Won/Closed-Lost based on Orders status changed Canceled/Closed and copy Oracle Order No from Orders to Opps
    public void updateOpportunityStage(){
        Set<Id> setIds = new Set<Id>();
        Map<Id,Order> orderOldMap =(Map<Id,Order>)oldMap;
        Map<Id,Order> orderNewMap=(Map<Id,Order>)newMap;
        Set<Opportunity>  updateOppties=new Set<Opportunity>();
        DateTime statusChange= System.now()-90;
        
        for (Order childObj : (List<Order>) newList) {
            if(childObj.Account_Record_Type_Name__c == 'Recipient' && childObj.Record_Type_Dev_Name__c == 'Upgrade_Order'){ 
            setIds.add(childObj.AccountId);
               
            }
        }
        if (setIds.isEmpty()) { return; }
        
        Map<ID, Account> parentAccts = new Map<Id, Account>(
                                          [select id, Upgrade_Order_Booked_Date__c, Upgrade_Order_Status__c, Order_Cancellation_Reason__c,Upgrade_Order_Number__c,Order_Cancellation_Date__c,
                                          (select id, Name, Booked_Date__c, Status ,Order_Cancellation_Reason__c,Oracle_Order_Number__c,Order_Cancellation_Date__c
                                            from Orders ) 
                                           from Account where id in :setIds]);
        System.debug('updateOrderUpgrade parentAccts: ' + parentAccts);
        
        Map<Account, Order> accountToLatestOrder = new Map<Account, Order>();
        for (Account acc : parentAccts.values()) {
            if (acc.orders.isEmpty() == false) {
                accountToLatestOrder.put(acc, acc.orders);
            }
        }
         
    
      for(Account acc : [select id, Upgrade_Order_Booked_Date__c, Upgrade_Order_Status__c, Order_Cancellation_Reason__c,Upgrade_Order_Number__c,Order_Cancellation_Date__c,
                         			(select Id,Name,closedate,amount,StageName,Oracle_Order_Number__c,Status_Last_Changed_On__c
                                     from opportunities where Record_Type_Dev_Name__c='Upgrade_Opportunity') 
                         			from Account where id in : setIds]){
                             
                             for(Order orders : accountToLatestOrder.values()){            
                             		for(Opportunity opps : acc.opportunities){
                                 		System.debug('orderOldMap.get(orders.Id): ' + orderOldMap.get(orders.Id));

                                 		//if(opps.StageName<>'Upgrade-Closed Won' && orders.Status!=orderOldMap.get(orders.Id).Status && orders.Status=='Cancelled'){
                                            if(opps.StageName <> 'Upgrade-Closed Won' && orderOldMap.get(orders.Id) != NULL // make sure the map entry exists
                                               && orders.Status!=orderOldMap.get(orders.Id).Status // THEN use it
                                               && orders.Status=='Cancelled'){
                                 		//if(opps.StageName<>'Upgrade-Closed Won' && orderNewMap.get(orders.Id).Status!=orderOldMap.get(orders.Id).Status && orderNewMap.get(orders.Id).Status=='Cancelled'){
                                                 opps.StageName='Upgrade - Closed Lost'; 
                                                 opps.Oracle_Order_Number__c=orders.Oracle_Order_Number__c;
                                                 
                                 		}
                               
                            	else if((opps.StageName<>'Upgrade-Closed Won'&&(opps.StageName=='Upgrade - Closed Lost' && opps.Status_Last_Changed_On__c>= statusChange))&& orders.Status!=orderOldMap.get(orders.Id).Status && orders.Status=='Closed'){                 		
                                    		opps.StageName='Upgrade-Closed Won';
                                    	 	opps.Oracle_Order_Number__c=orders.Oracle_Order_Number__c;
                                 }
                                 System.debug('updateOpportunityStage Opportunity: ' + opps);  
                    			updateOppties.add(opps);
                             }
                             }
                         }
        
         				List<Opportunity> updateopps=new List<Opportunity>(updateOppties);
        				update updateopps;
        			}
      }