trigger SegmentTrigger on Segment__c (before insert, before update, before delete, after insert, after update, after delete, after undelete) {
	private static boolean didStandardSave = false;

	if (trigger.isAfter){
		// skip normal processing for already proecessed segments
		list<segment__c> toProcess = new list<segment__c>();
		if (trigger.isDelete){
			for (segment__c was : trigger.old){
				if ( !SegmentTriggerHandler.processedsegments.contains(was.id)) toProcess.add(was);
			}
		} else  {
			for (segment__c is : trigger.new){
				if ( !SegmentTriggerHandler.processedsegments.contains(is.id)) toProcess.add(is);
			} 
		}
		SegmentTriggerHandler.processSegments(toProcess);
	}
}

global with sharing class SegmentTriggerHandler {
    // public SegmentTriggerHandler() { }
    
    private static map<id, trip> trips = new map<id, trip>(); //map <parent id, trip>

    // the following is used to allow the expansion of the scope of records to updated while
    // preventing them from being processed when saved by falling through the After Trigger
    // and in doing so preventing recursion
    public static set<id> processedSegments = new set<id>();

    public static string query = 'select the needed fields from segment__c';

    public class trip {
        public id parentID {get;set;}
        public id contactID {get;set;}
        public map<integer, segment__c> segments {get;set;}
        trip(){
            parentID = null;
            contactID = null;
            segments = new map<integer, segment__c>(); // map<seq#, segment__c>
        }
    }

    public static void processSegments(list<segment__c> segments){
        if (segments == null || segments.size() == 0) return;
        trips = loadTrips(segments);
        for (trip t : trips.values()) {
            trips.put(t.parentID, reflowTrip(t));
        }
        saveTrips(trips);
        updateMapping();
    }

    public static trip reflowTrip(trip t){
        t = cleanOrder(t);
        t = updateContinues(t);
        return t;
    }

    public static trip cleanOrder(trip t){
        // smoothes and rationalizes the sequence of the segment numbers
        // so 1, 3, 4, 7 becomes 1, 2, 3, 4
        return t;
    }

    public static trip updateContinues(trip t){
        // since segments tend to start at the endpoint of the previous one, this method ensures
        // continuity after segments have been deleted, inserted, or the order has changed
        return t;
    }

    public static void saveTrips(map<id, trip> trips){
        if (trips == null || trips.size() == 0) return;
        list<segment__c> segs = new list<segment__c>();
        for (trip t : trips.values()){
            if (t.segments != null && t.segments.size() > 0) {
                for (segment__c s : t.segments.values()){
                    segs.add(s);

                    // the following enables all of the related segments to pass 
                    // through the trigger without being processed again
                    processedSegments.add(s.id);
                }
            }
        }
        update segs;
    }

    public static map<id, trip> loadTrips(list<segment__c> segments){
        // loads all related segments in the trips associated with those passed in from the trigger
        // returns map<parent id, trip>
        trips = new map<id, trip>();
        return trips;
    }

    @Future(callout=true)
    public static void updateMapping(){
        list<segment__c> segments = [select id, segment__c, From_composite__c, To_composite__c,
            from_name__c,to_name__c, Directions__c from segment__c
            where From_composite__c != null and To_composite__c != null];
        list<segment__c> toUpdate = new list<segment__c>();
        for (segment__c s : segments){

            // Directions is being used as a status flag. if they need to be updated the 
            // field is nulled out.
            // Below ensures only the segments needing directions are sent to Google.
            if ( !string.isblank(s.directions__c)) continue;
        googlemaps.turnByTurn dir = googlemaps.turnByTurn(s.from_composite__c, s.to_composite__c);
            segment__c u = new segment__c();
            u.id = s.id;
            u.Directions__c = dir.directions;
            toUpdate.add(u);
        }
        update toUpdate;
    }
}