benchmarks/JetStream2/RexBench/FlightPlanner/flight_planner.js

/*
 * Copyright (C) 2017 Apple Inc. All rights reserved.
 * Copyright (C) 2016-2017 Michael Saboff. All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
 * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
 * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE INC. OR
 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
 * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
 */
"use strict";

let earthRadius = 3440; // In nautical miles.
let TwoPI = Math.PI * 2;
let degreeCharacter = "\u00b0";

let regExpOptionalUnicodeFlag;
var keywords;

if (this.useUnicode) {
    regExpOptionalUnicodeFlag = "u";
    keywords = UnicodeStrings;
} else {
    regExpOptionalUnicodeFlag = "";
    keywords = { get: function(str) { return str; } };
}

function status(text)
{
    console.debug("Status: " + text);
}

function error(text)
{
    console.error("Error: " + text);
}

if (typeof(Number.prototype.toRadians) === "undefined") {
    Number.prototype.toRadians = function() {
        return this * Math.PI / 180;
    }
}

if (typeof(Number.prototype.toDegrees) === "undefined") {
    Number.prototype.toDegrees = function() {
        return this * 180 / Math.PI;
    }
}

function distanceFromSpeedAndTime(speed, time)
{
    return speed * time.hours();
}

let LatRE = new RegExp("^([NS\\-])?(90|[0-8]?\\d)(?:( [0-5]?\\d\\.\\d{0,3})'?|(\\.\\d{0,6})|( ([0-5]?\\d)\" ?([0-5]?\\d)'?))?", "i" + regExpOptionalUnicodeFlag);

function decimalLatitudeFromString(latitudeString)
{
    if (typeof latitudeString != "string")
        return 0;

    let match = latitudeString.match(LatRE);

    if (!match)
        return 0;

    let result = 0;
    let sign = 1;

    if (match[1] && (match[1].toUpperCase() == "S" || match[1] == "-"))
        sign = -1;

    result = Number(match[2]);

    if (result != 90) {
        if (match[3]) {
            // e.g. N37 42.874
            let minutes = Number(match[3]);
            result = result + (minutes / 60);
        } else if (match[4]) {
            // e.g. N37.30697
            let decimalDegrees = Number(match[4]);
            result = result + decimalDegrees;
        } else if (match[5]) {
            // e.g. N37 18" 27'
            let degrees = Number(match[6]);
            let minutes = Number(match[7]);
            result = result + (degrees + minutes / 60) / 60;
        }
    }

    return result * sign;
}

let LongRE = new RegExp("^([EW\\-]?)(180|(?:1[0-7]|\\d)?\\d)(?:( [0-5]?\\d\\.\\d{0,3})|(\\.\\d{0,6})|( ([0-5]?\\d)\" ?([0-5]?\\d)'?)?)", "i" + regExpOptionalUnicodeFlag);

function decimalLongitudeFromString(longitudeString)
{
    if (typeof longitudeString != "string")
        return 0;

    let match = longitudeString.match(LongRE);

    if (!match)
        return 0;

    let result = 0;
    let sign = 1;

    if (match[1] && (match[1].toUpperCase() == "W" || match[1] == "-"))
        sign = -1;

    result = Number(match[2]);

    if (result != 180) {
        if (match[3]) {
            // e.g. W121 53.254
            let minutes = Number(match[3]);
            result = result + (minutes / 60);
        } else if (match[4]) {
            // e.g. W121.8876
            let decimalDegrees = Number(match[4]);
            result = result + decimalDegrees;
        } else if (match[5]) {
            // e.g. W121 53" 15'
            let degrees = Number(match[6]);
            let minutes = Number(match[7]);
            result = result + (degrees + minutes / 60) / 60;
        }
    }

    return result * sign;
}

let TimeRE = new RegExp("^([0-9][0-9]?)(?:\:([0-5][0-9]))?(?:\:([0-5][0-9]))?$");

class Time
{
    constructor(time)
    {
        if (time instanceof Date) {
            this._seconds = Math.Round(time.valueOf() / 1000);
            return;
        }

        if (typeof time == "string") {
            let match = time.match(TimeRE);

            if (!match) {
                this._seconds = 0;
                return;
            }

            if (match[3]) {
                let hours = parseInt(match[1].toString());
                let minutes = parseInt(match[2].toString());
                let seconds = parseInt(match[3].toString());

                this._seconds = (hours * 60 + minutes) * 60 + seconds;
            } else if (match[2]) {
                let minutes = parseInt(match[1].toString());
                let seconds = parseInt(match[2].toString());

                this._seconds = minutes * 60 + seconds;
            } else
                this._seconds = parseInt(match[1].toString());
            return;
        }

        if (typeof time == "number") {
            this._seconds = Math.round(time);
            return;
        }

        this._seconds = 0;
    }

    add(otherTime)
    {
        return new Time(this._seconds + otherTime._seconds);
    }

    addDate(otherDate)
    {
        return new Date(this._seconds * 1000 + otherDate.valueOf());
    }

    static differenceBetween(time2, time1)
    {
        let seconds1;
        let seconds2;
        if (time1 instanceof Time)
            seconds1 = time1.seconds();
        else
            seconds1 = Math.Round(time1.valueOf() / 1000);

        if (time2 instanceof Time)
            seconds2 = time2.seconds();
        else
            seconds2 = Math.Round(time2.valueOf() / 1000);

        return new Time(seconds2 - seconds1);
    }

    seconds()
    {
        return this._seconds;
    }

    minutes()
    {
        return this._seconds / 60;
    }

    hours()
    {
        return this._seconds / 3600;
    }

    toString()
    {
        let result = "";
        let seconds = this._seconds % 60;
        if (seconds < 0) {
            result = "-";
            seconds = -seconds;
        }
        let minutes = this._seconds / 60 | 0;
        let hours = minutes / 60 | 0;
        minutes = minutes % 60;

        if (hours)
            result = result + hours + ":";
        if (minutes < 10 && hours)
            result = result + "0";
        result = result + minutes + ":";
        if (seconds < 10)
            result = result + "0";
        result = result + seconds;

        return result;
    }
}

class GeoLocation
{
    constructor(latitude, longitude)
    {
        this.latitude = latitude;
        this.longitude = longitude;
    }

    latitudeString()
    {
        let latitude = this.latitude;
        let latitudePrefix = "N";
        if (latitude < 0) {
            latitude = -latitude;
            latitudePrefix = "S"
        }
        let latitudeDegrees = Math.floor(latitude);
        let latitudeMinutes = ((latitude - latitudeDegrees) * 60).toFixed(3);
        let latitudeMinutesFiller = latitudeMinutes < 10 ? " " : "";
        return latitudePrefix + latitudeDegrees + degreeCharacter + latitudeMinutesFiller + latitudeMinutes + "'";
    }

    longitudeString()
    {
        let longitude = this.longitude;
        let longitudePrefix = "E";
        if (longitude < 0) {
            longitude = -longitude;
            longitudePrefix = "W"
        }

        let longitudeDegrees = Math.floor(longitude);
        let longitudeMinutes = ((longitude - longitudeDegrees) * 60).toFixed(3);
        let longitudeMinutesFiller = longitudeMinutes < 10 ? " " : "";
        return longitudePrefix + longitudeDegrees + degreeCharacter + longitudeMinutesFiller + longitudeMinutes + "'";
    }

    distanceTo(otherLocation)
    {
        let dLat = (otherLocation.latitude - this.latitude).toRadians();
        let dLon = (otherLocation.longitude - this.longitude).toRadians();
        let a = Math.sin(dLat/2) * Math.sin(dLat/2) +
            Math.cos(this.latitude.toRadians()) * Math.cos(otherLocation.latitude.toRadians()) *
            Math.sin(dLon/2) * Math.sin(dLon/2);
        let c = 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1 - a));
        return earthRadius * c;
    }
    
    bearingFrom(otherLocation, magneticVariation)
    {
        if (magneticVariation == undefined)
            magneticVariation = 0;

        let dLon = (this.longitude - otherLocation.longitude).toRadians();
        let thisLatitudeRadians = this.latitude.toRadians();
        let otherLatitudeRadians = otherLocation.latitude.toRadians();
        let y = Math.sin(dLon) * Math.cos(this.latitude.toRadians());
        let x = Math.cos(otherLatitudeRadians) * Math.sin(thisLatitudeRadians) -
            Math.sin(otherLatitudeRadians) * Math.cos(thisLatitudeRadians) * Math.cos(dLon);
        return (Math.atan2(y, x).toDegrees() + 720 + magneticVariation) % 360;
    }

    bearingTo(otherLocation, magneticVariation)
    {
        if (magneticVariation == undefined)
            magneticVariation = 0;

        let dLon = (otherLocation.longitude - this.longitude).toRadians();
        let thisLatitudeRadians = this.latitude.toRadians();
        let otherLatitudeRadians = otherLocation.latitude.toRadians();
        let y = Math.sin(dLon) * Math.cos(otherLocation.latitude.toRadians());
        let x = Math.cos(thisLatitudeRadians) * Math.sin(otherLatitudeRadians) -
            Math.sin(thisLatitudeRadians) * Math.cos(otherLatitudeRadians) * Math.cos(dLon);
        return (Math.atan2(y, x).toDegrees() + 720 + magneticVariation) % 360
    }

    locationFrom(bearing, distance, magneticVariation)
    {
        if (magneticVariation == undefined)
            magneticVariation = 0;

        let bearingRadians = (bearing - magneticVariation).toRadians();
        let thisLatitudeRadians = this.latitude.toRadians();
        let angularDistance = distance / earthRadius;
        let latitudeRadians = Math.asin(Math.sin(thisLatitudeRadians) * Math.cos(angularDistance) +
                                 Math.cos(thisLatitudeRadians) * Math.sin(angularDistance) * Math.cos(bearingRadians));
        let longitudeRadians = this.longitude.toRadians() +
            Math.atan2(Math.sin(bearingRadians) * Math.sin(angularDistance) * Math.cos(thisLatitudeRadians),
                       Math.cos(angularDistance) - Math.sin(thisLatitudeRadians) * Math.sin(latitudeRadians));

        return new GeoLocation(latitudeRadians.toDegrees(), longitudeRadians.toDegrees());
    }

    toString()
    {
        return "(" + this.latitudeString() + ", " + this.longitudeString() + ")";
    }
}

function findFaaWaypoint(waypoint)
{
    return faaWaypoints[waypoint];
}

class FaaWaypoints
{
    constructor()
    {
        if (!FaaWaypoints.instance) {
            FaaWaypoints.instance = this;
            this.waypoints = _faaWaypoints;
        }

        return FaaWaypoints.instance;
    }

    find(waypoint)
    {
        return this.waypoints[waypoint];
    }
}

FaaWaypoints.instance = undefined;

let faaWaypoints = new FaaWaypoints();

class FaaAirways
{
    constructor()
    {
        if (!FaaAirways.instance) {
            FaaAirways.instance = this;
            this.airways = _faaAirways;
        }

        return FaaAirways.instance;
    }

    isAirway(identifier)
    {
        return !!this.airways[identifier];
    }

    resolveAirway(airwayID, entryPoint, exitPoint)
    {
        let airway = this.airways[airwayID];

        if (!airway)
            return "";

        let entryIndex = airway.fixes.indexOf(entryPoint);
        let exitIndex = airway.fixes.indexOf(exitPoint);

        if (entryIndex == -1 || exitIndex == -1)
            return "";

        let stride = (entryIndex <= exitIndex) ? 1 : -1;

        let route = [];

        for (let idx = entryIndex; idx != exitIndex; idx = idx + stride)
            route.push(airway.fixes[idx]);

        route.push(airway.fixes[exitIndex]);

        return route;
    }
}

FaaAirways.instance = undefined;

let faaAirways = new FaaAirways();

class UserWaypoints
{
    constructor()
    {
        if (!UserWaypoints.instance) {
            UserWaypoints.instance = this;
            this.waypoints = {};
        }

        return UserWaypoints.instance;
    }

    clear()
    {
        this.waypoints = {};
    }

    find(waypoint)
    {
        return this.waypoints[waypoint];
    }

    update(name, description, latitude, longitude)
    {
        if (typeof latitude == "string")
            latitude = decimalLatitudeFromString(latitude);

        if (typeof longitude == "string")
            longitude = decimalLongitudeFromString(longitude);

        this.waypoints[name.toUpperCase()] = {
            "name": name,
            "description": description,
            "latitude": latitude,
            "longitude": longitude
        };
    }
}

UserWaypoints.instance = undefined;

let userWaypoints = new UserWaypoints();


class EngineConfig
{
    constructor(type, fuelFlow, trueAirspeed)
    {
        this.type = type;
        this._fuelFlow = fuelFlow;
        this._trueAirspeed = trueAirspeed;
    }

    trueAirspeed()
    {
        return this._trueAirspeed;
    }

    fuelFlow()
    {
        return this._fuelFlow;
    }

    static appendConfig(type, fuelFlow, trueAirspeed)
    {
        if (this.allConfigsByType[type]) {
            status("Duplicate Engine configuration: " + type);
            return;
        }

        var newConfig = new EngineConfig(type, fuelFlow, trueAirspeed);
        this.allConfigs.push(newConfig);
        this.allConfigsByType[type] = newConfig;
    }

    static getConfig(n)
    {
        if (n >= this.allConfigs.length)
            return undefined;

        return this.allConfigs[n];
    }
}

EngineConfig.allConfigs = [];
EngineConfig.allConfigsByType = {};
EngineConfig.Taxi = 0;
EngineConfig.Runup = 1;
EngineConfig.Takeoff = 2;
EngineConfig.Climb = 3;
EngineConfig.Cruise = 4;
EngineConfig.Pattern= 5;

class Waypoint
{
    constructor(name, type, description, latitude, longitude)
    {
        this.name = name;
        this.type = type;
        this.description = description;
        this.latitude = latitude;
        this.longitude = longitude;
    }
}

class Leg
{
    constructor(fix, location)
    {
        this.previous = undefined;
        this.next = undefined;
        this.fix = fix;
        this.location = location;
        this.course = 0;
        this.distance = 0;
        this.trueAirspeed = 0;
        this.windDirection = 0;
        this.windSpeed = 0;
        this.heading = 0;
        this.estGS = 0;
        this.startFlightTiming = false;
        this.stopFlightTiming = false;
        this.engineConfig = EngineConfig.Cruise;
        this.fuelFlow = 0;
        this.distanceRemaining = 0;
        this.estimatedTimeEnroute = undefined;
        this.estTimeRemaining = 0;
        this.estFuel = 0;
    }

    fixName()
    {
        return this.fix;
    }

    toString()
    {
        return this.fix;
    }

    setPrevious(leg)
    {
        this.previous = leg;
    }

    previousLeg()
    {
        return this.previous;
    }

    setNext(leg)
    {
        this.next = leg;
    }

    nextLeg()
    {
        return this.next;
    }

    setWind(windDirection, windSpeed)
    {
        this.windDirection = windDirection;
        this.windSpeed = windSpeed;
    }

    isSameWind(windDirection, windSpeed)
    {
        return this.windDirection == windDirection && this.windSpeed == windSpeed;
    }

    windToString()
    {
        if (!this.windSpeed)
            return "";

        return (this.windDirection ? this.windDirection : "360") + "@" + this.windSpeed;
    }

    setTrueAirspeed(trueAirspeed)
    {
        this.trueAirspeed = trueAirspeed;
    }

    isStandardTrueAirspeed()
    {

        let engineConfig = EngineConfig.getConfig(this.engineConfig);

        return (this.trueAirspeed == engineConfig.trueAirspeed());
    }

    trueAirspeedToString()
    {
        return this.trueAirspeed + "kts";
    }

    updateDistanceAndBearing(other)
    {
        this.distance = this.location.distanceTo(other);
        this.course = Math.round(this.location.bearingFrom(other));
        if (this.estimatedTimeEnroute == undefined && this.estGS != 0) {
            let estimatedTimeEnrouteInSeconds = Math.round(this.distance * 3600 / this.estGS);
            this.estimatedTimeEnroute = new Time(estimatedTimeEnrouteInSeconds);
        }

        if (this.estimatedTimeEnroute.seconds())
            this.estFuel = this.fuelFlow * this.estimatedTimeEnroute.hours();
    }

    propagateWind()
    {
        let windDirection = this.windDirection;
        let windSpeed = this.windSpeed;

        windDirection = (windDirection + 360) % 360;
        if (!windDirection)
            windDirection = 360;

        for (let currLeg = this; currLeg; currLeg = currLeg.nextLeg()) {
            currLeg.windDirection = windDirection;
            currLeg.windSpeed = windSpeed;
            if (currLeg.stopFlightTiming)
                break;
        }
    }

    updateForWind()
    {
        if (!this.windSpeed || !this.trueAirspeed) {
            this.heading = this.course;
            this.estGS = this.trueAirspeed;
            return;
        }

        let windDirectionRadians = this.windDirection.toRadians();
        let courseRadians = this.course.toRadians();
        let swc = (this.windSpeed / this.trueAirspeed) * Math.sin(windDirectionRadians - courseRadians);
        if (Math.abs(swc) > 1) {
            status("Wind to strong to fly!");
            return;
        }

        let headingRadians = courseRadians + Math.asin(swc);
        if (headingRadians < 0)
            headingRadians += TwoPI;
        if (headingRadians > TwoPI)
            headingRadians -= TwoPI
        let groundSpeed = this.trueAirspeed * Math.sqrt(1 - swc * swc) -
            this.windSpeed * Math.cos(windDirectionRadians - courseRadians);
        if (groundSpeed < 0) {
            status("Wind to strong to fly!");
            return;
        }

        this.estGS = groundSpeed;
        this.heading = Math.round(headingRadians.toDegrees());
    }

    calculate()
    {
        let engineConfig = EngineConfig.getConfig(this.engineConfig);

        if (!this.trueAirspeed)
            this.trueAirspeed = engineConfig.trueAirspeed();
        this.fuelFlow = engineConfig.fuelFlow();

        this.updateForWind();
    }

    updateForward()
    {
        if (this.specialUpdateForward)
            this.specialUpdateForward();

        let previousLeg = this.previousLeg();
        let havePrevious = true;
        if (!previousLeg) {
            havePrevious = false;
            previousLeg = this;
            if (!this.estimatedTimeEnroute)
                this.estimatedTimeEnroute = new Time(0);
        }

        let thisLegType = this.type;
        if (thisLegType == "Climb" && havePrevious)
            this.location = previousLeg.location;
        else {
            this.updateDistanceAndBearing(previousLeg.location);
            this.updateForWind();
            let nextLeg = this.nextLeg();
            let previousLegType = previousLeg.type;
            if (havePrevious) {
                if (previousLegType == "Climb") {
                    let climbDistance = distanceFromSpeedAndTime(previousLeg.estGS, previousLeg.climbTime);
                    if (climbDistance < this.distance) {
                        let climbStartLocation = previousLeg.location;
                        let climbEndLocation = climbStartLocation.locationFrom(this.course, climbDistance);
                        previousLeg.location = climbEndLocation;
                        previousLeg.updateDistanceAndBearing(climbStartLocation);
                        this.estimatedTimeEnroute = undefined;
                        this.updateDistanceAndBearing(climbEndLocation);
                    } else {
                        status("Not enough distance to climb in leg #" + previousLeg.index);
                    }
                } else if ((thisLegType == "Left" || thisLegType == "Right") && nextLeg && nextLeg.location) {
                    let standardRateCircumference = this.trueAirspeed / 30;
                    let standardRateRadius = standardRateCircumference / TwoPI;
                    let offsetInboundBearing = 360 + previousLeg.course + (thisLegType == "Left" ? -90 : 90);
                    offsetInboundBearing = Math.round((offsetInboundBearing + 360) % 360);
                    // Save original location
                    if (!previousLeg.originalLocation)
                        previousLeg.originalLocation = previousLeg.location;
                    let previousLocation = previousLeg.originalLocation;
                    let inboundLocation = previousLocation.locationFrom(offsetInboundBearing, standardRateRadius);
                    let bearingToNext = Math.round(nextLeg.location.bearingFrom(previousLocation));
                    let offsetOutboundBearing = bearingToNext + (thisLegType == "Left" ? 90 : -90);
                    offsetOutboundBearing = (offsetOutboundBearing + 360) % 360;
                    let outboundLocation = previousLocation.locationFrom(offsetOutboundBearing, standardRateRadius);
                    let turnAngle = thisLegType == "Left" ? (360 + bearingToNext - previousLeg.course) : (360 + previousLeg.course - bearingToNext);
                    turnAngle = (turnAngle + 360) % 360;
                    let totalDegrees = turnAngle + 360 * this.extraTurns;
                    let secondsInTurn = Math.round(totalDegrees / 3);
                    this.estimatedTimeEnroute = new Time(Math.round((turnAngle + 360 * this.extraTurns) / 3));
                    this.estFuel = this.fuelFlow * this.estimatedTimeEnroute.hours();
                    this.location = outboundLocation;
                    this.distance = distanceFromSpeedAndTime(this.trueAirspeed, this.estimatedTimeEnroute);
                    previousLeg.location = inboundLocation;
                    let prevPrevLeg = previousLeg.previousLeg();
                    if (prevPrevLeg && prevPrevLeg.location) {
                        previousLeg.estimatedTimeEnroute = undefined;
                        previousLeg.updateDistanceAndBearing(prevPrevLeg.location);
                    }
                }
            }
        }
    }

    updateBackward()
    {
        let nextLeg = this.nextLeg();

        let distanceRemaining;
        let timeRemaining;

        if (nextLeg) {
            distanceRemaining = nextLeg.distanceRemaining;
            timeRemaining = nextLeg.estTimeRemaining;
        } else {
            distanceRemaining = 0;
            timeRemaining = new Time(0);
        }

        if (this.stopFlightTiming || timeRemaining.seconds()) {
            this.distanceRemaining = distanceRemaining + this.distance;;
            this.estTimeRemaining = timeRemaining.add(this.estimatedTimeEnroute);
        } else
            this.estTimeRemaining = new Time(0);
    }
}

let RallyLegWithFixRE = new RegExp("^([0-9a-z\.]{3,16})\\|(" + keywords.get("START") + "|" + keywords.get("TIMING") + ")", "i" + regExpOptionalUnicodeFlag);

class RallyLeg extends Leg
{
    constructor(type, fix, location, engineConfig)
    {
        super(fix, location);
        this.type = type;
        this.engineConfig = engineConfig;
    }

    fixName()
    {
        return this.type;
    }

    toString()
    {
        return this.fixName();
    }

    static reset()
    {
        RallyLeg.startLocation = undefined;
        RallyLeg.startFix = "";
        RallyLeg.totalTaxiTime = new Time(0);
        RallyLeg.taxiSegments = [];
    }

    static fixNeeded(fix)
    {
        let match = fix.match(RallyLegWithFixRE);

        if (!match)
            return "";

        return match[1].toString();
    }

    static getLegWithFix(waypointText, fix, location)
    {
        let match = waypointText.match(RallyLegWithFixRE);

        if (!match)
            return undefined;

        let legType = match[2].toString();

        if (legType == keywords.get("START")) {
            if (this.startLocation) {
                status("Trying to create second start leg");
                return undefined;
            }

            this.startLocation = location;
            this.startFix = fix;
            this.totalTaxiTime = new Time(0);
            this.taxiSegments = [];

            return new StartLeg(waypointText, fix, location);
        }

        if (legType == keywords.get("TIMING"))
            return new TimingLeg(waypointText, fix, location);


        error("Unhandled Rally Leg type " + legType);
        return undefined;
    }
}

RallyLeg.startLocation = undefined;
RallyLeg.startFix = "";
RallyLeg.totalTaxiTime = new Time(0);
RallyLeg.taxiSegments = [];

class StartLeg extends RallyLeg
{
    constructor(fixText, fix, location)
    {
        super("Start", fix, location, EngineConfig.Taxi);
    }

    fixName()
    {
        return this.fix + "|Start";
    }
}

class TimingLeg extends RallyLeg
{
    constructor(fixText, fix, location)
    {
        super("Timing", fix, location, EngineConfig.Cruise);
        this.stopFlightTiming = true;
    }

    fixName()
    {
        return this.fix + "|Timing";
    }
}

let RallyLegNoFixRE = new RegExp(keywords.get("TAXI") + "|" + keywords.get("RUNUP") + "|" + keywords.get("TAKEOFF") + "|" + keywords.get("CLIMB") + "|" + keywords.get("PATTERN") + "|" + keywords.get("LEFT") + "|" + keywords.get("RIGHT"), "i" + regExpOptionalUnicodeFlag);

class RallyLegWithoutFix extends RallyLeg
{
    constructor(type, CommentsAsFix, location, engineConfig)
    {
        super(type, CommentsAsFix, location, engineConfig);
    }

    setPrevious(previous)
    {
        if (this.setLocationFromPrevious() && previous)
            this.location = previous.location;

        super.setPrevious(previous);
    }

    setLocationFromPrevious()
    {
        return false;
    }

    static isRallyLegWithoutFix(fix)
    {
        let barPosition = fix.indexOf("|");
        let firstPart = barPosition < 0 ? fix : fix.substring(0, barPosition);

        return RallyLegNoFixRE.test(firstPart);
    }

    static getLegNoFix(waypointText)
    {
        let barPosition = waypointText.indexOf("|");
        let firstPart = barPosition < 0 ? waypointText : waypointText.substring(0, barPosition);
        firstPart = firstPart.toUpperCase();

        let match = firstPart.match(RallyLegNoFixRE);

        if (!match)
            return undefined;

        let legType = match[0].toString();

        if (legType == keywords.get("TAXI"))
            return new TaxiLeg(waypointText);

        if (legType == keywords.get("RUNUP"))
            return new RunupLeg(waypointText);

        if (legType == keywords.get("TAKEOFF")) {
            if (!this.startLocation) {
                status("Trying to create a Takeoff leg without start leg");
                return undefined;
            }

            return new TakeoffLeg(waypointText);
        }

        if (legType == keywords.get("CLIMB"))
            return new ClimbLeg(waypointText);

        if (legType == keywords.get("PATTERN"))
            return new PatternLeg(waypointText);

        if (legType == keywords.get("LEFT") || legType == keywords.get("RIGHT"))
            return new TurnLeg(waypointText, legType == keywords.get("RIGHT"));

        error("Unhandled Rally Leg type " + legType);
        return undefined;
    }
}

// TAXI[|<time>]  e.g. TAXI|2:30
let TaxiLegRE = new RegExp("^" + keywords.get("TAXI") + "(?:\\|([0-9][0-9]?(?:\:[0-5][0-9])?))?$", "i" + regExpOptionalUnicodeFlag);

class TaxiLeg extends RallyLegWithoutFix
{
    constructor(fixText)
    {
        let match = fixText.match(TaxiLegRE);

        super("Taxi", "", new GeoLocation(-1, -1), EngineConfig.Taxi);

        let taxiTimeString = "5:00";
        if (match[1])
            taxiTimeString = match[1].toString();

        this.estimatedTimeEnroute = new Time(taxiTimeString);
    }

    setLocationFromPrevious()
    {
        return true;
    }    

    fixName()
    {
        return "Taxi|" + this.estimatedTimeEnroute.toString();
    }
}

// RUNUP[|<time>]  e.g. RUNUP|0:30
let RunupLegRE = new RegExp("^" + keywords.get("RUNUP") + "(?:\\|([0-9][0-9]?(?:\:[0-5][0-9])?))?$", "i" + regExpOptionalUnicodeFlag);

class RunupLeg extends RallyLegWithoutFix
{
    constructor(fixText)
    {
        let match = fixText.match(RunupLegRE);

        super("Runup", "", new GeoLocation(-1, -1), EngineConfig.Runup);

        let runupTimeString = "30";
        if (match[1])
            runupTimeString = match[1].toString();

        this.estimatedTimeEnroute = new Time(runupTimeString);
    }

    setLocationFromPrevious()
    {
        return true;
    }    

    fixName()
    {
        return "Runup|" + this.estimatedTimeEnroute.toString();
    }
}

// TAKEOFF[|<time>][|<bearing>|<distance>]  e.g. TAKEOFF|2:00|270@3.5
let TakeoffLegRE = new RegExp("^" + keywords.get("TAKEOFF") + "(?:\\|([0-9][0-9]?(?:\:[0-5][0-9])?))?(?:\\|([0-9]{1,2}|[0-2][0-9][0-9]|3[0-5][0-9]|360)(?:@)(\\d{1,2}(?:\\.\\d{1,4})?))?$", "i" + regExpOptionalUnicodeFlag);

class TakeoffLeg extends RallyLegWithoutFix
{
    constructor(fixText)
    {
        let match = fixText.match(TakeoffLegRE);

        let bearingFromStart = 0;
        let distanceFromStart = 0;
        let takeoffEndLocation = RallyLeg.startLocation;
        if (match && match[2] && match[3]) {
            bearingFromStart = parseInt(match[2].toString()) % 360;
            distanceFromStart = parseFloat(match[3].toString());
            takeoffEndLocation = RallyLeg.startLocation.locationFrom(bearingFromStart, distanceFromStart);
        }

        super("Takeoff", "", takeoffEndLocation, EngineConfig.Takeoff);

        this.bearingFromStart = bearingFromStart;
        this.distanceFromStart = distanceFromStart;

        let takeoffTimeString = "2:00";
        if (match[1])
            takeoffTimeString = match[1].toString();

        this.estimatedTimeEnroute = new Time(takeoffTimeString);
        this.startFlightTiming = true;
    }

    fixName()
    {
        let result = "Takeoff";

        if (this.estimatedTimeEnroute.seconds() != 120)
            result += "|" + this.estimatedTimeEnroute.toString();
        if (this.distanceFromStart)
            result += "|" + this.bearingFromStart + "@" + this.distanceFromStart;

        return result;
    }
}

// CLIMB|<alt>|<time>  e.g. CLIMB|5000|7:00
let ClimbLegRE = new RegExp("^" + keywords.get("CLIMB") + "(?:\\|)(\\d{3,5})(?:\\|([0-9][0-9]?(?:\:[0-5][0-9])?))$", "i" + regExpOptionalUnicodeFlag);

class ClimbLeg extends RallyLegWithoutFix
{
    constructor(fixText)
    {
        let match = fixText.match(ClimbLegRE);

        let altitude = 5500;
        if (match && match[1])
            altitude = match[1].toString();

        super("Climb", altitude + "\"", undefined, EngineConfig.Climb);

        let timeToClimb = "8:00";
        if (match && match[2])
            timeToClimb = match[2].toString();

        this.altitude = altitude;
        this.climbTime = this.estimatedTimeEnroute = new Time(timeToClimb);
    }

    setLocationFromPrevious()
    {
        return true;
    }    

    fixName()
    {
        return "Climb|" + this.altitude + "|" + this.estimatedTimeEnroute.toString();
    }
}

// PATTERN|<time>  e.g. PATTERN|0:30
let PatternLegRE = new RegExp("^" + keywords.get("PATTERN") + "(?:\\|([0-9][0-9]?(?:\:[0-5][0-9])?))$", "i" + regExpOptionalUnicodeFlag);

class PatternLeg extends RallyLegWithoutFix
{
    constructor(fixText)
    {
        super("Pattern", "", undefined, EngineConfig.Pattern);

        let match = fixText.match(PatternLegRE);
        let patternTimeString = match[1].toString();
        this.estimatedTimeEnroute = new Time(patternTimeString);
    }

    setLocationFromPrevious()
    {
        return true;
    }    

    fixName()
    {
        return "Pattern|" + this.estimatedTimeEnroute.toString();
    }
}

// {LEFT,RIGHT}[|+<extra_turns>]  e.g. LEFT|2
let TurnLegRE = new RegExp("^(" + keywords.get("LEFT") + "|" + keywords.get("RIGHT") + ")(?:\\|\\+(\\d))?$", "i");

class TurnLeg extends RallyLegWithoutFix
{
    constructor(fixText, isRightTurn)
    {
        let match = fixText.match(TurnLegRE);

        let direction = "Left";
        if (match && match[1])
            direction = match[1].toString().toUpperCase() == keywords.get("LEFT") ? "Left" : "Right";

        let engineConfig = EngineConfig.Cruise;

        super(direction, "", new GeoLocation(-1, -1), engineConfig);

        this.extraTurns = (match && match[2]) ? parseInt(match[2]) : 0;
    }

    fixName()
    {
        let result = this.type;
        if (this.extraTurns)
            result += ("|+" + this.extraTurns);

        return result;
    }
}

let LegModifier = new RegExp("(360|3[0-5][0-9]|[0-2][0-9]{2}|[0-9]{1,2})@([0-9]{1,3})|([1-9][0-9]{1,2}|0)kts", "i");

class FlightPlan
{
    constructor(name, route)
    {
        this._name = name;
        this._route = route;
        this._firstLeg = undefined;
        this._lastLeg = undefined;
        this._legCount = 0;
        this._defaultWindDirection = 0;
        this._defaultWindSpeed = 0;
        this._trueAirspeedOverride = 0;
        this._timeToGate = undefined;
        this._estimatedTimeEnroute = undefined;
        this._totalFuel = 0;
        this._totalTime = new Time();
        this._gateTime = new Time();

        RallyLeg.reset();   //  Refactor to make this more OO
    }

    clear()
    {
    }

    appendLeg(leg)
    {
        if (!this._firstLeg)
            this._firstLeg = leg;
        if (this._lastLeg)
            this._lastLeg.setNext(leg);
        leg.setPrevious(this._lastLeg);
        leg.setNext(undefined);

        if (this._trueAirspeedOverride) {
            leg.setTrueAirspeed(this._trueAirspeedOverride);
            this.clearTrueAirspeedOverride(0);
        }

        if (this._defaultWindSpeed)
            leg.setWind(this._defaultWindDirection, this._defaultWindSpeed);

        this._lastLeg = leg;
        this._legCount++;
    }

    setDefaultWind(windDirection, windSpeed)
    {
        this._defaultWindDirection = windDirection;
        this._defaultWindSpeed = windSpeed;
    }

    clearTrueAirspeedOverride()
    {
        this._trueAirspeedOverride = 0;
    }

    setTrueAirspeedOverride(trueAirspeed)
    {
        this._trueAirspeedOverride = trueAirspeed;
    }

    isLegModifier(fix)
    {
        return LegModifier.test(fix);
    }

    processLegModifier(fix)
    {
        let match = fix.match(LegModifier);

        if (match) {
            if (match[1] && match[2]) {
                let windDirection = parseInt(match[1].toString()) % 360;
                let windSpeed = parseInt(match[2].toString());

                this.setDefaultWind(windDirection, windSpeed);
            } else if (match[3]) {
                let trueAirspeed = parseInt(match[3].toString());
                this.setTrueAirspeedOverride(trueAirspeed);
            }
        }
    }

    resolveWaypoint(waypointText)
    {
        if (this.isLegModifier(waypointText))
            this.processLegModifier(waypointText);
        else if (RallyLegWithoutFix.isRallyLegWithoutFix(waypointText)) {
            let rallyLeg = RallyLegWithoutFix.getLegNoFix(waypointText);
            if (rallyLeg)
                this.appendLeg(rallyLeg);
        } else {
            let fixName = RallyLeg.fixNeeded(waypointText);
            let isRallyWaypoint = false;

            if (fixName)
                isRallyWaypoint = true;
            else
                fixName = waypointText;

            let waypoint = userWaypoints.find(fixName);
            if (!waypoint)
                waypoint = faaWaypoints.find(fixName);
            if (!waypoint) {
                error("Couldn't find waypoint \"" + waypointText + "\"");
                return;
            }

            let location = new GeoLocation(waypoint.latitude, waypoint.longitude);

            if (isRallyWaypoint) {
                let rallyLeg = RallyLeg.getLegWithFix(waypointText, fixName, location);
                this.appendLeg(rallyLeg);
            } else
                this.appendLeg(new Leg(waypoint.name, location));
        }
    }

    parseRoute()
    {
        let waypointsToLookup = this._route.split(/ +/);
        let priorWaypoint = "";

        for (let waypointIndex = 0; waypointIndex < waypointsToLookup.length; waypointIndex++) {
            let currentWaypoint = waypointsToLookup[waypointIndex].toUpperCase();
            if (faaAirways.isAirway(currentWaypoint) && (waypointIndex + 1) < waypointsToLookup.length) {
                let exitWaypointFix = waypointsToLookup[waypointIndex + 1];
                let airwayFixes = faaAirways.resolveAirway(currentWaypoint, priorWaypoint, exitWaypointFix);

                // We skip the entry and exit fixes, because they are handled in the prior / next
                // iterations of the outer loop.
                for (let airwayFixIndex = 1; airwayFixIndex < airwayFixes.length - 1; airwayFixIndex++)
                    this.resolveWaypoint(airwayFixes[airwayFixIndex]);
            } else
                this.resolveWaypoint(currentWaypoint);
            
            priorWaypoint = currentWaypoint;
        }
    }

    calculate()
    {
        if (!this._firstLeg)
            return;

        let haveStartTiming = false;
        let haveStopTiming = false;
        for (let thisLeg = this._firstLeg; thisLeg; thisLeg = thisLeg.nextLeg()) {
            thisLeg.calculate();
            if (thisLeg.startFlightTiming) {
                if (haveStartTiming)
                    status("Have duplicate Start timing leg in row " + thisLeg.toString());
                haveStartTiming = true;
            }
            if (thisLeg.stopFlightTiming) {
                if (haveStopTiming)
                    status("Have duplicate Timing leg in row " + thisLeg.toString());
                haveStopTiming = true;
            }
        }

        if (!haveStartTiming)
            this._firstLeg.startFlightTiming = true;
        if (!haveStopTiming)
            this._lastLeg.stopFlightTiming = true;

        for (let thisLeg = this._firstLeg; thisLeg; thisLeg = thisLeg.nextLeg())
            thisLeg.updateForward();

        for (let thisLeg = this._lastLeg; thisLeg; thisLeg = thisLeg.previousLeg())
            thisLeg.updateBackward();

        for (let thisLeg = this._firstLeg; thisLeg; thisLeg = thisLeg.nextLeg()) {
            if (thisLeg.startFlightTiming)
                this._gateTime = thisLeg.estTimeRemaining;
        }

        this._totalTime = this._firstLeg.estTimeRemaining;
    }

    resolvedRoute()
    {
        let result = "";
        let lastWindDirection = 0;
        let lastWindSpeed = 0;

        let legIndex = 0;
        let currentLeg = this._firstLeg;
        
        for (; currentLeg; currentLeg = currentLeg.nextLeg(), legIndex++) {

            if (legIndex)
                result = result + " ";

            if (!currentLeg.isSameWind(lastWindDirection, lastWindSpeed)) {
                result = result + currentLeg.windToString() + " ";
                lastWindDirection = currentLeg.windDirection;
                lastWindSpeed = currentLeg.windSpeed;
            }

            if (!currentLeg.isStandardTrueAirspeed())
                result = result + currentLeg.trueAirspeedToString() + " ";

            result = result + currentLeg.toString();
        }

        return result;
    }

    name()
    {
        return this._name;
    }

    totalTime()
    {
        return this._totalTime;
    }
    
    gateTime()
    {
        return this._gateTime;
    }
    
    toString()
    {
        let result = "";
        let lastWindDirection = 0;
        let lastWindSpeed = 0;

        let legIndex = 0;
        let currentLeg = this._firstLeg;
        
        for (; currentLeg; currentLeg = currentLeg.nextLeg(), legIndex++) {

            if (legIndex)
                result = result + " ";

            if (!currentLeg.isSameWind(lastWindDirection, lastWindSpeed)) {
                result = result + currentLeg.windToString() + " ";
                lastWindDirection = currentLeg.windDirection;
                lastWindSpeed = currentLeg.windSpeed;
            }

            if (!currentLeg.isStandardTrueAirspeed())
                result = result + currentLeg.trueAirspeedToString() + " ";

            result = result + currentLeg.toString();
            result = result + " " + currentLeg.location + " " + currentLeg.distance.toFixed(2) + "nm " + currentLeg.estGS.toFixed(2) + "kts " + currentLeg.estimatedTimeEnroute + " ";
        }

        if (this._gateTime)
            result = result + " gate time " + this._gateTime;

        result = result + " total time " + this._firstLeg.estTimeRemaining;
        return result;
    }
}

EngineConfig.appendConfig("Taxi", 2, 0);
EngineConfig.appendConfig("Runup", 8, 0);
EngineConfig.appendConfig("Takeoff", 27, 105);
EngineConfig.appendConfig("Climb", 22, 125);
EngineConfig.appendConfig("Cruise", 15, 142);
EngineConfig.appendConfig("Pattern", 11, 95);

class ExpectedFlightPlan
{
    constructor(name, route, expectedRoute, expectedTotalTime, expectedGateTime)
    {
        this._name = name;
        this._route = route;
        this._expectedRoute = expectedRoute;
        this._expectedTotalTime = expectedTotalTime;
        this._expectedGateTime = expectedGateTime;
    }

    reset()
    {
        this._flightPlan = new FlightPlan(this._name, this._route);
    }

    resolveRoute()
    {
        this._flightPlan.parseRoute();
    }

    calculate()
    {
        this._flightPlan.calculate();
    }

    checkExpectations()
    {
        if (this._expectedRoute) {
            let computedRoute = this._flightPlan.resolvedRoute();
            if (this._expectedRoute != computedRoute)
                error("Flight plan " + this._flightPlan.name() + " route different than expected (\"" +
                      this._expectedRoute + "\"), got (\"" + computedRoute + "\")");
        }

        if (this._expectedTotalTime) {
            let computedTotalTime = this._flightPlan.totalTime();
            let deltaTime = Math.abs(Time.differenceBetween(this._expectedTotalTime, computedTotalTime).seconds());
            if (deltaTime > 5)
                error("Flight plan " + this._flightPlan.name() + " total time different than expected (" +
                      this._expectedTotalTime + "), got (" + computedTotalTime + ")");
        }

        if (this._expectedGateTime) {
            let computedGateTime = this._flightPlan.gateTime();
            let deltaTime = Math.abs(Time.differenceBetween(this._expectedGateTime, computedGateTime).seconds());
            if (deltaTime > 5)
                error("Flight plan " + this._flightPlan.name() + " gate time different than expected (" +
                      this._expectedGateTime + "), got (" + computedGateTime + ")");
        }
    }
}

function setupUserWaypoints()
{
    userWaypoints.clear();   
    userWaypoints.update("Oilcamp", "Oil storage in the middle of no where", "36.68471", "-120.50277");
    userWaypoints.update("I5.Westshields", "I5 & West Shields", "36.77774", "-120.72426");
    userWaypoints.update("I5.165", "Intersection of I5 and CA165", "36.93022", "-120.84068");
    userWaypoints.update("I5.VOLTA", "I5 & Volta Road", "37.01419", "-120.92878");
    userWaypoints.update("PT.ALPHA", "Intersection of I5 and CA152", "37.05665", "-120.96990");
    userWaypoints.update("Jellysferry", "Jelly's Ferry bridge across Sacramento River", "N40 19.037", "W122 11.359");
    userWaypoints.update("Howie", "RDD Timing Point", "N40 21.893", "W122 13.042");
    userWaypoints.update("Hale", "2014 Leg 1 Timing", "N39 33.621", "W119 14.438");
    userWaypoints.update("Winnie", "2014 Leg 2 Timing", "N40 50.499", "W114 12.595");
    userWaypoints.update("WindRiver", "2014 Leg 3 Timing", "N42 43.733", "W108 38.800");
    userWaypoints.update("Buff", "2014 Leg 4 Timing", "N43 59.455", "W103 16.171");
    userWaypoints.update("Omega", "2014 Leg 5 Timing", "N44 53.388", "W95 38.935");
    userWaypoints.update("Paul", "2014 Leg 6 Timing", "N43 22.027", "W89 37.111");
    userWaypoints.update("MicrowaveSt", "2014 Microwave Station", "N40 24.89", "W117 12.37");
    userWaypoints.update("RanchTower", "2014 Ranch/Tower", "N41 6.16", "W115 5.43");
    userWaypoints.update("FremontIsland", "2014 Fremont Island", "N41 10.49", "W112 20.64");
    userWaypoints.update("Tremonton", "2014 Tremonton", "N41 42.86", "W112 11.05");
    userWaypoints.update("RandomPoint", "2014 Random Point", "N42", "W111 03");
    userWaypoints.update("Farson", "2014 Farson", "N42 6.40", "W109 26.95");
    userWaypoints.update("Midwest", "2014 Midwest", "N43 24.49", "W109 16.68");
    userWaypoints.update("Bill", "2014 Bill", "N43 13.96", "W105 15.60");
    userWaypoints.update("MMNHS", "2014 MMNHS", "N43 52.67", "W101 57.65");
    userWaypoints.update("Tracks", "2014 Tracks", "N44 21", "W100 22");
    userWaypoints.update("Towers", "2014 Towers", "N43 34.25", "W92 25.64");
    userWaypoints.update("IsletonBridge", "Isleton Bridge", "N38 10.32", "W121 35.62");
    userWaypoints.update("Mystery15", "2015 Mystery", "N38 46.22", "W122 34.25");
    userWaypoints.update("Paskenta", "Paskenta Town", "N39 53.13", "W122 32.36");
    userWaypoints.update("Bonanza", "Bonanza Town", "N42 12.15", "W121 24.53");
    userWaypoints.update("Silverlake", "Silverlake", "N43 07.41", "W121 03.74");
    userWaypoints.update("Millican", "Bend Timing Start", "N43 52.75", "W120 55.13");
    userWaypoints.update("Goering", "Bend Timing", "N44 05.751", "W120 56.834");
    userWaypoints.update("Constantia2", "Our Constantia Wpt", "N39 56.068", "W120 0.831");
    userWaypoints.update("Hallelujah2", "Reno Timing", "N39 46.509", "W120 2.336");
    userWaypoints.update("Redding.Pond", "Pond 6nm North of KRDD", "N40 36", "W122 17");
    userWaypoints.update("Thunderhill", "Thunder Hill Race Track", "N39 32.36", "W122 19.83");
    userWaypoints.update("CascadeHighway", "Cascade Wonderland Highway", "N40 46.63", "W122 19.12");
    userWaypoints.update("Eagleville", "Eagleville closed airport", "N41 18.73", "W120 3.00");
    userWaypoints.update("DuckLakePass", "Saddle near Duck Lake", "N41 3.00", "W120 3.00");
}

function createTestRoutes()
{
    let flightPlans = [
        { name: "Rally Practice 1", route: "C83|Start Taxi|6:00 Runup|0:30 Taxi|1:00 Takeoff Climb|5500|5:00 CA67 0CN1 28CA 126kts I5.165 PT.ALPHA KLSN|Timing Pattern|0:45 Taxi|2:00" },
        { name: "Rally Practice 2", route: "C83|Start Taxi|6:00 Runup|0:30 Taxi|1:00 Takeoff Climb|5500|5:00 ECA 343@4 5CL3 67CA 314@12 126kts I5.165 126kts PT.ALPHA|Timing  126kts KLSN Pattern|0:45 Taxi|2:00" },
        { name: "Rally Practice 3", route: "KTCY|Start Taxi|6:00 Runup|0:30 Taxi|1:00 Takeoff Climb|3500|5:00 O27 67CA OILCAMP I5.WESTSHIELDS I5.165 I5.VOLTA PT.ALPHA|Timing KLSN Pattern|0:45 Taxi|2:00" },
        { name: "Rally Practice 4", route: "C83|Start Taxi|6:00 Runup|0:30 Taxi|1:00 Takeoff Climb|5500|5:00 62@3 9CL0 342@9 CL84 28CA 315@10 126kts I5.165 126kts PT.ALPHA|Timing  126kts KLSN Pattern|0:45 Taxi|2:00" },
        { name: "Rally Practice 5", route: "C83|Start Taxi|6:00 Runup|0:30 Taxi|1:00 Takeoff Climb|5500|7:00 O27 9CL0 CL01 I5.165 PT.ALPHA KLSN Pattern|0:45 Taxi|2:00" },
        { name: "2014 HWD Rally Leg 1", route: "KHWD|Start Taxi|6:00 Runup|0:30 Taxi|1:00 Takeoff Climb|5500|4:35 VPDUB Climb|8500|6:25 2CL9 Left|+1 09CL Left|+1 O02 Left|+1 77NV Left 126kts HALE|Timing KSPZ Pattern|0:45 Taxi|2:00"},
        { name: "2014 HWD Rally Leg 2", route: "KSPZ|Start Taxi|4:00 Runup|0:30 Taxi|1:00 Takeoff Climb|7500|9:00 NV30 Left MicrowaveSt Left DOBYS Left RanchTower Left 126kts Winnie|Timing KENV Pattern|0:45 Taxi|2:00"},
        { name: "2014 HWD Rally Leg 3", route: "KENV|Start Taxi|5:00 Runup|0:30 Taxi|1:00 Takeoff Climb|7500|8:30 FremontIsland Left|+1 Tremonton Left|+1 RandomPoint Left|+1 Farson Left 126kts WindRiver|Timing KLND Pattern|0:45 Taxi|2:00"},
        { name: "2014 HWD Rally Leg 4", route: "KLND|Start Taxi|6:00 Runup|0:30 Taxi|1:00 Takeoff Climb|7500|10:00 Midwest Left Bill Right|+1 WY09 Left KCUT Left 126kts BUFF|Timing KRAP Pattern|0:45 Taxi|2:00"},
        { name: "2014 HWD Rally Leg 5", route: "KRAP|Start Taxi|5:00 Runup|0:30 Taxi|3:00 Takeoff Climb|7500|9:00 MMNHS Left|+1 Tracks Left|+1 8D7 Left 5H3 Left 126kts Omega KMVE Pattern|0:45 Taxi|2:00"},
        { name: "2014 HWD Rally Leg 6", route: "KMVE|Start Taxi|6:00 Runup|0:30 Taxi|2:00 Takeoff Climb|5500|6:00 1D6 Left 68Y Right|+1 Towers Left KCHU Left 126kts Paul|Timing KMSN Pattern|0:45 Taxi|2:00"},
        { name: "2015 HWD Rally Leg 1", route: "KHWD|Start Taxi|6:00 Runup|0:30 Taxi|1:00 Takeoff Climb|5500|4:35 VPDUB Climb|5500|3:25 IsletonBridge Mystery15 Left|+1 71CL Left|+1 Paskenta Left|+1 O37 Left|+1 JELLYSFERRY HOWIE|Timing KRDD Pattern|0:45 Taxi|2:00"},
        { name: "2015 HWD Rally Leg 2", route: "KRDD|Start Taxi|6:00 Runup|0:30 Taxi|2:00 Takeoff Climb|8500|1:20 REDDING.POND Climb|8500|7:40 A26 O81 Left 340@6 Bonanza Left|+1 Silverlake Left|+1 Millican 126kts Goering|Timing KBDN pattern|30 taxi|2:00"},
        { name: "2016 HWD Rally Leg 1", route: "KHWD|Start Taxi|6:00 Runup|0:30 Taxi|1:00 Takeoff Climb|5500|4:35 VPDUB Climb|5500|3:25 65CN 3CN7 57CN Left|+1 2CL1 Left|+1 O37 Left|+1 JELLYSFERRY HOWIE|Timing KRDD Pattern|0:45 Taxi|2:00"},
        { name: "2016 HWD Rally Leg 2", route: "KRDD|Start Taxi|6:00 Runup|0:30 Taxi|2:00 Takeoff Climb|8500|1:20 REDDING.POND Climb|8500|7:40 O89 KAAT Left 1Q2 KSVE Left H37 Left CONSTANTIA2 HALLELUJAH2|Timing KRTS pattern|30 taxi|2:00"},
        { name: "2017 HWD Rally Leg 1", route: "KHWD|Start Taxi|6:00 Runup|0:30 Taxi|1:00 Takeoff Climb|4500|8:00 10@6 9CL9 63CL THUNDERHILL 60@10 90CL 0O4 350@10 126kts JELLYSFERRY 126kts HOWIE|Timing KRDD Pattern|0:45 Taxi|4:00" },
        { name: "2017 HWD Rally Leg 2", route: "KRDD|Start Taxi|6:00 Runup|0:30 Taxi|2:00 Takeoff Climb|8500|6:40 CASCADEHIGHWAY Climb|8500|8:20 KLKV 210@2 EAGLEVILLE DUCKLAKEPASS 210@5 O39 209@8 AHC 148@6 126kts CONSTANTIA2 126kts Hallelujah2|Timing KRTS Pattern|0:30 Taxi|2:00" },
        { name: "San Jose to San Diego", route: "KSJC LICKE SNS V25 REDIN KMYF" },
        { name: "San Diego to San Jose", route: "KMYF JOPDO CARIF V23 LAX V299 VTU V25 PRB SARDO RANCK V485 LICKE KSJC" },
        { name: "San Jose to Renton", route: "KSJC SUNOL RBL V23 SEA KRNT" },
        { name: "Renton to Willows", route: "KRNT SEA V495 BTG V23 RBL KWLW" },
        { name: "SJC to SEA #1", route: "ksjc sunol 135kts 300@12 rdd 0kts pdx ksea" },
        { name: "SJC to SEA #2", route: "KSJC SJC V334 SAC V23 BTG V495 SEA KSEA" },
        { name: "SJC to SEA #3", route: "KSJC SJC V334 SAC V23 FJS V495 SEA KSEA" },
        { name: "Roseburg to San Jose", route: "KRBG RBG KOLER V495 FJS V23 RBL SUNOL KSJC" },
        { name: "SAN to DEN", route: "KSAN HAILE V514 LYNSY V8 JNC V134 BINBE KDEN" },
        { name: "Denver to Minneapolis", route: "KDEN DVV V8 AKO V80 FSD V148 RWF V412 FCM KMSP" },
        { name: "Reno to Chicago", route: "KRNO FMG V6 LLC V32 CEVAR V200 STACO V32 FBR V6 MBW V100 RFD V171 SIMMN V172 DPA KORD" },
        { name: "Denver to Oklahoma City", route: "KDEN AVNEW V366 HGO V263 LAA V304 LBL V507 MMB V17 IRW KOKC" },
        { name: "Stockton to Hawthorne 1", route: "KSCK MOD V113 PXN V107 AVE V137 GMN V23 LAX KHHR" },
        { name: "Stockton to Hawthorne 2", route: "ksck patyy v113 rom v485  exert v25 lax khhr" },
        { name: "Long View to Corpus Christi", route: "KGGG PIPES V289 LFK V13 WORRY KCRP" },
        { name: "Austin Exec to Beaumont 1", route: "KEDC HOOKK V306 TNV V574 IAH V222 SHINA KBPT" },
        { name: "Austin Exec to Beaumont 2", route: "KEDC HOOKK V306 DAS KBPT" },
        { name: "Austin Exec to Beaumont 3", route: "KEDC HOOKK V306 TNV DAS KBPT" },
        { name: "Savannah to Daytona Beach", route: "KSAV KELER V437 COKES KDAB" },
        { name: "Philly to Hartford 1", route: "KPNE ARD V276 DIXIE V16 JFK V229 SNIVL KHFD" },
        { name: "Philly to Hartford 2", route: "KPNE ARD V276 MANTA V139 RICED MAD KHFD" },
        { name: "Philly to Hartford 3", route: "KPNE DITCH V312 DRIFT V139 SARDI V308 ORW KHFD" },
        { name: "Philly to Hartford 4", route: "KPNE ZIDET V479 ARD V433 LGA V99 YALER KHFD" },
        { name: "West Georgie Regional to Frankfort, KY 1", route: "kctj noone nello v5 gqo kfft" },
        { name: "West Georgie Regional to Frankfort, KY 2", route: "kctj felto v243 gqo v333 hyk v512 clegg kfft" },
        { name: "West Georgie Regional to Frankfort, KY 3", route: "kctj rmg v333 hyk v512 clegg kfft" },
        { name: "West Georgie Regional to Frankfort, KY 4", route: "kctj rmg v333 hch v51 lvt v493 hyk kfft" },
        { name: "Raleigh / Durham to Baltimore Martin State 1", route: "KRDU aimhi  KMTN" },
        { name: "Raleigh / Durham to Baltimore Martin State 2", route: "KRDU rdu v155 lvl ric ott KMTN" },
        { name: "Raleigh / Durham to Baltimore Martin State 3", route: "KRDU rdu v155 mange v157 colin v33 ott v433 paleo KMTN" },
        { name: "Raleigh / Durham to Baltimore Martin State 4", route: "KRDU rdu v155 LVL V157 RIC V16 PXT V93 GRACO KMTN" },
        { name: "Roswell, NM to Longview, TX", route: "KROW Climb|9500|6:00 070@14 HOB V68 PIZON 050@16 V16 ABI V62 JEN V94 OTTIF KGGG" },
        { name: "Lubbock to Longview 1", route: "KLBB JEN CQY KGGG" },
        { name: "Lubbock to Longview 2", route: "KLBB ralls v102 gth v278 byp v114 awlar KGGG" },
        { name: "Lubbock to Longview 3", route: "KLBB hydro v62 jen v94 ottif KGGG" },
        { name: "Stockton, CA to North Las Vegas 1", route: "KSCK ECA V244 OAL V105 LUCKY KVGT" },
        { name: "Stockton, CA to North Las Vegas 2", route: "KSCK ehf v197 pmd v12 basal v394 oasys KVGT" },
        { name: "Bakersfield to Santa Rosa 1", route: "KBFL EHF V248 AVE OAK SAU KSTS" },
        { name: "Bakersfield to Santa Rosa 2", route: "KBFL EHF V248 AVE PXN V301 SUNOL KSTS" },
        { name: "Bakersfield to Santa Rosa 3", route: "KBFL SCRAP V248 AVE V107 OAK V195 CROIT V108 STS KSTS" },
        { name: "Bakersfield to Santa Rosa 4", route: "KBFL EHF V23 SAC V494 SNUPY KSTS" },
        { name: "Bakersfield to Santa Rosa 5", route: "KBFL EHF V248 AVE V137 SNS V230 SHOEY V27 PYE KSTS" },
        { name: "Bakersfield to Santa Rosa 6", route: "KBFL EHF V23 CZQ MOD OAKEY KSTS" },
        { name: "Bakersfield to Santa Rosa 7", route: "KBFL EHF V23 LIN CCR CROIT SGD KSTS" },
        { name: "Bakersfield to Santa Rosa 8", route: "KBFL EHF V248 AVE V107 PXN SGD KSTS" },
        { name: "Great Falls to Boeing King Field 1", route: "KGTF GTF V120 MLP V2 GEG V120 NORMY KBFI" },
        { name: "Great Falls to Boeing King Field 2", route: "KGTF GTF V120 MLP J70 SEA KBFI" },
        { name: "Great Falls to Boeing King Field 3", route: "KGTF GTF V187 ELN V2 SEA KBFI" },
        { name: "Great Falls to Boeing King Field 4", route: "KGTF KEETA Q144 ZIRAN KBFI" },
        { name: "Boise to Centenial 1", route: "KBOI BOI V4 LAR RAMMS NIWOT KAPA" },
        { name: "Boise to Centenial 2", route: "KBOI ROARR PIH J20 OCS J154 AVVVS KAPA" },
        { name: "Boise to Centenial 3", route: "KBOI CANEK V4 OCS V328 DOBEE V356 ELORE KAPA" },
        { name: "Boise to Centenial 4", route: "KBOI BOI J54 PIH J20 OCS J52 FQF KAPA" },
        { name: "St. Louis to Birmingham 1", route: "KSTL SPUDZ V125 DUEAS V540 CNG V67 SYI V321 BOAZE V115 COLIG KBHM" },
        { name: "St. Louis to Birmingham 2", route: "KSTL ODUJY FAM CGI JKS MSL VUZ KBHM" },
        { name: "Chattanoga to Augusta 1", route: "KCHA ODF AHN V417 MSTRS KAGS" },
        { name: "Chattanoga to Augusta 2", route: "KCHA GQO NELLO CCATT T292 JACET KAGS" },
        { name: "Chattanoga to Augusta 3", route: "KCHA GQO ATL ANNAN KAGS" },
        { name: "Chattanoga to Augusta 4", route: "KCHA HOCHE V5 AHN V417 IRQ KAGS" },
        { name: "Concord, NC to Richmond, VA 1", route: "KJQF SBV V20 RIC KRIC" },
        { name: "Concord, NC to Richmond, VA 2", route: "KJQF GIZMO V143 GSO V266 SBV V20 RIC KRIC" },
        { name: "Concord, NC to Richmond, VA 3", route: "KJQF GSO SBV V20 RIC KRIC" },
        { name: "Concord, NC to Richmond, VA 4", route: "KJQF GIZMO V454 LVL V157 RIC KRIC" },
        { name: "Buffalo, NY to Portland, ME 1", route: "KBUF BUF V2 UCA V496 NEETS V39 LIMER KPWM" },
        { name: "Buffalo, NY to Portland, ME 2", route: "KBUF HANKK AUDIL PUPPY GFL KPWM" },
        { name: "Buffalo, NY to Portland, ME 3", route: "KBUF BUF V14 GGT V428 UCA V496 ENE KPWM" },
        { name: "Buffalo, NY to Portland, ME 4", route: "KBUF JOSSY Q935 PONCT ARIME CDOGG ENE KPWM" },
        { name: "Moline, IL to Battle Creek, MI 1", route: "KMLI GENSO V8 NOMES V156 AZO KBTL" },
        { name: "Moline, IL to Battle Creek, MI 2", route: "KMLI OBK J547 PMM KBTL" },
        { name: "Moline, IL to Battle Creek, MI 3", route: "KMLI PLL OBK ELX KBTL" },
        { name: "Moline, IL to Battle Creek, MI 4", route: "KMLI PLL RFD V100 ELX AZO KBTL" },
        { name: "Green Bay, WI to Indianapolis, IN 1", route: "KGRB OKK V305 WELDO KIND" },
        { name: "Green Bay, WI to Indianapolis, IN 2", route: "KGRB GRB J101 BAE J89 OBK EON V24 VHP KIND" },
        { name: "Green Bay, WI to Indianapolis, IN 3", route: "KGRB WAFLE V7 BVT V399 ADVAY KIND" },
        { name: "Green Bay, WI to Indianapolis, IN 4", route: "KGRB WAFLE V7 BVT VHP KIND" },
        { name: "Anoka County, MN to Springfield, IL 1", route: "KANE KANAC V97 ODI V129 GROWL KSPI" },
        { name: "Anoka County, MN to Springfield, IL 2", route: "KANE GEP PRIOR FGT V411 RST V67 ULAXY KSPI" },
        { name: "Anoka County, MN to Springfield, IL 3", route: "KANE GEP PRIOR FGT V411 RST V503 CID V67 ULAXY KSPI" },
        { name: "Anoka County, MN to Springfield, IL 4", route: "KANE WAGNR V510 ODI V129 SPI KSPI" },
        { name: "Little Rock to Souix City 1", route: "KLIT MCI J41 OVR KSUX" },
        { name: "Little Rock to Souix City 2", route: "KLIT ROLAN V534 HAAWK V71 SGF V159 SUX KSUX" },
        { name: "Little Rock to Souix City 3 ", route: "KLIT ROLAN V534 SCRAN V527 RZC V13 BUM V71 PANNY KSUX" },
        { name: "Little Rock to Souix City 4", route: "KLIT ROLAN V534 SCRAN V527 RZC V13 EOS V307 CNU V131 TOP PWE SUX KSUX" }
    ];

    setupUserWaypoints();

    print("let expectedFlightPlans = [");

    for (let i = 0; i < flightPlans.length; ++i) {
        let flightPlanName = flightPlans[i].name;
        let flightPlanRoute = flightPlans[i].route;
        let flightPlan = new FlightPlan(flightPlanName, flightPlanRoute);
        flightPlan.parseRoute();
        flightPlan.calculate();
        let totalTime = flightPlan.totalTime();
        let gateTime = flightPlan.gateTime();
        let expectedGateTimeString;
        if (Math.abs(Time.differenceBetween(totalTime, gateTime).seconds()) == 0)
            expectedGateTimeString = "undefined";
        else
            expectedGateTimeString = "new Time(\"" + gateTime + "\")";

            print("    new ExpectedFlightPlan(\"" + flightPlanName + "\", \"" + flightPlanRoute + "\", \"" +
                  flightPlan.resolvedRoute() + "\", new Time(\"" + totalTime + "\"), " + expectedGateTimeString + "),");
    }

    print("];");

    print("# Created " + flightPlans.length + " flight plans");
}

// createTestRoutes();