"use strict";

function PlaneObject(icao) {
    // Info about the plane
    this.icao      = icao;
    this.icaorange = findICAORange(icao);
    this.flight    = null;
    this.squawk    = null;
    this.selected  = false;
    this.category  = null;
    this.dataSource = "other";
    this.hasADSB   = false;
    this.adsbOnGround = null;

    this.trCache = [];

    // Basic location information
    this.altitude       = null;
    this.alt_baro       = null;
    this.alt_geom       = null;
    this.altitudeTime   = 0;
    this.bad_alt        = null;
    this.bad_altTime    = null;
    this.alt_reliable   = 0;

    this.speed          = null;
    this.gs             = null;
    this.ias            = null;
    this.tas            = null;

    this.track          = null;
    this.track_rate     = null;
    this.mag_heading    = null;
    this.true_heading   = null;
    this.mach           = null;
    this.roll           = null;
    this.nav_altitude   = null;
    this.nav_heading    = null;
    this.nav_modes      = null;
    this.nav_qnh        = null;
    this.rc				= null;

    this.rotation       = 0;

    this.nac_p			= null;
    this.nac_v			= null;
    this.nic_baro		= null;
    this.sil_type		= null;
    this.sil			= null;

    this.baro_rate      = null;
    this.geom_rate      = null;
    this.vert_rate      = null;

    this.version        = null;

    this.prev_position = null;
    this.prev_time = null;
    this.prev_track = null;
    this.position  = null;
    this.sitedist  = null;
    this.too_fast = 0;

    // Data packet numbers
    this.messages  = 0;
    this.rssi      = null;
    this.msgs1090  = 0;
    this.msgs978   = 0;
    this.messageRate = 0;
    this.messageRateOld = 0;

    // Track history as a series of line segments
    this.elastic_feature = null;
    this.track_linesegs = [];
    this.history_size = 0;
    this.trace = []; // save last 30 seconds of positions

    // Track (direction) at the time we last appended to the track history
    this.tail_track = null;
    this.tail_true = null;
    // Timestamp of the most recent point appended to the track history
    this.tail_update = null;

    // When was this last updated (receiver timestamp)
    this.last_message_time = 0;
    this.position_time = 0;

    this.last = 0; // last json this plane was included in

    // When was this last updated (seconds before last update)
    this.seen = null;
    this.seen_pos = null;

    // Display info
    this.visible = true;
    this.marker = null;
    this.markerStyle = null;
    this.markerIcon = null;
    this.markerStyleKey = null;
    this.markerSvgKey = null;
    this.baseScale = 1;

    // start from a computed registration, let the DB override it
    // if it has something else.
    this.registration = registration_from_hexid(this.icao);
    this.icaoType = null;
    this.typeDescription = null;
    this.wtc = null;


    // request metadata
    this.getAircraftData();

}
PlaneObject.prototype.checkLayers = function() {
    if (!this.trail_features)
        this.createFeatures();
    if ((showTrace || trackLabels) && !this.trail_labels)
        this.createLabels();
}

PlaneObject.prototype.createFeatures = function() {
    this.trail_features = new ol.source.Vector();

    this.layer = new ol.layer.Vector({
        name: this.icao,
        isTrail: true,
        source: this.trail_features,
        declutter: false,
        zIndex: 150,
    });

    trailGroup.push(this.layer);
}

PlaneObject.prototype.createLabels = function() {
    this.trail_labels = new ol.source.Vector();

    this.layer_labels = new ol.layer.Vector({
        name: this.icao + '_labels',
        isTrail: true,
        source: this.trail_labels,
        declutter: true,
        zIndex: 151,
    });

    trailGroup.push(this.layer_labels);
}

PlaneObject.prototype.logSel = function(loggable) {
    if (debugTracks && this.selected && !SelectedAllPlanes)
        console.log(loggable);
    return;
}

PlaneObject.prototype.isFiltered = function() {

    if (onlySelected && !this.selected) {
        return true;
    }

    if (onlyMLAT && !(this.dataSource == "mlat" || (this.dataSource == "other" && this.position == null))) {
        return true;
    }

    if (onlyMilitary && !this.military) {
        return true;
    }

    if (onlyADSB && this.dataSource != "adsb" && this.dataSource != "uat") {
        return true;
    }

    if (filterTISB && this.dataSource == "tisb") {
        return true;
    }

    if (!filterTracks && this.altFiltered(this.altitude))
        return true;

    if (PlaneFilter.type && (!this.icaoType || !this.icaoType.match(PlaneFilter.type)) ) {
        return true;
    }

    if (PlaneFilter.description && (!this.typeDescription || !this.typeDescription.match(PlaneFilter.description)) ) {
        return true;
    }

    if (PlaneFilter.callsign
        && (!this.flight || !this.flight.match(PlaneFilter.callsign))
        && (!this.squawk || !this.squawk.match(PlaneFilter.callsign))
    ) {
        return true;
    }

    // filter out ground vehicles
    if (typeof PlaneFilter.groundVehicles !== 'undefined' && PlaneFilter.groundVehicles === 'filtered') {
        if (typeof this.category === 'string' && this.category.startsWith('C')) {
            return true;
        }
    }

    // filter out blocked MLAT flights
    if (typeof PlaneFilter.blockedMLAT !== 'undefined' && PlaneFilter.blockedMLAT === 'filtered') {
        if (typeof this.icao === 'string' && this.icao.startsWith('~')) {
            return true;
        }
    }

    return false;
}


PlaneObject.prototype.altFiltered = function(altitude) {
    if (PlaneFilter.minAltitude == null || PlaneFilter.maxAltitude == null)
        return false;
    if (altitude == null) {
        return true;
    }
    const planeAltitude = altitude === "ground" ? 0 : altitude;
    if (planeAltitude < PlaneFilter.minAltitude || planeAltitude > PlaneFilter.maxAltitude) {
        return true;
    }
    return false;
}

PlaneObject.prototype.updateTail = function() {

    this.tail_update = this.prev_time;
    this.tail_track = this.prev_track;
    this.tail_rot = this.prev_rot;
    this.tail_true = this.prev_true;
    this.tail_position = this.prev_position;

    return this.updateTrackPrev();
}

PlaneObject.prototype.updateTrackPrev = function() {

    this.prev_position = this.position;
    this.prev_time = this.position_time;
    this.prev_track = this.track;
    this.prev_rot = this.rotation;
    this.prev_true = this.true_head;
    this.prev_alt = this.altitude;
    this.prev_alt_rounded = this.alt_rounded;
    this.prev_speed = this.speed;

    return true;
}

// Appends data to the running track so we can get a visual tail on the plane
// Only useful for a long running browser session.
PlaneObject.prototype.updateTrack = function(now, last, serverTrack, stale) {
    if (this.position == null)
        return false;
    if (this.prev_position && this.position[0] == this.prev_position[0] && this.position[1] == this.prev_position[1]
        && !serverTrack)
        return false;
    if (this.bad_position && this.position[0] == this.bad_position[0] && this.position[1] == this.bad_position[1])
        return false;

    if (this.position && SitePosition) {
        this.sitedist = ol.sphere.getDistance(SitePosition, this.position);
    }

    var projHere = ol.proj.fromLonLat(this.position);
    var on_ground = (this.altitude === "ground");

    var is_leg = false;
    if (this.leg_ts == now)
        is_leg = 'end';
    if (this.leg_ts == last)
        is_leg = 'start';

    if (this.track_linesegs.length == 0) {
        // Brand new track
        //console.log(this.icao + " new track");
        if (this.leg_ts == now)
            is_leg = 'start';
        var newseg = { fixed: new ol.geom.LineString([projHere]),
            feature: null,
            estimated: false,
            ground: on_ground,
            altitude: this.alt_rounded,
            alt_real: this.altitude,
            speed: this.speed,
            ts: now,
            track: this.rotation,
            leg: is_leg,
        };
        this.track_linesegs.push(newseg);
        this.history_size ++;
        this.updateTrackPrev();
        return this.updateTail();
    }

    var projPrev = ol.proj.fromLonLat(this.prev_position);
    var lastseg = this.track_linesegs[this.track_linesegs.length - 1];

    var distance = 1000;
    var derivedMach = 0.01;
    var filterSpeed = 10000;

    const pFilter = (positionFilter == true || (positionFilter == 'onlyMLAT' && this.dataSource == "mlat"));

    if (pFilter) {
        distance = ol.sphere.getDistance(this.position, this.prev_position);
        derivedMach = (distance/(this.position_time - this.prev_time + 0.4))/343;
        filterSpeed = on_ground ? positionFilterSpeed/10 : positionFilterSpeed;
        filterSpeed = (this.speed != null && this.prev_speed != null) ? (positionFilterGsFactor*(Math.max(this.speed, this.prev_speed)+10+(this.dataSource == "mlat")*100)/666) : filterSpeed;
    }

    // ignore the position if the object moves faster than positionFilterSpeed (default Mach 3.5)
    // or faster than twice the transmitted groundspeed
    if (pFilter && derivedMach > filterSpeed && this.too_fast < 1) {
        this.bad_position = this.position;
        this.too_fast++;
        if (debugPosFilter) {
            console.log(this.icao + " / " + this.name + " ("+ this.dataSource + "): Implausible position filtered: " + this.bad_position[0] + ", " + this.bad_position[1] + " (kts/Mach " + (derivedMach*666).toFixed(0) + " > " + (filterSpeed*666).toFixed(0)   + " / " + derivedMach.toFixed(2) + " > " + filterSpeed.toFixed(2) + ") (" + (this.position_time - this.prev_time + 0.2).toFixed(1) + "s)");
        }
        this.position = this.prev_position;
        this.position_time = this.prev_time;
        if (debugPosFilter) {
            this.drawRedDot(this.bad_position);
            jumpTo = this.icao;
        }
        return false;
    } else {
        this.too_fast = Math.max(-5, this.too_fast-0.8);
    }

    if (this.request_rotation_from_track && this.prev_position) {
        this.rotation = bearingFromLonLat(this.prev_position, this.position);
    }


    // special case crossing the 180 -180 longitude line by just starting a new track
    if ((this.position[0] < -90 && this.prev_position[0] > 90)
        || (this.position[0] > 90 && this.prev_position[0] < -90)
    ) {
        lastseg.fixed.appendCoordinate(projPrev);
        var sign1 = Math.sign(this.prev_position[0]);
        var sign2 = Math.sign(this.position[0]);
        var londiff1 = 180 - Math.abs(this.prev_position[0]);
        var londiff2 = 180 - Math.abs(this.position[0]);
        var ratio1 = londiff1 / (londiff1 + londiff2);
        var ratio2 = londiff2 / (londiff1 + londiff2);
        var tryLat = ratio1 * this.prev_position[1] + ratio2 *this.position[1];
        var minDistance = 50 * 1000* 1000;
        var midLat = 0;
        for (var i = 1; i < 100; i += 1) {
            var distance1 = ol.sphere.getDistance(this.prev_position, [sign1 * 180, tryLat - i]);
            var distance2 = ol.sphere.getDistance(this.position, [sign2 * 180, tryLat - i]);

            var distance = distance1 + distance2;
            if (distance < minDistance) {
                minDistance = distance;
                midLat = tryLat - i;
            } else {
                break;
            }
        }
        for (var i = 1; i < 100; i+= 1) {
            var distance1 = ol.sphere.getDistance(this.prev_position, [sign1 * 180, tryLat + i]);
            var distance2 = ol.sphere.getDistance(this.position, [sign2 * 180, tryLat + i]);

            var distance = distance1 + distance2;

            if (distance < minDistance) {
                minDistance = distance;
                midLat = tryLat + i;
            } else {
                break;
            }
        }
        var midPoint1 = ol.proj.fromLonLat([sign1 * 180, midLat]);
        var midPoint2 = ol.proj.fromLonLat([sign2 * 180, midLat]);
        this.track_linesegs.push({ fixed: new ol.geom.LineString([projPrev, midPoint1]),
            feature: null,
            altitude: 0,
            estimated: true,
            ts: this.prev_time,
        });
        this.track_linesegs.push({ fixed: new ol.geom.LineString([midPoint2, projHere]),
            feature: null,
            altitude: 0,
            estimated: true,
            ts: NaN,
        });
        var newseg = { fixed: new ol.geom.LineString([projHere]),
            feature: null,
            estimated: true,
            ground: on_ground,
            altitude: this.alt_rounded,
            alt_real: this.altitude,
            speed: this.speed,
            ts: now,
            track: this.rotation,
        };
        this.track_linesegs.push(newseg);
        this.history_size += 2;

        this.updateTrackPrev();
        return this.updateTail();
    }


    // Determine if track data are intermittent/stale
    // Time difference between two position updates should not be much
    // greater than the difference between data inputs
    var time_difference = (this.position_time - this.prev_time) - (now - last);

    //var stale_timeout = lastseg.estimated ? 5 : 10;
    var stale_timeout = 15;

    // MLAT data are given some more leeway
    if (this.dataSource == "mlat")
        stale_timeout = 15;

    // On the ground you can't go that quick
    if (on_ground)
        stale_timeout = 30;

    // Also check if the position was already stale when it was exported by dump1090
    // Makes stale check more accurate for example for 30s spaced history points

    const estimated = (time_difference > stale_timeout) || ((now - this.position_time) > stale_timeout) || stale;

    /*
    var track_change = this.track != null ? Math.abs(this.tail_track - this.track) : NaN;
    track_change = track_change < 180 ? track_change : Math.abs(track_change - 360);
    var true_change =  this.trueheading != null ? Math.abs(this.tail_true - this.true_heading) : NaN;
    true_change = true_change < 180 ? true_change : Math.abs(true_change - 360);
    if (!isNaN(true_change)) {
        track_change = isNaN(track_change) ? true_change : Math.max(track_change, true_change);
    }
    */
    var track_change = Math.abs(this.tail_rot - this.rotation);

    var alt_change = Math.abs(this.alt_rounded - lastseg.altitude);
    var since_update = this.prev_time - this.tail_update;
    var distance_traveled = ol.sphere.getDistance(this.tail_position, this.prev_position);

    if (
        this.prev_alt_rounded !== lastseg.altitude
        || this.prev_time > lastseg.ts + 300
        || estimated != lastseg.estimated
        || tempTrails
        || debugAll ||
        (
            serverTrack &&
            (
                this.prev_time - lastseg.ts > 5
                || estimated
                || track_change > 2
                || Math.abs(this.prev_speed - lastseg.speed) > 5
                || Math.abs(this.prev_alt - lastseg.alt_real) > 50
                || is_leg
            )
        )

        //lastseg.ground != on_ground
        //|| (!on_ground && isNaN(alt_change))
        //|| (alt_change > 700)
        //|| (alt_change > 375 && this.alt_rounded < 9000)
        //|| (alt_change > 150 && this.alt_rounded < 5500)
    ) {
        // Create a new segment as the ground state or the altitude changed.
        // The new state is only drawn after the state has changed
        // and we then get a new position.

        this.logSel("sec_elapsed: " + since_update.toFixed(1) + " alt_change: "+ alt_change.toFixed(0) + " derived_speed(kts/Mach): " + (distance_traveled/since_update*1.94384).toFixed(0) + " / " + (distance_traveled/since_update/343).toFixed(1));

        lastseg.fixed.appendCoordinate(projPrev);
        this.track_linesegs.push({ fixed: new ol.geom.LineString([projPrev]),
            feature: null,
            estimated: estimated,
            altitude: this.prev_alt_rounded,
            alt_real: this.prev_alt,
            speed: this.prev_speed,
            ground: on_ground,
            ts: this.prev_time,
            track: this.prev_rot,
            leg: is_leg,
        });

        this.history_size += 2;

        return this.updateTail();
    }


    // Add current position to the existing track.
    // We only retain some points depending on time elapsed and track change
    var turn_density = 6.5;
    if (
        since_update > 86 ||
        (!on_ground && since_update > (100/turn_density)/track_change) ||
        (!on_ground && isNaN(track_change) && since_update > 8) ||
        (on_ground && since_update > (120/turn_density)/track_change && distance_traveled > 20) ||
        (on_ground && distance_traveled > 50 && since_update > 5) ||
        debugAll
    ) {

        lastseg.fixed.appendCoordinate(projPrev);
        this.history_size ++;

        this.logSel("sec_elapsed: " + since_update.toFixed(1) + " " + (on_ground ? "ground" : "air") +  " dist:" + distance_traveled.toFixed(0) +  " track_change: "+ track_change.toFixed(1) + " derived_speed(kts/Mach): " + (distance_traveled/since_update*1.94384).toFixed(0) + " / " + (distance_traveled/since_update/343).toFixed(1));

        return this.updateTail();
    }

    return this.updateTrackPrev();
};

// This is to remove the line from the screen if we deselect the plane
PlaneObject.prototype.clearLines = function() {
    if (this.layer && this.layer.getVisible()) {
        this.layer.setVisible(false);
    }
    if (this.layer_labels && this.layer_labels.getVisible())
        this.layer_labels.setVisible(false);
};

PlaneObject.prototype.getDataSourceNumber = function() {
    // MLAT
    if (this.jaero || this.sbs)
        return 5;
    if (this.dataSource == "mlat") {
        return 3;
    }
    if (this.dataSource == "uat")
        return 2; // UAT

    // Not MLAT, but position reported - ADSB or variants
    if (this.dataSource == "tisb")
        return 4; // TIS-B
    if (this.dataSource == "adsb")
        return 1;

    // Otherwise Mode S
    return 5;

    // TODO: add support for Mode A/C
};

PlaneObject.prototype.getDataSource = function() {
    // MLAT
    if (this.jaero)
        return 'jaero';

    if (this.sbs)
        return 'unknown';

    if (this.dataSource == "mlat") {
        return 'mlat';
    }
    if (this.dataSource == "uat" && this.dataSource != "tisb")
        return 'uat';

    if (this.addrtype) {
        return this.addrtype;
    }

    if (this.dataSource == "adsb")
        return "adsb_icao";

    if (this.dataSource == "tisb")
        return "tisb";

    // Otherwise Mode S
    return 'mode_s';

    // TODO: add support for Mode A/C
};

PlaneObject.prototype.getMarkerColor = function() {
    // Emergency squawks override everything else
    if (this.squawk in SpecialSquawks)
        return SpecialSquawks[this.squawk].markerColor;

    if (monochromeMarkers) {
        return monochromeMarkers;
    }

    var h, s, l;

    var colorArr = altitudeColor(this.alt_rounded);

    h = colorArr[0];
    s = colorArr[1];
    l = colorArr[2];

    // If we have not seen a recent position update, change color
    if (this.seen_pos > 15 && !globeIndex)  {
        h += ColorByAlt.stale.h;
        s += ColorByAlt.stale.s;
        l += ColorByAlt.stale.l;
    }
    if (this.alt_rounded == "ground") {
        l += 15;
    }

    // If this marker is selected, change color
    if (this.selected && !SelectedAllPlanes && !onlySelected){
        h += ColorByAlt.selected.h;
        s += ColorByAlt.selected.s;
        l += ColorByAlt.selected.l;
    }

    // If this marker is a mlat position, change color
    if (this.dataSource == "mlat") {
        h += ColorByAlt.mlat.h;
        s += ColorByAlt.mlat.s;
        l += ColorByAlt.mlat.l;
    }

    if (h < 0) {
        h = (h % 360) + 360;
    } else if (h >= 360) {
        h = h % 360;
    }

    //if (s < 5) s = 5;
    if (s > 95) s = 95;

    if (l < 5) l = 5;
    else if (l > 95) l = 95;

    return 'hsl(' + h.toFixed(0) + ',' + s.toFixed(0) + '%,' + l.toFixed(0) + '%)'
}

function altitudeColor(altitude) {
    var h, s, l;

    if (altitude == null) {
        h = ColorByAlt.unknown.h;
        s = ColorByAlt.unknown.s;
        l = ColorByAlt.unknown.l;
    } else if (altitude === "ground") {
        h = ColorByAlt.ground.h;
        s = ColorByAlt.ground.s;
        l = ColorByAlt.ground.l;
    } else {
        s = ColorByAlt.air.s;

        // find the pair of points the current altitude lies between,
        // and interpolate the hue between those points
        var hpoints = ColorByAlt.air.h;
        h = hpoints[0].val;
        for (var i = hpoints.length-1; i >= 0; --i) {
            if (altitude > hpoints[i].alt) {
                if (i == hpoints.length-1) {
                    h = hpoints[i].val;
                } else {
                    h = hpoints[i].val + (hpoints[i+1].val - hpoints[i].val) * (altitude - hpoints[i].alt) / (hpoints[i+1].alt - hpoints[i].alt)
                }
                break;
            }
        }
        var lpoints = ColorByAlt.air.l;
        lpoints = lpoints.length ? lpoints : [{h:0, val:lpoints}];
        l = lpoints[0].val;
        for (var i = lpoints.length-1; i >= 0; --i) {
            if (h > lpoints[i].h) {
                if (i == lpoints.length-1) {
                    l = lpoints[i].val;
                } else {
                    l = lpoints[i].val + (lpoints[i+1].val - lpoints[i].val) * (h - lpoints[i].h) / (lpoints[i+1].h - lpoints[i].h)
                }
                break;
            }
        }
    }

    if (h < 0) {
        h = (h % 360) + 360;
    } else if (h >= 360) {
        h = h % 360;
    }

    if (s < 5) s = 5;
    else if (s > 95) s = 95;

    if (l < 5) l = 5;
    else if (l > 95) l = 95;

    return [h, s, l];
}

PlaneObject.prototype.updateIcon = function() {

    var col = this.getMarkerColor();
    var baseMarkerKey = (this.category ? this.category : "A0") + "_"
        + this.typeDescription + "_" + this.wtc  + "_" + this.icaoType;

    if (!this.baseMarker || this.baseMarkerKey != baseMarkerKey) {
        this.baseMarkerKey = baseMarkerKey;
        this.baseMarker = getBaseMarker(this.category, this.icaoType, this.typeDescription, this.wtc);
        this.shape = this.baseMarker[0];
        this.baseScale = this.baseMarker[1];
        this.baseMarker = shapes[this.shape]
        if (!this.baseMarker)
            console.log(baseMarkerKey);
    }
    var outline = (this.shape != 'md11') ?
        ' stroke="'+OutlineADSBColor+'" stroke-width="0.4px"' :
        ' stroke="'+OutlineADSBColor+'" stroke-width="2px"';
    var add_stroke = (this.selected && !SelectedAllPlanes && !onlySelected) ? outline : '';

    this.scale = scaleFactor * this.baseScale;
    var svgKey  = col + '!' + this.shape + '!' + add_stroke;
    var labelText = null;
    if ( enableLabels && !showTrace && (!multiSelect || (multiSelect && this.selected)) &&
        (
            (ZoomLvl >= labelZoom && this.altitude != "ground")
            || (ZoomLvl >= labelZoomGround-2 && this.speed > 5)
            || ZoomLvl >= labelZoomGround
            || (this.selected && !SelectedAllPlanes)
        )
    ) {
        if (extendedLabels == 2) {
            labelText = NBSP + (this.icaoType ? this.icaoType : "  ?  ") + NBSP + "\n" + NBSP + (this.registration ? this.registration : "  ?  ")+ NBSP + "\n" + NBSP + this.name + NBSP;
        } else if (extendedLabels == 1 ) {
            const altitude = this.altitude ? this.altitude : '  ?  ';
            if ((!this.onGround || (this.speed && this.speed > 18) || (this.selected && !SelectedAllPlanes))) {
                labelText =  Number(this.speed).toFixed(0).toString().padStart(4, NBSP)+ "  "
                    + altitude.toString().padStart(5, NBSP) + " \n " + this.name + " ";
            } else {
                labelText =  " " + this.name + " ";
            }
        } else {
            labelText = " " + this.name + " ";
        }
    }
    var styleKey = svgKey + '!' + labelText + '!' + this.scale;

    if (this.markerStyle == null || this.markerIcon == null || (this.markerSvgKey != svgKey)) {
        //console.log(this.icao + " new icon and style " + this.markerSvgKey + " -> " + svgKey);

        this.markerSvgKey = svgKey;
        this.rotationCache = this.rotation;

        if (iconCache[svgKey] == undefined) {
            var svgURI = svgPathToURI(this.baseMarker.svg, OutlineADSBColor, col, add_stroke);

            addToIconCache.push([svgKey, null, svgURI]);

            this.markerIcon = new ol.style.Icon({
                scale: this.scale,
                imgSize: this.baseMarker.size,
                src: svgURI,
                rotation: (this.baseMarker.noRotate ? 0 : this.rotation * Math.PI / 180.0),
                rotateWithView: (this.baseMarker.noRotate ? false : true),
            });
        } else {
            this.markerIcon = new ol.style.Icon({
                scale: this.scale,
                imgSize: this.baseMarker.size,
                img: iconCache[svgKey],
                rotation: (this.baseMarker.noRotate ? 0 : this.rotation * Math.PI / 180.0),
                rotateWithView: (this.baseMarker.noRotate ? false : true),
            });
        }
        //iconCache[svgKey] = undefined; // disable caching for testing
    }
    if (this.styleKey != styleKey) {
        this.styleKey = styleKey;
        if (labelText) {
            this.markerStyle = new ol.style.Style({
                image: this.markerIcon,
                text: new ol.style.Text({
                    text: labelText ,
                    fill: new ol.style.Fill({color: 'white' }),
                    backgroundFill: new ol.style.Stroke({color: 'rgba(0,0,0,0.4'}),
                    textAlign: 'left',
                    textBaseline: "top",
                    font: labelFont,
                    offsetX: (this.baseMarker.size[0]*0.5*0.74*this.scale),
                    offsetY: (this.baseMarker.size[0]*0.5*0.74*this.scale),
                }),
                zIndex: this.zIndex,
            });
        } else {
            this.markerStyle = new ol.style.Style({
                image: this.markerIcon,
                zIndex: this.zIndex,
            });
        }
        this.marker.setStyle(this.markerStyle);
    }

    /*
    if (this.opacityCache != opacity) {
        this.opacityCache = opacity;
        this.markerIcon.setOpacity(opacity);
    }
    */

    if (this.rotationCache == null || Math.abs(this.rotationCache - this.rotation) > 0.15) {
        this.rotationCache = this.rotation;
        this.markerIcon.setRotation(this.baseMarker.noRotate ? 0 : this.rotation * Math.PI / 180.0);
    }

    if (this.scaleCache != this.scale) {
        this.scaleCache = this.scale;
        this.markerIcon.setScale(this.scale);
    }

    return true;
};

PlaneObject.prototype.processTrace = function(options) {
    if (!options)
        options = {};
    var legStart = options.legStart;
    var legEnd = options.legEnd;
    var follow = options.follow;
    this.checkLayers();
    var trace = null;
    var timeZero, _now, _last = 0;
    this.history_size = 0;
    var points_in_trace = 0;

    var tempPlane = {};
    const oldSegs = this.track_linesegs;
    this.track_linesegs = [];
    this.remakeTrail();

    Object.assign(tempPlane, this);

    this.position = null;

    var onlyRecent = 0;

    if (lastLeg && !showTrace && this.recentTrace && this.recentTrace.trace) {
        trace = this.recentTrace.trace;
        for (var i = trace.length - 1; i >= 0; i--) {
            if (trace[i][6] & 2) {
                onlyRecent = 1;
                break;
            }
        }
    }

    for (var j = 0; j < 2; j++) {
        if (j == 0) {
            if (!this.fullTrace || !this.fullTrace.trace)
                continue;
            if (onlyRecent)
                continue;
            timeZero = this.fullTrace.timestamp;

            _last = timeZero - 1;

            trace = this.fullTrace.trace;
        } else {
            if (!this.recentTrace || !this.recentTrace.trace)
                continue;
            timeZero = this.recentTrace.timestamp;
            if (!trace) {
                _last = timeZero - 1;
            }
            trace = this.recentTrace.trace;
        }
        var start = 0;
        var end = trace.length;

        if (lastLeg && !showTrace) {
            for (var i = trace.length - 1; i >= 0; i--) {
                if (trace[i][6] & 2) {
                    start = i;
                    break;
                }
            }
        }

        if (legStart != null)
            start = legStart;
        if (legEnd != null)
            end = legEnd;

        for (var i = start; i < end; i++) {
            const state = trace[i];
            const timestamp = timeZero + state[0];
            const lat = state[1];
            const lon = state[2];
            const altitude = state[3];
            const gs = state[4];
            const track = state[5];
            const stale = state[6] & 1;
            const leg_marker = state[6] & 2;

            _now = timestamp;

            if (_now <= _last)
                continue;

            points_in_trace++;

            this.position = [lon, lat];
            this.position_time = _now;
            this.last_message_time = _now;
            this.altitude = altitude;
            this.alt_rounded = calcAltitudeRounded(this.altitude);
            this.speed = gs;
            this.track = track;
            if (track)
                this.rotation = track

            if (leg_marker)
                this.leg_ts = _now;
            if (legStart != null && legStart > 0 && legStart == i)
                this.leg_ts = _now;
            if (legEnd != null && legEnd < trace.length && legEnd == i + 1)
                this.leg_ts = _now;

            if (_last - _now > 320) {
                stale = true;
            }

            this.updateTrack(_now, _last, true, stale);
            _last = _now;
        }
    }

    for (var i = 0; i < this.trace.length; i++) {
        if (showTrace)
            break;
        const state = this.trace[i];
        if (_now >= state.now)
            continue;

        _now = state.now;
        this.position = state.position;
        this.position_time = _now;
        this.altitude = state.altitude;
        this.alt_rounded = state.alt_rounded;
        this.speed = state.speed;
        this.track = state.track;
        this.rotation = state.rotation;

        if (_last - _now > 30) {
            _last = _now - 1;
        }

        this.updateTrack(_now, _last);
        _last = _now;
    }

    if (!tempPlane.prev_position) {
        tempPlane.prev_position = this.position;
    }

    if (tempPlane.last_message_time > this.last_message_time && !showTrace) {
        var newSegs = this.track_linesegs;
        Object.assign(this, tempPlane);
        this.track_linesegs = newSegs;
    }

    if (showTrace) {

        if (this.track_linesegs.length > 0 && this.position) {
            const proj = ol.proj.fromLonLat(this.position);
            this.track_linesegs[this.track_linesegs.length - 1].fixed.appendCoordinate(proj);
            this.track_linesegs.push({ fixed: new ol.geom.LineString([proj]),
                feature: null,
                estimated: false,
                altitude: this.alt_rounded,
                alt_real: this.altitude,
                speed: this.speed,
                ground: (this.altitude == "ground"),
                ts: this.position_time,
                track: this.rotation,
            });
        }

        now = new Date().getTime()/1000;
    }
    this.updateFeatures(now, _last);

    var mapSize = OLMap.getSize();
    var size = [Math.max(5, mapSize[0] - 280), mapSize[1]];
    if ((showTrace || showTraceExit) && !inView(this, OLMap.getView().calculateExtent(size)))
        OLMap.getView().setCenter(ol.proj.fromLonLat(this.position));

    showTraceExit = false;

    this.updateMarker(true);
    this.updateLines();

    if (this.position && follow) {
        toggleFollow(true);
    }

    refreshSelected();

    console.log(this.history_size + ' ' + points_in_trace);
}

// Update our data
PlaneObject.prototype.updateData = function(now, last, data, init) {
    // get location data first, return early if only those are needed.

    this.updated = true;
    var newPos = false;

    var isArray = Array.isArray(data);
    // [.hex, .alt_baro, .gs, .track, .lat, .lon, .seen_pos, "mlat"/"tisb"/.type , .flight, .messages]
    //    0      1        2     3       4     5     6                 7               8        9
    // this format is only valid for chunk loading the history
    const alt_baro = isArray? data[1] : data.alt_baro;
    const gs = isArray? data[2] : data.gs;
    const track = isArray? data[3] : data.track;
    const lat = isArray? data[4] : data.lat;
    const lon = isArray? data[5] : data.lon;
    var seen = isArray? data[6] : data.seen;
    const seen_pos = isArray? data[6] : data.seen_pos;
    seen = (seen == null) ? 5 : seen;
    const type = isArray? data[7] : data.type;
    var mlat = isArray? (data[7] == "mlat") : (data.mlat != null && data.mlat.indexOf("lat") >= 0);
    var tisb = isArray? (data[7] == "tisb") : (data.tisb != null && data.tisb.indexOf("lat") >= 0);
    tisb = tisb || (type && type.substring(0,4) == "tisb");
    const flight = isArray? data[8] : data.flight;

    this.last_message_time = now - seen;

    // remember last known position even if stale
    // and some other magic to avoid mlat positions when a current ads-b position is available
    if (lat != null && this.hasADSB && this.dataSource != "mlat" && mlat
        && (now - this.position_time) < (mlatTimeout + 0.5 * mlatTimeout * this.adsbOnGround)) {
        mlat = false;
        // don't use MLAT for mlatTimeout (default 30) seconds after getting an ADS-B position
        // console.log(this.icao + ': mlat position ignored');
        if (debug && this.prev_position) {
            this.drawRedDot([lon, lat]);
        }
    } else if (lat != null && seen_pos < (now - this.position_time + 2) && !(noMLAT && mlat)) {
        this.position   = [lon, lat];
        this.position_time = now - seen_pos;
        newPos = true;
    }

    // remember last known altitude even if stale
    var newAlt = null;
    if (alt_baro != null) {
        newAlt = alt_baro;
        this.alt_baro = alt_baro;
    } else if (data.altitude != null) {
        newAlt = data.altitude;
        this.alt_baro = data.altitude;
    } else {
        this.alt_baro = null;
        if (data.alt_geom != null) {
            newAlt = data.alt_geom;
        }
    }
    // Filter anything greater than 12000 fpm


    if (newAlt == null || (newAlt == this.bad_alt && this.seen_pos > 5)) {
        // do nothing
    } else if (
        !altitudeFilter
        || this.altitude == null
        || newAlt == "ground"
        || this.altitude == "ground"
        || (seen_pos != null && seen_pos < 2)
    ) {
        this.altitude = newAlt;
        this.altitudeTime = now;
    } else if (
        this.alt_reliable > 0 && this.altBad(newAlt, this.altitude, this.altitudeTime, data)
        && (this.bad_alt == null || this.altBad(newAlt, this.bad_alt, this.bad_altTime, data))
    ) {
        // filter this altitude!
        this.alt_reliable--;
        this.bad_alt = newAlt;
        this.bad_altTime = now;
        if (debugPosFilter) {
            console.log((now%1000).toFixed(0) + ': AltFilter: ' + this.icao
                + ' oldAlt: ' + this.altitude
                + ' newAlt: ' + newAlt
                + ' elapsed: ' + (now-this.altitudeTime).toFixed(0) );
            jumpTo = this.icao;
        }
    } else {
        // good altitude
        this.altitude = newAlt;
        this.altitudeTime = now;
        this.alt_reliable = Math.min(this.alt_reliable + 1, 3);
    }

    this.alt_rounded = calcAltitudeRounded(this.altitude);

    if (this.altitude == null) {
        this.onGround = null;
        this.zIndex = -10000;
    } else if (this.altitude == "ground") {
        this.onGround = true;
        this.zIndex = -10000;
    } else {
        this.onGround = false;
        this.zIndex = this.alt_rounded;
    }

    // needed for track labels
    this.speed = gs;

    this.track = track;
    if (track != null) {
        this.rotation = track;
        this.request_rotation_from_track = false;
    } else if (data.calc_track) {
        this.rotation = data.calc_track;
    } else {
        this.request_rotation_from_track = true;
    }
    // don't expire callsigns
    if (flight != null) {
        this.flight	= flight;
        this.name = flight;
    }

    if (mlat && noMLAT) {
        this.dataSource = "other";
    } else if (mlat) {
        this.dataSource = "mlat";
    } else if (!displayUATasADSB && this.receiver == "uat" && !tisb) {
        this.dataSource = "uat";
    } else if (type == "adsb_icao" || type == "adsb_other") {
        this.dataSource = "adsb";
    } else if (type && type.substring(0,4) == "adsr") {
        this.dataSource = "adsb";
    } else if (type == "adsb_icao_nt") {
        this.dataSource = "other";
    } else if (tisb) {
        this.dataSource = "tisb";
    } else if (lat != null && type == null) {
        this.dataSource = "adsb";
        this.hasADSB = true;
        this.adsbOnGround = (alt_baro == "ground");
    }

    if (isArray) {
        this.messages = data[9];
        return;
    }

    this.jaero = data.jaero;
    this.sbs = data.sbs_other;

    if (this.jaero)
        this.dataSource = "jaero";
    if (this.sbs)
        this.dataSource = "unknown";

    // Update all of our data

    if (now - this.last > 0) {
        if (this.receiver == "1090") {
            const messageRate = (data.messages - this.msgs1090)/(now - this.last);
            this.messageRate = (messageRate + this.messageRateOld)/2;
            this.messageRateOld = messageRate; 
            this.msgs1090 = data.messages;
        } else {
            const messageRate = (data.messages - this.msgs978)/(uat_now - uat_last);
            this.messageRate = (messageRate + this.messageRateOld)/2;
            this.messageRateOld = messageRate; 
            this.msgs978 = data.messages;
        }
    }
    this.messages = data.messages;

    this.rssi = data.rssi;

    if (data.gs != null)
        this.gs = data.gs;
    else if (data.speed != null)
        this.gs = data.speed;
    else
        this.gs = null;

    if (data.baro_rate != null)
        this.baro_rate = data.baro_rate;
    else if (data.vert_rate != null)
        this.baro_rate = data.vert_rate;
    else
        this.baro_rate = null;

    // simple fields
    this.alt_geom = data.alt_geom;
    this.ias = data.ias;
    this.tas = data.tas;
    this.track_rate = data.track_rate;
    this.mag_heading = data.mag_heading;
    this.mach = data.mach;
    this.roll = data.roll;
    this.nav_altitude = data.nav_altitude;
    this.nav_heading = data.nav_heading;
    this.nav_modes = data.nav_modes;
    this.nac_p = data.nac_p;
    this.nac_v = data.nac_v;
    this.nic_baro = data.nic_baro;
    this.sil_type = data.sil_type;
    this.sil = data.sil;
    this.nav_qnh = data.nav_qnh;
    this.geom_rate = data.geom_rate;
    this.rc = data.rc;
    this.squawk = data.squawk;

    // fields with more complex behaviour

    if (data.version != null) {
        this.version = data.version;
    }
    if (data.category != null) {
        this.category = data.category;
    }

    if (data.true_heading != null)
        this.true_heading = data.true_heading;
    else
        this.true_heading = null;

    if (data.type != null)
        this.addrtype	= data.type;
    else
        this.addrtype = null;

    // Pick a selected altitude
    if (data.nav_altitude_fms != null) {
        this.nav_altitude = data.nav_altitude_fms;
    } else if (data.nav_altitude_mcp != null){
        this.nav_altitude = data.nav_altitude_mcp;
    } else {
        this.nav_altitude = null;
    }

    // Pick vertical rate from either baro or geom rate
    // geometric rate is generally more reliable (smoothed etc)
    if (data.geom_rate != null ) {
        this.vert_rate = data.geom_rate;
    } else if (data.baro_rate != null) {
        this.vert_rate = data.baro_rate;
    } else if (data.vert_rate != null) {
        // legacy from mut v 1.15
        this.vert_rate = data.vert_rate;
    } else {
        this.vert_rate = null;
    }

    this.request_rotation_from_track = false;
    if (this.altitude == "ground") {
        if (this.true_heading != null)
            this.rotation = this.true_heading;
        else if (this.mag_heading != null)
            this.rotation = this.mag_heading;
        else if (data.calc_track)
            this.rotation = data.calc_track;
    } else if (this.track != null) {
        this.rotation = this.track;
    } else if (this.true_heading != null) {
        this.rotation = this.true_heading;
    } else if (this.mag_heading != null) {
        this.rotation = this.mag_heading;
    } else if (data.calc_track) {
        this.rotation = data.calc_track;
    } else {
        this.request_rotation_from_track = true;
    }

    if (globeIndex && newPos) {
        var state = {};
        state.now = this.position_time;
        state.position = this.position;
        state.altitude = this.altitude;
        state.alt_rounded = this.alt_rounded;
        state.speed = this.speed;
        state.track = this.track;
        state.rotation = this.rotation;
        this.trace.push(state);
        if (this.trace.length > 20) {
            this.trace.slice(-15);
        }
    }

    this.last = now;
};

PlaneObject.prototype.updateTick = function(redraw) {
    if (this.dataSource == "uat")
        this.updateFeatures(uat_now, uat_last, redraw);
    else
        this.updateFeatures(now, last, redraw);
}

PlaneObject.prototype.updateFeatures = function(now, last, redraw) {

    // recompute seen and seen_pos
    this.seen = Math.max(0, now - this.last_message_time)
    this.seen_pos = Math.max(0, now - this.position_time);

    if (globeIndex && this.isFiltered())
        return;

    var moved = false;

    if (this.updated) {
        if (this.flight && this.flight.trim()) {
            this.name = this.flight;
        } else if (this.registration) {
            this.name = '_' + this.registration;
        } else {
            this.name = '_' + this.icao.toUpperCase();
        }
        this.name = this.name.trim();

        moved = this.updateTrack(now, last);
    }

    const zoomedOut = 40 * Math.max(0, 7 - ZoomLvl);
    const jaeroTime = this.jaero ? 35*60 : 0;
    const tisbReduction = (this.icao[0] == '~') ? 15 : 0;
    // If no packet in over 58 seconds, clear the plane.
    // Only clear the plane if it's not selected individually


    if ( !this.isFiltered() &&
        (
            (!globeIndex && this.seen < (58 - tisbReduction))
            || (globeIndex && this.seen_pos < (40 + zoomedOut + jaeroTime - tisbReduction))
            || (this.selected && (onlySelected || (!SelectedAllPlanes && !multiSelect)))
            || noVanish
        )
    ) {
        const lastVisible = this.visible;
        this.visible = true;
        if (SelectedAllPlanes)
            this.selected = true;

        var lines = false;
        var marker = false;


        marker = true;
        /*
        this.scale = scaleFactor * this.baseScale;
        if (this.scaleCache != this.scale)
            marker = true;
        */
        if (redraw || moved || lastVisible != this.visible)
            marker = lines = true;

        if (lines)
            this.updateLines();
        if (marker)
            this.updateMarker(true);
    } else {
        if (this.visible) {
            //console.log("hiding " + this.icao);
            this.clearMarker();
            this.clearLines();
            this.visible = false;
            this.selected = false;
            if (SelectedPlane == this.icao)
                selectPlaneByHex(null,false);
        }
    }
    this.updated = false;
};

PlaneObject.prototype.clearMarker = function() {
    if (this.marker && this.marker.visible) {
        PlaneIconFeatures.removeFeature(this.marker);
        this.marker.visible = false;
    }
};

// Update our marker on the map
PlaneObject.prototype.updateMarker = function(moved) {
    if (!this.visible || this.position == null || this.isFiltered()) {
        this.clearMarker();
        return;
    }
    if (!this.marker) {
        this.marker = new ol.Feature(new ol.geom.Point(ol.proj.fromLonLat(this.position)));
        this.marker.hex = this.icao;
        PlaneIconFeatures.addFeature(this.marker);
        this.marker.visible = true;
    } else if (moved) {
        this.marker.setGeometry(new ol.geom.Point(ol.proj.fromLonLat(this.position)));
    }

    this.updateIcon();

    if (!this.marker.visible) {
        this.marker.visible = true;
        PlaneIconFeatures.addFeature(this.marker);
    }
};


// return the styling of the lines based on altitude
function altitudeLines (segment) {
    var colorArr = altitudeColor(segment.altitude);
    if (segment.estimated)
        colorArr = [colorArr[0], colorArr[1], colorArr[2] * 0.7];
    //var color = 'hsl(' + colorArr[0].toFixed(0) + ', ' + colorArr[1].toFixed(0) + '%, ' + colorArr[2].toFixed(0) + '%)';

    var color = hslToRgb(colorArr[0], colorArr[1], colorArr[2]);

    if (monochromeTracks)
        color = monochromeTracks;

    const lineKey = color + '_' + debugTracks + '_' + noVanish + '_' + segment.estimated + '_' + newWidth;

    if (lineStyleCache[lineKey])
        return lineStyleCache[lineKey];

    var estimatedMult = segment.estimated ? 0.3 : 1

    if (!debugTracks) {
        lineStyleCache[lineKey]	= new ol.style.Style({
            stroke: new ol.style.Stroke({
                color: color,
                width: (2-(noVanish*0.8)) * newWidth * estimatedMult,
                lineJoin: 'miter',
                lineCap: 'square',
            })
        });
    } else {
        lineStyleCache[lineKey] = [
            new ol.style.Style({
                image: new ol.style.Circle({
                    radius: 2 * newWidth,
                    fill: new ol.style.Fill({
                        color: color
                    })
                }),
                geometry: function(feature) {
                    return new ol.geom.MultiPoint(feature.getGeometry().getCoordinates());
                }
            }),
            new ol.style.Style({
                stroke: new ol.style.Stroke({
                    color: color,
                    width: 2 * newWidth * estimatedMult,
                })
            })
        ];
    }
    return lineStyleCache[lineKey];
}

// Update our planes tail line,
PlaneObject.prototype.updateLines = function() {
    if (!this.visible || this.position == null || (!this.selected && !SelectedAllPlanes) || this.isFiltered())
        return this.clearLines();

    if (this.track_linesegs.length == 0)
        return;

    this.checkLayers();

    var trail_add = [];
    var label_add = [];

    if (!this.layer.getVisible())
        this.layer.setVisible(true);

    if (trackLabels || showTrace) {
        if (!this.layer_labels.getVisible())
            this.layer_labels.setVisible(true);
    } else if (this.layer_labels && this.layer_labels.getVisible()) {
        this.layer_labels.setVisible(false);
    }

    // create the new elastic band feature
    if (this.elastic_feature)
        this.trail_features.removeFeature(this.elastic_feature);

    var lastseg = this.track_linesegs[this.track_linesegs.length - 1];
    var lastfixed = lastseg.fixed.getCoordinateAt(1.0);
    var geom = new ol.geom.LineString([lastfixed, ol.proj.fromLonLat(this.position)]);


    this.elastic_feature = new ol.Feature(geom);
    if (filterTracks && this.altFiltered(lastseg.altitude)) {
        this.elastic_feature.setStyle(nullStyle);
    } else {
        this.elastic_feature.setStyle(altitudeLines(lastseg));
    }

    trail_add.push(this.elastic_feature);

    // create any missing fixed line features

    for (var i = this.track_linesegs.length-1; i >= 0; i--) {
        var seg = this.track_linesegs[i];
        if (seg.feature && (!trackLabels || seg.label))
            break;

        if ((filterTracks && this.altFiltered(seg.altitude)) || altitudeLines(seg) == nullStyle) {
            seg.feature = true;
        } else if (!seg.feature) {
            seg.feature = new ol.Feature(seg.fixed);
            seg.feature.setStyle(altitudeLines(seg));
            seg.feature.hex = this.icao;
            trail_add.push(seg.feature);
        }

        if (filterTracks && this.altFiltered(seg.altitude)) {
            seg.label = true;
        } else if ((trackLabels || ((i == 0 || i == this.track_linesegs.length-1 ||seg.leg) && showTrace && enableLabels)) && !seg.label) {
            const alt_real = (seg.alt_real != null) ? seg.alt_real : 'n/a';
            seg.label = new ol.Feature(new ol.geom.Point(seg.fixed.getFirstCoordinate()));
            var timestamp;
                const date = new Date(seg.ts * 1000);
            if (showTrace) {
                timestamp =
                    date.getUTCHours().toString().padStart(2,'0')
                    + ":" + date.getUTCMinutes().toString().padStart(2,'0')
                    + ":" + date.getUTCSeconds().toString().padStart(2,'0');
                timestamp = "".padStart(0, NBSP) + timestamp + NBSP + "Z";

                timestamp = "".padStart(0, NBSP) + getDateString(date) + '\n' + timestamp;
            } else {
                timestamp = date.getHours().toString().padStart(2,'0')
                    + ":" + date.getMinutes().toString().padStart(2,'0')
                    + ":" + date.getSeconds().toString().padStart(2,'0');
                timestamp = "".padStart(2, NBSP) + timestamp;
            }
            var text =
                Number(seg.speed).toFixed(0).toString().padStart(3, NBSP) + "  "
                + (alt_real == "ground" ? ("Ground") : (alt_real.toString().padStart(6, NBSP)))
                + "\n"
                //+ NBSP + format_track_arrow(seg.track)
                + timestamp;

            if (showTrace && !trackLabels)
                text = timestamp;

            var fill = labelFill;
            var zIndex = -i;
            if (seg.leg == 'start') {
                fill = new ol.style.Fill({color: '#88CC88' });
                zIndex = 123456;
            }
            if (seg.leg == 'end') {
                fill = new ol.style.Fill({color: '#8888CC' });
                zIndex = 123455;
            }
            seg.label.setStyle(
                new ol.style.Style({
                    text: new ol.style.Text({
                        text: text,
                        fill: fill,
                        stroke: labelStroke,
                        textAlign: 'left',
                        textBaseline: "top",
                        font: labelFont,
                        offsetX: 8 * globalScale,
                        offsetY: 8 * globalScale,
                    }),
                    image: new ol.style.Circle({
                        radius: 2 * globalScale,
                        fill: blackFill,
                    }),
                    zIndex: zIndex,
                })
            );
            seg.label.hex = this.icao;
            label_add.push(seg.label)
        }
    }

    if (trail_add.length > 0)
        this.trail_features.addFeatures(trail_add);
    if (this.trail_labels && label_add.length > 0)
        this.trail_labels.addFeatures(label_add);

};

PlaneObject.prototype.remakeTrail = function() {

    if (this.trail_features)
        this.trail_features.clear();
    if (this.trail_labels)
        this.trail_labels.clear();

    for (var i in this.track_linesegs) {
        this.track_linesegs[i].feature = undefined;
        this.track_linesegs[i].label = undefined;
    }
    this.elastic_feature = null;

    /*
    trailGroup.remove(this.layer);

    this.trail_features = new ol.Collection();

    this.layer = new ol.layer.Vector({
        name: this.icao,
        isTrail: true,
        source: new ol.source.Vector({
            features: this.trail_features,
        }),
        renderOrder: null,
    });

    trailGroup.push(this.layer);
    */

}

PlaneObject.prototype.makeTR = function() {

    this.tr = PlaneRowTemplate.cloneNode(true);

    if (this.icao[0] === '~') {
        // Non-ICAO address
        this.tr.cells[0].textContent = this.icao.substring(1);
        $(this.tr).css('font-style', 'italic');
    } else {
        this.tr.cells[0].textContent = this.icao;
    }

    // set flag image if available
    if (ShowFlags && this.icaorange.flag_image !== null) {
        $('img', this.tr.cells[1]).attr('src', FlagPath + this.icaorange.flag_image);
        $('img', this.tr.cells[1]).attr('title', this.icaorange.country);
    } else {
        $('img', this.tr.cells[1]).css('display', 'none');
    }

    this.clickListener = function(evt) {
        if (evt.srcElement instanceof HTMLAnchorElement) {
            evt.stopPropagation();
            return;
        }

        if(!mapIsVisible) {
            selectPlaneByHex(this.icao, {follow: true});
            //showMap();
        } else {
            selectPlaneByHex(this.icao, {follow: false});
        }
        evt.preventDefault();
    }.bind(this);

    if (!globeIndex) {
        this.dblclickListener = function(evt) {
            if(!mapIsVisible) {
                showMap();
            }
            selectPlaneByHex(this.icao, {follow: true});
            evt.preventDefault();
        }.bind(this);

        this.tr.addEventListener('dblclick', this.dblclickListener);
    }

    this.tr.addEventListener('click', this.clickListener);
}

PlaneObject.prototype.destroy = function() {
    this.clearLines();
    this.clearMarker();
    this.visible = false;
    if (this.layer) {
        trailGroup.remove(this.layer);
        this.trail_features.clear();
        this.layer = null;
    }
    if (this.layer_labels) {
        trailGroup.remove(this.layer_labels);
        this.trail_labels.clear();
        this.layer_labels = null;
    }
    if (this.tr) {
        var tbody = document.getElementById('tableinfo').tBodies[0];
        if (!this.inTable) {
            tbody.appendChild(this.tr);
        }

        this.tr.removeEventListener('click', this.clickListener);
        this.tr.removeEventListener('dblclick', this.dblclickListener);

        tbody.removeChild(this.tr);

        if (this.tr.parentNode)
            this.tr.parentNode.removeChild(this.tr);
        this.tr = null;
    }
    if (this.icao == SelectedPlane)
        SelectedPlane = null;
    for (var key in Object.keys(this)) {
        delete this[key];
    }
};

function calcAltitudeRounded(altitude) {
    if (altitude == null) {
        return null;
    } else if (altitude == "ground") {
        return altitude;
    } else if (altitude > 8000) {
        return (altitude/500).toFixed(0)*500;
    } else {
        return (altitude/125).toFixed(0)*125;
    }
}

PlaneObject.prototype.drawRedDot = function(bad_position) {
    this.checkLayers();
    if (debugJump && loadFinished && SelectedPlane != this) {
        OLMap.getView().setCenter(ol.proj.fromLonLat(bad_position));
        selectPlaneByHex(this.icao, false);
    }
    var badFeat = new ol.Feature(new ol.geom.Point(ol.proj.fromLonLat(bad_position)));
    badFeat.setStyle(this.dataSource == "mlat"  ? badDotMlat : badDot);
    this.trail_features.addFeature(badFeat);
    var geom = new ol.geom.LineString([ol.proj.fromLonLat(this.prev_position), ol.proj.fromLonLat(bad_position)]);
    var lineFeat = new ol.Feature(geom);
    lineFeat.setStyle(this.dataSource == "mlat" ? badLineMlat : badLine);
    this.trail_features.addFeature(lineFeat);
}

/**
 * Converts an HSL color value to RGB. Conversion formula
 * adapted from http://en.wikipedia.org/wiki/HSL_color_space.
 * Assumes h, s, and l are contained in the set [0, 1] and
 * returns r, g, and b in the set [0, 255].
 *
 * @param   {number}  h       The hue
 * @param   {number}  s       The saturation
 * @param   {number}  l       The lightness
 * @return  {Array}           The RGB representation
 */
function hslToRgb(h, s, l){
    var r, g, b;

    h /= 360;
    s *= 0.01;
    l *= 0.01;

    if(s == 0){
        r = g = b = l; // achromatic
    }else{
        var hue2rgb = function hue2rgb(p, q, t){
            if(t < 0) t += 1;
            if(t > 1) t -= 1;
            if(t < 1/6) return p + (q - p) * 6 * t;
            if(t < 1/2) return q;
            if(t < 2/3) return p + (q - p) * (2/3 - t) * 6;
            return p;
        }

        var q = l < 0.5 ? l * (1 + s) : l + s - l * s;
        var p = 2 * l - q;
        r = hue2rgb(p, q, h + 1/3);
        g = hue2rgb(p, q, h);
        b = hue2rgb(p, q, h - 1/3);
    }

    return 'rgb(' + Math.round(r * 255) + ', ' + Math.round(g * 255) + ', ' +  Math.round(b * 255) + ')';
}

PlaneObject.prototype.altBad = function(newAlt, oldAlt, oldTime, data) {
    var max_fpm = 12000;
    if (data.geom_rate != null)
        max_fpm = 1.3*Math.abs(data.goem_rate) + 5000;
    else if (data.baro_rate != null)
        max_fpm = 1.3*Math.abs(data.baro_rate) + 5000;

    const delta = Math.abs(newAlt - oldAlt);
    const fpm = (delta < 800) ? 0 : (60 * delta / (now - oldTime + 2));
    return fpm > max_fpm;
}
PlaneObject.prototype.getAircraftData = function() {
    var req = getAircraftData(this.icao);

    // military icao ranges
    if (this.milRange()) {
        this.military = true;
    }

    req.done(function(data) {
        if (data == null) {
            //console.log(this.icao + ': Not found in database!');
            return;
        }
        if (data == "strange") {
            //console.log(this.icao + ': Database malfunction!');
            return;
        }


        //console.log(this.icao + ': loaded!');
        // format [r:0, t:1, f:2]

        if (data[0]) {
            this.registration = data[0];
        }

        if (data[1]) {
            this.icaoType = data[1];
            this.icaoTypeCache = this.icaoType;
        }

        if (data[3]) {
            this.typeDescription = data[3];
        }

        if (data[4]) {
            this.wtc = data[4];
        }

        if (data[2]) {
            this.military = (data[2][0] == '1');
            this.interesting = (data[2][1] == '1');
        }
        if (this.selected) {
            refreshSelected();
        }

        this.updateMarker(true);

        data = null;
    }.bind(this));

    req.fail(function(jqXHR,textStatus,errorThrown) {
        if (textStatus == 'timeout')
            this.getAircraftData();
        else
            console.log(this.icao + ': Database load error: ' + textStatus + ' at URL: ' + jqXHR.url);
    }.bind(this));
}


PlaneObject.prototype.reapTrail = function() {
    const oldSegs = this.track_linesegs;
    this.track_linesegs = [];
    this.history_size = 0;
    for (var i in oldSegs) {
        const seg = oldSegs[i];
        if (seg.ts + tempTrailsTimeout > now) {
            this.history_size += seg.fixed.getCoordinates().length;
            this.track_linesegs.push(seg);
        }
    }
    if (this.track_linesegs.length != oldSegs.length) {
        this.remakeTrail();
        this.updateTick(true);
    }
}


PlaneObject.prototype.milRange = function() {
    return (
        false
        // us military
        //adf7c8-adf7cf = united states mil_5(uf)
        //adf7d0-adf7df = united states mil_4(uf)
        //adf7e0-adf7ff = united states mil_3(uf)
        //adf800-adffff = united states mil_2(uf)
        || this.icao.match(/^adf[7-9]/)
        || this.icao.match(/^adf[a-f]/)
        //ae0000-afffff = united states mil_1(uf)
        || this.icao.match(/^a(e|f)/)

        //010070-01008f = egypt_mil
        || this.icao.match(/^0100(7|8)/)

        //0a4000-0a4fff = algeria mil(ap)
        || this.icao.match(/^0a4/)

        //33ff00-33ffff = italy mil(iy)
        || this.icao.match(/^33ff/)

        //340000-37ffff = spain mil(sp)
        || this.icao.match(/^34/)

        //3a8000-3affff = france mil_1(fs)
        || this.icao.match(/^3(8|9|[a-f])/)
        //3b0000-3bffff = france mil_2(fs)
        || this.icao.match(/^3b/)

        //3e8000-3ebfff = germany mil_1(df)
        || this.icao.match(/^3e(8|9|a|b)/)
        //3f4000-3f7fff = germany mil_2(df)
        //3f8000-3fbfff = germany mil_3(df)
        || this.icao.match(/^3f([4-9]|[a-b])/)

        //400000-40003f = united kingdom mil_1(ra)
        || this.icao.match(/^4000[0-3]/)
        //43c000-43ffff = united kingdom mil(ra)
        || this.icao.match(/^43[c-f]/)

        //444000-447fff = austria mil(aq)
        || this.icao.match(/^44[4-7]/)

        //44f000-44ffff = belgium mil(bc)
        || this.icao.match(/^44f/)

        //457000-457fff = bulgaria mil(bu)
        || this.icao.match(/^457/)

        //45f400-45f4ff = denmark mil(dg)
        || this.icao.match(/^45f4/)

        //468000-4683ff = greece mil(gc)
        || this.icao.match(/^468[0-3]/)

        //473c00-473c0f = hungary mil(hm)
        || this.icao.match(/^473c0/)

        //478100-4781ff = norway mil(nn)
        || this.icao.match(/^4781/)
        //480000-480fff = netherlands mil(nm)
        || this.icao.match(/^480/)
        //48d800-48d87f = poland mil(po)
        || this.icao.match(/^48d8[0-7]/)
        //497c00-497cff = portugal mil(pu)
        || this.icao.match(/^497c/)
        //498420-49842f = czech republic mil(ct)
        || this.icao.match(/^49842/)

        //4b7000-4b7fff = switzerland mil(su)
        || this.icao.match(/^4b7/)
        //4b8200-4b82ff = turkey mil(tq)
        || this.icao.match(/^4b82/)

        //506f00-506fff = slovenia mil(sj)
        || this.icao.match(/^506f/)

        //70c070-70c07f = oman mil(on)
        || this.icao.match(/^70c07/)

        //710258-71025f = saudi arabia mil_1(sx)
        //710260-71027f = saudi arabia mil_2(sx)
        //710280-71028f = saudi arabia mil_3(sx)
        //710380-71039f = saudi arabia mil_4(sx)
        || this.icao.match(/^7102[5-8]/)
        || this.icao.match(/^7103[8-9]/)

        //738a00-738aff = israel mil(iz)
        || this.icao.match(/^738a/)

        //7c822e-7c822f = australia mil_1(av)
        //7c8230-7c823f = australia mil_2(av)
        //7c8240-7c827f = australia mil_3(av)
        //7c8280-7c82ff = australia mil_4(av)
        //7c8300-7c83ff = australia mil_5(av)
        //7c8400-7c87ff = australia mil_6(av)
        //7c8800-7c8fff = australia mil_7(av)
        || this.icao.match(/^7c8([2-4]|8)/)
        //7c9000-7c9fff = australia mil_8(av)
        || this.icao.match(/^7c9/)
        //7ca000-7cbfff = australia mil_9(av)
        //7cc000-7cffff = australia mil_10(av)
        || this.icao.match(/^7c[a-c]/)
        //7d0000-7dffff = australia mil_11(av)
        //7e0000-7fffff = australia mil_12(av)
        || this.icao.match(/^7[d-f]/)

        //800200-8002ff = india mil(im)
        || this.icao.match(/^8002/)

        //c20000-c3ffff = canada mil(cb)
        || this.icao.match(/^c[2-3]/)

        //e40000-e41fff = brazil mil(bq)
        || this.icao.match(/^e4[0-1]/)

        //e80600-e806ff = chile mil(cq)
        || this.icao.match(/^e806/)



    );
}