//-- --------------------------------------------------------------------------------- --
//-- *
//-- Fichier     : TR_WorkOrderUpdateRules
//-- Modifie par : SOPRA STERIA
//-- Modifie le  : 16/10/2018
//-- Version     : 1.0
//-- * 1.0 - Init
//-- --------------------------------------------------------------------------------- --
public with sharing class TR_WorkOrderUpdateRules {

    /**
    * @description Règles de validation pour les interventions (ordres d'exécution)
    * @param newEvents Liste des interventions à vérifier
    */
    public static void applyUpdateRules(List<WorkOrder> newWorkOrders) {
        system.debug('### DEBUT TR_WorkOrderUpdateRules.applyUpdateRules');
        if (!Trigger.isExecuting)
            return;

        // Init
        Set<String> caseIds = new Set<String>();
        List<WorkOrder> interventions = [SELECT Id FROM WorkOrder ORDER BY CreatedDate DESC limit 1];
        Map<WorkOrder, String> workOrderUpdateCaseInd = new Map<WorkOrder, String>();
        Map<WorkOrder, String> caseWorkOrderMap = new Map<WorkOrder, String>();
        Map<Id, WorkOrder> oldWorkOrders = (Map<Id, WorkOrder>)Trigger.oldMap;

        System.debug('########## List newWorkOrders'+newWorkOrders);
        System.debug('########## query'+interventions[0]);
        try{
        /* A - Récupération de la liste des Ids */
        for(WorkOrder newWorkOrder : newWorkOrders) {
            WorkOrder oldWorkOrder = oldWorkOrders == null ? null : oldWorkOrders.get(newWorkOrder.id);
            if(String.isNotBlank(newWorkOrder.CaseId) && Trigger.isInsert && newWorkOrder.id == interventions[0].id)
                caseIds.add(newWorkOrder.CaseId);
            if(Trigger.IsUpdate && Trigger.IsAfter && String.isNotBlank(newWorkOrder.CaseId) && newWorkOrder.coutMainOeuvre__c != oldWorkOrder.coutMainOeuvre__c)
                caseWorkOrderMap.put(newWorkOrder, newWorkOrder.CaseId);
            if((Trigger.IsUpdate || Trigger.isDelete) && Trigger.IsAfter && newWorkOrder.id == interventions[0].id) {
                system.debug('########## newWorkOrder.interventionConcluante__c'+newWorkOrder.interventionConcluante__c);
                if(Trigger.IsUpdate && newWorkOrder.interventionConcluante__c == true && newWorkOrder.Status == 'Terminée')
                    workOrderUpdateCaseInd.put(newWorkOrder, 'concluante');
                if(Trigger.isDelete && newWorkOrder.interventionConcluante__c == true && newWorkOrder.Status == 'Terminée')
                    workOrderUpdateCaseInd.put(newWorkOrder, 'delete');
                }
        }

        if(!workOrderUpdateCaseInd.isEmpty())
            incrementCaseIndicators(workOrderUpdateCaseInd);
        if(!caseWorkOrderMap.isEmpty())
            calculateCoutMO(caseWorkOrderMap);

        /* B - SOQL - Récupération des informations */

        /* C - Traitement */
        } catch (Exception e) {
            system.debug('ERREUR # TR_OrderUpdateRules (' + e + ') ligne : ' + String.valueOf(e.getLineNumber()) + ' !');
            system.debug('ERREUR # Message ' + e.getMessage());
            throw e;
        }

        system.debug('### FIN TR_WorkOrderValidationRules.applyValidationRules');
    }

    public static void incrementCaseIndicators(Map<WorkOrder, String> newWorkOrders) {
        List<String> caseIds = new List<String>();
        List<Case> caseToUp = new List<Case>();
        Map<String, Case> cases = new Map<String, Case>();
        for(WorkOrder newWorkOrder : newWorkOrders.keySet()) {
            caseIds.add(newWorkOrder.CaseId);
        }
        if(!caseIds.isEmpty())
            cases = new Map<String, Case>([SELECT id, derniereInterventionConcluante__c FROM Case WHERE Id IN :caseIds]);

        for(WorkOrder newWorkOrder : newWorkOrders.keySet()) {
            Case caseWorkOrder = cases.get(newWorkOrder.CaseId);
            if(newWorkOrders.get(newWorkOrder) == 'concluante') {
                caseWorkOrder.derniereInterventionConcluante__c = true;
                caseToUp.add(caseWorkOrder);
            }
            if(newWorkOrders.get(newWorkOrder) == 'delete' && caseWorkOrder.derniereInterventionConcluante__c == true) {
                caseWorkOrder.derniereInterventionConcluante__c = false;
                caseToUp.add(caseWorkOrder);
            }
        }

        if(!caseToUp.isEmpty())
            update caseToUp;

    }

    public static void calculateCoutMO (Map<WorkOrder, String> caseWorkOrderMap) {
        List<Case> caseToUp = new List<Case>();

        // Modification de coutMO
        AggregateResult[] groupedResults = [SELECT CaseId, SUM(coutMainOeuvre__c)somme FROM WorkOrder
                                                WHERE CaseId IN :caseWorkOrderMap.values()
                                            GROUP BY CaseId];
        for(AggregateResult result : groupedResults) {
            Case ccc = new Case();
            ccc.Id = (String) result.get('CaseId');
            Decimal coutTtotal = (Decimal) result.get('somme');
            ccc.mainOeuvreTechnicien__c = (Decimal) result.get('somme');
            system.debug('### mainOeuvreTechnicien__c ' + ccc.mainOeuvreTechnicien__c);
            caseToUp.add(ccc);
        }

        if(!caseToUp.isEmpty())
            update caseToUp;

    }

    public class LapeyreException extends Exception {}
}