@golemio/pid 2.14.1 → 2.14.2-dev.1355461560

package/dist/integration-engine/vehicle-positions/workers/vehicle-positions/helpers/PositionsManager.js

@@ -15,6 +15,12 @@ var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (
 }) : function(o, v) {
     o["default"] = v;
 });
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
 var __importStar = (this && this.__importStar) || function (mod) {
     if (mod && mod.__esModule) return mod;
     var result = {};
@@ -22,6 +28,12 @@ var __importStar = (this && this.__importStar) || function (mod) {
     __setModuleDefault(result, mod);
     return result;
 };
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
 var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
     function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
     return new (P || (P = Promise))(function (resolve, reject) {
@@ -34,21 +46,419 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
-var _a;
 Object.defineProperty(exports, "__esModule", { value: true });
-const turf = __importStar(require("@turf/turf"));
+exports.PositionsManager = void 0;
+const VPContainerToken_1 = require("../../../ioc/VPContainerToken");
 const moment_timezone_1 = __importDefault(require("@golemio/core/dist/shared/moment-timezone"));
+const tsyringe_1 = require("@golemio/core/dist/shared/tsyringe");
+const turf = __importStar(require("@turf/turf"));
 const const_1 = require("../../../../../const");
 const RouteTypeEnums_1 = require("../../../../../helpers/RouteTypeEnums");
 const DPPUtils_1 = __importDefault(require("./DPPUtils"));
 const DateTimeUtils_1 = require("./DateTimeUtils");
 const PositionHandlerEnum_1 = require("./PositionHandlerEnum");
-const ValidToCalculator_1 = __importDefault(require("./ValidToCalculator"));
+const ValidToCalculator_1 = require("./ValidToCalculator");
 const AnchorPointSegmenter_1 = require("./anchor-points/AnchorPointSegmenter");
 const ComputeDelayHelper_1 = __importDefault(require("./compute-positions/ComputeDelayHelper"));
 const ONE_DAY_IN_SECONDS = 24 * 60 * 60;
 const ONE_SECOND_IN_MILLIS = 1000;
-class PositionsManager {
+let PositionsManager = exports.PositionsManager = class PositionsManager {
+    constructor(validToCalculator) {
+        this.validToCalculator = validToCalculator;
+        /**
+         * Compute positions and return computed positions
+         *
+         * @param {ITripPositionsWithGTFS} tripPositions - Trip positions with shape anchors data
+         * @returns {Promise<IProcessedPositions>} - Returns computed/updated positions
+         */
+        this.computePositions = (tripPositions, schedule) => __awaiter(this, void 0, void 0, function* () {
+            const startTimestamp = tripPositions.start_timestamp.getTime();
+            const startDayTimestamp = this.getStartDayTimestamp(startTimestamp, tripPositions.gtfsData.shapes_anchor_points[0].time_scheduled_seconds);
+            const gtfsRouteType = tripPositions.gtfs_route_type;
+            const context = this.getCurrentContext(tripPositions);
+            const computedPositions = [];
+            const endTimestamp = tripPositions.end_timestamp;
+            return this.updatePositions({ tripPositions, startTimestamp, endTimestamp, startDayTimestamp, context, computedPositions, gtfsRouteType }, schedule);
+        });
+        /**
+         * Takes position one by one, set proper handler for type of position, and do the process of position
+         *
+         * @param {number} i - Iteration
+         * @param {IUpdatePositionsIteratorOptions} options - Initial options
+         * @param {number} cb - Callback function of iterator
+         * @returns {void} - void
+         */
+        this.updatePositions = (options, schedule) => __awaiter(this, void 0, void 0, function* () {
+            var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o;
+            const { tripPositions, startDayTimestamp, startTimestamp, endTimestamp, context, computedPositions, gtfsRouteType } = options;
+            for (let i = 0; i < tripPositions.positions.length; i++) {
+                const position = tripPositions.positions[i];
+                let positionToUpdate = null;
+                // situations
+                switch (this.setPositionUpdateHandler(position)) {
+                    case PositionHandlerEnum_1.PositionHandlerEnum.TRACKING:
+                        const currentPosition = turf.point([position.lng, position.lat], {
+                            id: position.id,
+                            origin_time: position.origin_time,
+                            origin_timestamp: position.origin_timestamp,
+                            scheduled_timestamp: position.scheduled_timestamp,
+                            this_stop_id: position.this_stop_id,
+                            tcp_event: position.tcp_event,
+                        });
+                        positionToUpdate = this.getEstimatedPoint(tripPositions.gtfsData, currentPosition, context, startDayTimestamp, tripPositions.gtfs_route_type);
+                        if (positionToUpdate.state_position !== const_1.StatePositionEnum.MISMATCHED) {
+                            positionToUpdate = ComputeDelayHelper_1.default.updatePositionToUpdate(context, positionToUpdate, position, gtfsRouteType);
+                        }
+                        positionToUpdate.bearing = (_a = position.bearing) !== null && _a !== void 0 ? _a : positionToUpdate.bearing;
+                        break;
+                    case PositionHandlerEnum_1.PositionHandlerEnum.NOT_TRACKING:
+                        // if there is no previous positions with tracking status, set position as before_track
+                        const firstShapesAnchorPoint = tripPositions.gtfsData.shapes_anchor_points[0];
+                        if (context.lastPositionTracking === null &&
+                            (endTimestamp === null ||
+                                position.scheduled_timestamp === null ||
+                                endTimestamp > position.scheduled_timestamp)) {
+                            const firstStopTime = tripPositions.gtfsData.stop_times[0];
+                            // if there is propagated delay we can use it for new position
+                            const lastPositionDelayed = context.lastPositionBeforeTrackDelayed;
+                            // if there is no delay to duplicate and DPP trip is far from start then invisible
+                            const setAsInvisible = !lastPositionDelayed &&
+                                DPPUtils_1.default.isInvisible(tripPositions.agency_name_scheduled, position.origin_timestamp, startTimestamp, [position.lng, position.lat], firstShapesAnchorPoint.coordinates, schedule, tripPositions.gtfs_trip_id, context.lastPositionTracking, position.is_tracked);
+                            positionToUpdate = Object.assign({ id: position.id, next_stop_arrival_time: new Date(startDayTimestamp + firstStopTime.arrival_time_seconds * 1000), next_stop_departure_time: new Date(startDayTimestamp + firstStopTime.departure_time_seconds * 1000), next_stop_id: firstStopTime.stop_id, next_stop_sequence: firstStopTime.stop_sequence, next_stop_name: firstStopTime.stop.stop_name, shape_dist_traveled: firstStopTime.shape_dist_traveled, state_position: setAsInvisible ? const_1.StatePositionEnum.INVISIBLE : const_1.StatePositionEnum.BEFORE_TRACK, state_process: const_1.StateProcessEnum.PROCESSED }, (firstStopTime.stop_headsign && {
+                                last_stop_headsign: firstStopTime.stop_headsign,
+                            }));
+                            if (positionToUpdate.state_position === const_1.StatePositionEnum.BEFORE_TRACK) {
+                                positionToUpdate.delay = this.getDelayBeforeTrack((_b = lastPositionDelayed === null || lastPositionDelayed === void 0 ? void 0 : lastPositionDelayed.delay) !== null && _b !== void 0 ? _b : position.delay, firstStopTime.departure_time_seconds, position.origin_timestamp.getTime(), startDayTimestamp);
+                            }
+                        }
+                        else {
+                            // if there is tracking 2 position with same origin_timestamp then this position is duplicate
+                            const statePosition = position.origin_timestamp.getTime() === context.lastPositionOriginTimestamp ||
+                                tripPositions.positions.findIndex((positionItem) => positionItem.origin_timestamp.getTime() === position.origin_timestamp.getTime() &&
+                                    positionItem.is_tracked) >= 0
+                                ? const_1.StatePositionEnum.DUPLICATE
+                                : const_1.StatePositionEnum.AFTER_TRACK;
+                            const lastShapesAnchorPoint = tripPositions.gtfsData.shapes_anchor_points[tripPositions.gtfsData.shapes_anchor_points.length - 1];
+                            const lastStopTime = tripPositions.gtfsData.stop_times[tripPositions.gtfsData.stop_times.length - 1];
+                            // set as invisible if there are some AFTER_TRACK before
+                            const setAsInvisible = DPPUtils_1.default.isInvisible(tripPositions.agency_name_scheduled, position.origin_timestamp, startTimestamp, [position.lng, position.lat], firstShapesAnchorPoint.coordinates, schedule, tripPositions.gtfs_trip_id, context.lastPositionTracking, position.is_tracked) && statePosition === const_1.StatePositionEnum.AFTER_TRACK;
+                            positionToUpdate = Object.assign({ id: position.id, last_stop_arrival_time: new Date(startDayTimestamp + lastShapesAnchorPoint.time_scheduled_seconds * 1000), last_stop_departure_time: new Date(startDayTimestamp + lastShapesAnchorPoint.time_scheduled_seconds * 1000), last_stop_id: lastStopTime.stop_id, last_stop_sequence: lastShapesAnchorPoint.last_stop_sequence, shape_dist_traveled: lastShapesAnchorPoint.shape_dist_traveled, state_position: setAsInvisible ? const_1.StatePositionEnum.INVISIBLE : statePosition, state_process: const_1.StateProcessEnum.PROCESSED, delay: (_c = position.delay) !== null && _c !== void 0 ? _c : null }, (lastStopTime.stop_headsign && {
+                                last_stop_headsign: lastStopTime.stop_headsign,
+                            }));
+                            positionToUpdate = ComputeDelayHelper_1.default.updatePositionToUpdate(context, positionToUpdate, position, gtfsRouteType);
+                        }
+                        break;
+                    case PositionHandlerEnum_1.PositionHandlerEnum.CANCELED:
+                        positionToUpdate = {
+                            id: position.id,
+                            lat: (_f = (_d = position.lat) !== null && _d !== void 0 ? _d : (_e = context.lastPositionTracking) === null || _e === void 0 ? void 0 : _e.geometry.coordinates[1]) !== null && _f !== void 0 ? _f : null,
+                            lng: (_j = (_g = position.lng) !== null && _g !== void 0 ? _g : (_h = context.lastPositionTracking) === null || _h === void 0 ? void 0 : _h.geometry.coordinates[0]) !== null && _j !== void 0 ? _j : null,
+                            state_position: const_1.StatePositionEnum.CANCELED,
+                            state_process: const_1.StateProcessEnum.PROCESSED,
+                        };
+                        if (positionToUpdate.lat === null || positionToUpdate.lng === null) {
+                            positionToUpdate = null;
+                        }
+                        break;
+                    case PositionHandlerEnum_1.PositionHandlerEnum.DO_NOTHING:
+                        break;
+                    default:
+                        break;
+                }
+                // if not null push to update
+                if (positionToUpdate) {
+                    (_k = positionToUpdate.is_tracked) !== null && _k !== void 0 ? _k : (positionToUpdate.is_tracked = position.is_tracked);
+                    positionToUpdate.valid_to = this.validToCalculator.getValidToAttribute(positionToUpdate, position, gtfsRouteType, tripPositions.gtfsData, startTimestamp);
+                    computedPositions.push(positionToUpdate);
+                }
+                context.lastPositionState = (_l = positionToUpdate === null || positionToUpdate === void 0 ? void 0 : positionToUpdate.state_position) !== null && _l !== void 0 ? _l : position.state_position;
+                // set last known BEFORE_TRACK_DELAYED position
+                if (position.state_position === const_1.StatePositionEnum.BEFORE_TRACK_DELAYED) {
+                    context.lastPositionBeforeTrackDelayed = {
+                        delay: (_m = positionToUpdate === null || positionToUpdate === void 0 ? void 0 : positionToUpdate.delay) !== null && _m !== void 0 ? _m : position.delay,
+                        origin_timestamp: (_o = positionToUpdate === null || positionToUpdate === void 0 ? void 0 : positionToUpdate.origin_timestamp) !== null && _o !== void 0 ? _o : position.origin_timestamp,
+                    };
+                }
+                // set last position tracking (only for at_stop and on_track)
+                if ((positionToUpdate === null || positionToUpdate === void 0 ? void 0 : positionToUpdate.state_position) === const_1.StatePositionEnum.AT_STOP ||
+                    (positionToUpdate === null || positionToUpdate === void 0 ? void 0 : positionToUpdate.state_position) === const_1.StatePositionEnum.ON_TRACK ||
+                    position.state_position === const_1.StatePositionEnum.AT_STOP ||
+                    position.state_position === const_1.StatePositionEnum.ON_TRACK) {
+                    context.lastPositionTracking = turf.point([position.lng, position.lat], Object.assign(Object.assign({}, position), positionToUpdate));
+                }
+                // set new first position at stop streak if this stop seqence is set and it is not same as before
+                if (positionToUpdate
+                    ? positionToUpdate.this_stop_sequence &&
+                        context.atStopStreak.stop_sequence !== positionToUpdate.this_stop_sequence
+                    : position.this_stop_sequence && context.atStopStreak.stop_sequence !== position.this_stop_sequence) {
+                    context.atStopStreak.stop_sequence = positionToUpdate
+                        ? positionToUpdate.this_stop_sequence
+                        : position.this_stop_sequence;
+                    context.atStopStreak.firstPositionTimestamp = position.origin_timestamp.getTime();
+                    context.atStopStreak.firstPositionDelay = positionToUpdate ? positionToUpdate.delay : position.delay;
+                }
+                // IF currently valid updated position / position was processed before
+                // and it is NOT AT_STOP
+                // then disrupt atStopStreak
+                if (positionToUpdate &&
+                    positionToUpdate.state_position !== const_1.StatePositionEnum.MISMATCHED &&
+                    !positionToUpdate.this_stop_sequence) {
+                    context.atStopStreak.stop_sequence = null;
+                }
+                else if (!positionToUpdate && !position.this_stop_sequence) {
+                    context.atStopStreak.stop_sequence = null;
+                }
+                // duplicated or mismatched position should not be considered at all
+                if ((positionToUpdate === null || positionToUpdate === void 0 ? void 0 : positionToUpdate.state_position) !== const_1.StatePositionEnum.DUPLICATE &&
+                    (positionToUpdate === null || positionToUpdate === void 0 ? void 0 : positionToUpdate.state_position) !== const_1.StatePositionEnum.INVISIBLE &&
+                    (positionToUpdate === null || positionToUpdate === void 0 ? void 0 : positionToUpdate.state_position) !== const_1.StatePositionEnum.MISMATCHED) {
+                    context.lastPositionId = position.id;
+                    context.lastPositionCanceled = position.is_canceled;
+                    context.lastPositionOriginTimestamp = position.origin_timestamp.getTime();
+                    ComputeDelayHelper_1.default.updateContext(context, positionToUpdate, position, gtfsRouteType);
+                }
+            }
+            return {
+                context,
+                positions: computedPositions,
+            };
+        });
+        this.getCurrentContext = (tripPositions) => {
+            var _a;
+            const context = (_a = tripPositions.last_position_context) !== null && _a !== void 0 ? _a : {
+                atStopStreak: {
+                    stop_sequence: null,
+                    firstPositionTimestamp: null,
+                    firstPositionDelay: null,
+                },
+                lastPositionLastStop: {
+                    id: null,
+                    sequence: null,
+                    arrival_time: null,
+                    arrival_delay: null,
+                    departure_time: null,
+                    departure_delay: null,
+                },
+                lastPositionDelay: null,
+                lastPositionId: null,
+                lastPositionOriginTimestamp: null,
+                lastPositionTracking: null,
+                lastPositionCanceled: null,
+                lastPositionBeforeTrackDelayed: null,
+                lastPositionState: null,
+                tripId: tripPositions.id,
+            };
+            return context;
+        };
+        /**
+         * Decide how to process input position data
+         *
+         * @param {IVPTripsPositionAttributes} position - Input vehiclepositions_positions row data
+         * @returns {PositionHandlerEnum} - Returns action handler enum
+         */
+        this.setPositionUpdateHandler = (position) => {
+            if (position.state_process === const_1.StateProcessEnum.PROCESSED)
+                return PositionHandlerEnum_1.PositionHandlerEnum.DO_NOTHING;
+            else if (position.is_canceled)
+                return PositionHandlerEnum_1.PositionHandlerEnum.CANCELED;
+            else if (position.is_tracked)
+                return PositionHandlerEnum_1.PositionHandlerEnum.TRACKING;
+            else
+                return PositionHandlerEnum_1.PositionHandlerEnum.NOT_TRACKING;
+        };
+        /**
+         * Returns estimate of point on shape, where the trip should be with appropriate delay
+         *
+         * @param {IShapeAnchorPoint[]} tripShapePoints - Precalculated trip shape equidistant points with scheduled times
+         * @param {Feature<Point, ICurrentPositionProperties>} currentPosition - Current position of trip
+         * @param {IVPTripsLastPositionContext | null} context - Context state, holds information about previous positions
+         * @param {number} startDayTimestamp - Unix timestamp of midnight before trip starts
+         * @returns {IPositionToUpdate} - Position object to update
+         */
+        this.getEstimatedPoint = (tripGtfsData, currentPosition, context, startDayTimestamp, gtfsRouteType) => {
+            var _a, _b, _c, _d, _e, _f, _g, _h;
+            const anchorPointSegmenter = new AnchorPointSegmenter_1.AnchorPointSegmenter(tripGtfsData.shapes_anchor_points, currentPosition);
+            const defaultStatePosition = const_1.StatePositionEnum.OFF_TRACK;
+            // Initial value
+            let estimatedPoint = Object.assign({ id: currentPosition.properties.id, state_position: defaultStatePosition, state_process: const_1.StateProcessEnum.PROCESSED, tcp_event: currentPosition.properties.tcp_event, valid_to: this.validToCalculator.getDefaultValidToAttribute(currentPosition.properties.origin_timestamp) }, (context &&
+                ((_a = context.lastPositionTracking) === null || _a === void 0 ? void 0 : _a.properties.last_stop_sequence) && {
+                shape_dist_traveled: (_b = context.lastPositionTracking) === null || _b === void 0 ? void 0 : _b.properties.shape_dist_traveled,
+                last_stop_arrival_time: ((_c = context.lastPositionTracking) === null || _c === void 0 ? void 0 : _c.properties.last_stop_arrival_time)
+                    ? new Date((_d = context.lastPositionTracking) === null || _d === void 0 ? void 0 : _d.properties.last_stop_arrival_time)
+                    : undefined,
+                last_stop_departure_time: ((_e = context.lastPositionTracking) === null || _e === void 0 ? void 0 : _e.properties.last_stop_departure_time)
+                    ? new Date((_f = context.lastPositionTracking) === null || _f === void 0 ? void 0 : _f.properties.last_stop_departure_time)
+                    : undefined,
+                last_stop_sequence: (_g = context.lastPositionTracking) === null || _g === void 0 ? void 0 : _g.properties.last_stop_sequence,
+                last_stop_id: (_h = context.lastPositionTracking) === null || _h === void 0 ? void 0 : _h.properties.last_stop_id,
+            }));
+            let lastStopSequence = null;
+            if ((context === null || context === void 0 ? void 0 : context.lastPositionState) === const_1.StatePositionEnum.BEFORE_TRACK) {
+                lastStopSequence = 1;
+            }
+            else if (context === null || context === void 0 ? void 0 : context.lastPositionTracking) {
+                lastStopSequence = context.lastPositionTracking.properties.last_stop_sequence;
+            }
+            const closesPoint = anchorPointSegmenter.getClosesPoint(lastStopSequence);
+            if (!closesPoint) {
+                return estimatedPoint;
+            }
+            return this.getClosestPoint(currentPosition, context, startDayTimestamp, closesPoint, tripGtfsData, gtfsRouteType);
+        };
+        /**
+         * Picks only one closest point for multiple possible points based on delay of last position and stop times
+         *
+         * @param {Feature<Point, ICurrentPositionProperties>} currentPosition - Feature Point of current position
+         * @param {IVPTripsLastPositionContext | null} context - Context state, holds information about previous positions
+         * @param {number} startDayTimestamp - Unix timestamp of start of the day
+         * @param {IShapeAnchorPoint[]} closestPts - All closest points of possible segments
+         * @param {IComputationTrip} tripGtfsData - GTFS data and all set of known positions
+         * @returns {IPositionToUpdate} - Result point as position to update in DB
+         */
+        this.getClosestPoint = (currentPosition, context, startDayTimestamp, thisClosestPoint, tripGtfsData, gtfsRouteType) => {
+            // want to find minimum difference of our prediction, where the bus should be
+            const tripShapePoints = tripGtfsData.shapes_anchor_points;
+            const tripStopTimes = tripGtfsData.stop_times;
+            const firstTripShapePoint = tripShapePoints[0];
+            const lastTripShapePoint = tripShapePoints[tripShapePoints.length - 1];
+            const timeScheduledTimestamp = DateTimeUtils_1.DateTimeUtils.getStopDateTimeForDayStart(
+            // take stop arrival time if is point at stop
+            thisClosestPoint.this_stop_sequence
+                ? tripStopTimes[thisClosestPoint.this_stop_sequence - 1].arrival_time_seconds
+                : thisClosestPoint.time_scheduled_seconds, startDayTimestamp);
+            let timeDelayInSeconds = Math.round((currentPosition.properties.origin_timestamp.getTime() - timeScheduledTimestamp.getTime()) / 1000);
+            const isBusOrTram = gtfsRouteType === RouteTypeEnums_1.GTFSRouteTypeEnum.BUS ||
+                gtfsRouteType === RouteTypeEnums_1.GTFSRouteTypeEnum.TROLLEYBUS ||
+                gtfsRouteType === RouteTypeEnums_1.GTFSRouteTypeEnum.TRAM;
+            // push trip into nearest at_stop shape anchor point if trip "P" event  (TCP tram or bus)
+            if (isBusOrTram &&
+                currentPosition.properties.tcp_event === const_1.TCPEventEnum.ARRIVAL_ANNOUNCED &&
+                thisClosestPoint.this_stop_sequence === null) {
+                if (thisClosestPoint.last_stop_sequence === 1 && !(context === null || context === void 0 ? void 0 : context.lastPositionTracking)) {
+                    thisClosestPoint = firstTripShapePoint;
+                }
+                else {
+                    let movingShapePointIndex = thisClosestPoint.index;
+                    while (thisClosestPoint.this_stop_sequence === null && movingShapePointIndex < lastTripShapePoint.index) {
+                        movingShapePointIndex++;
+                        thisClosestPoint = tripShapePoints[movingShapePointIndex];
+                    }
+                }
+            }
+            // lets correct delay if it is at stop
+            if (thisClosestPoint.this_stop_sequence) {
+                const thisStopSequence = thisClosestPoint.this_stop_sequence;
+                timeDelayInSeconds = this.getCorrectedTimeDelay(timeDelayInSeconds, context, currentPosition, thisStopSequence, {
+                    departureTime: tripStopTimes[thisStopSequence - 1].departure_time_seconds,
+                    arrivalTime: tripStopTimes[thisStopSequence - 1].arrival_time_seconds,
+                });
+                // delay can not be negative if the vehicle is at the first stop
+                if (thisStopSequence === firstTripShapePoint.this_stop_sequence) {
+                    timeDelayInSeconds = Math.max(timeDelayInSeconds, 0);
+                }
+            }
+            let { statePosition, thisStopSequence, lastStopSequence, nextStopSequence } = this.getStateAndStopSequences(gtfsRouteType, tripStopTimes, thisClosestPoint, currentPosition.properties, context);
+            // test if TCP trip with DEPARTURED event should not be at stop (not applied for last stop)
+            if (currentPosition.properties.tcp_event === const_1.TCPEventEnum.DEPARTURED &&
+                thisStopSequence !== lastTripShapePoint.this_stop_sequence) {
+                statePosition = const_1.StatePositionEnum.ON_TRACK;
+            }
+            if (isBusOrTram && this.isAfterTrack(lastStopSequence, lastTripShapePoint)) {
+                statePosition = const_1.StatePositionEnum.AFTER_TRACK;
+                thisStopSequence = lastTripShapePoint.this_stop_sequence;
+                lastStopSequence = lastTripShapePoint.last_stop_sequence;
+                nextStopSequence = lastTripShapePoint.next_stop_sequence;
+                timeDelayInSeconds = 0;
+            }
+            // save it for result
+            const estimatedPoint = {
+                id: currentPosition.properties.id,
+                bearing: thisClosestPoint.bearing,
+                shape_dist_traveled: thisClosestPoint.shape_dist_traveled,
+                next_stop_id: tripStopTimes[nextStopSequence - 1].stop_id,
+                last_stop_id: tripStopTimes[lastStopSequence - 1].stop_id,
+                next_stop_name: tripStopTimes[nextStopSequence - 1].stop.stop_name,
+                last_stop_name: tripStopTimes[lastStopSequence - 1].stop.stop_name,
+                next_stop_sequence: nextStopSequence,
+                last_stop_sequence: lastStopSequence,
+                next_stop_arrival_time: DateTimeUtils_1.DateTimeUtils.getStopDateTimeForDayStart(tripStopTimes[nextStopSequence - 1].arrival_time_seconds, startDayTimestamp),
+                last_stop_arrival_time: DateTimeUtils_1.DateTimeUtils.getStopDateTimeForDayStart(tripStopTimes[lastStopSequence - 1].arrival_time_seconds, startDayTimestamp),
+                next_stop_departure_time: DateTimeUtils_1.DateTimeUtils.getStopDateTimeForDayStart(tripStopTimes[nextStopSequence - 1].departure_time_seconds, startDayTimestamp),
+                last_stop_departure_time: DateTimeUtils_1.DateTimeUtils.getStopDateTimeForDayStart(tripStopTimes[lastStopSequence - 1].departure_time_seconds, startDayTimestamp),
+                delay: timeDelayInSeconds,
+                this_stop_id: (statePosition === const_1.StatePositionEnum.AT_STOP &&
+                    thisStopSequence &&
+                    tripStopTimes[thisStopSequence - 1].stop_id) ||
+                    undefined,
+                this_stop_name: (statePosition === const_1.StatePositionEnum.AT_STOP &&
+                    thisStopSequence &&
+                    tripStopTimes[thisStopSequence - 1].stop.stop_name) ||
+                    undefined,
+                this_stop_sequence: (statePosition === const_1.StatePositionEnum.AT_STOP && thisStopSequence) || undefined,
+                last_stop_headsign: tripStopTimes[lastStopSequence - 1].stop_headsign || undefined,
+                state_position: statePosition,
+                state_process: const_1.StateProcessEnum.PROCESSED,
+                valid_to: this.validToCalculator.getDefaultValidToAttribute(currentPosition.properties.origin_timestamp),
+                is_tracked: statePosition !== const_1.StatePositionEnum.AFTER_TRACK && statePosition !== const_1.StatePositionEnum.MISMATCHED,
+            };
+            return estimatedPoint;
+        };
+        /**
+         * Corrects time delay at stop with dwelling time
+         *
+         * @param {number} timeDelay - Initial computed delay in seconds, can be negative for trip ahead
+         * @param {IVPTripsLastPositionContext | null} context - Context state, holds information about previous positions
+         * @param {Feature<Point, ICurrentPositionProperties>} currentPosition - Feature Point of current position
+         * @param {IShapeAnchorPoint} thisClosestPoint - Closest point of shape anchors
+         * @param { departureTime: number; arrivalTime: number } stopTimes - departure and arrival stop times in seconds
+         * @returns {number} - Result delay in seconds, can be negative for trip ahead
+         */
+        this.getCorrectedTimeDelay = (timeDelay, context, currentPosition, thisStopSequence, stopTimes) => {
+            // compute dwell time in stop, most common is zero
+            const stopDwellTimeSeconds = stopTimes.departureTime - stopTimes.arrivalTime;
+            // if dwell time is sheduled as zero, return initial computed delay
+            if (stopDwellTimeSeconds <= 0) {
+                return timeDelay;
+            }
+            // if last position was not in this same stop or there is no last position at all
+            if (!context || context.atStopStreak.stop_sequence !== thisStopSequence) {
+                // timeDelay >= 0 trip is DELAYED
+                // we presume it will lower delay by shortening its scheduled dwell time,
+                // cant go under zero of course, trip should not go ahead
+                // else trip is AHeAD
+                // left computed delay as it was
+                return timeDelay >= 0 ? Math.max(timeDelay - stopDwellTimeSeconds, 0) : timeDelay;
+            }
+            // we presume that first position at same stop is real arrival time
+            if (context.atStopStreak.firstPositionDelay >= 0) {
+                // trip was DELAYED before
+                // we presume it will lower delay by shortening its scheduled dwell time,
+                // cant go under zero of course, trip should not go ahead
+                return Math.max(timeDelay - stopDwellTimeSeconds, 0);
+            }
+            // trip was AHEAD before
+            // real dwell time so far
+            const realDwellTimeSeconds = Math.round((currentPosition.properties.origin_timestamp.getTime() - context.atStopStreak.firstPositionTimestamp) / 1000);
+            // if real dwell is longer than scheduled, then add to negative delay time
+            return context.atStopStreak.firstPositionDelay + Math.max(realDwellTimeSeconds - stopDwellTimeSeconds, 0);
+        };
+        /**
+         * Compute UTC timestamp of start of day when trip starts
+         *
+         * @param {number} startTimestamp - Unix timestamp of start of the trip
+         * @param {number} firstStopTimeScheduledSeconds - Number of seconds from midnight of first stop departure
+         * @returns {number} - Returns unix timestamp in milliseconds.
+         */
+        this.getStartDayTimestamp = (startTimestamp, firstStopTimeScheduledSeconds) => {
+            let startDayTimestamp = moment_timezone_1.default.utc(startTimestamp).tz("Europe/Prague").startOf("day");
+            const stopTimeDayOverflow = Math.floor(firstStopTimeScheduledSeconds / ONE_DAY_IN_SECONDS);
+            // if trip has 24+ stop times set real startDay to yesterday
+            if (stopTimeDayOverflow > 0) {
+                startDayTimestamp.subtract(1, "day");
+            }
+            return startDayTimestamp.valueOf();
+        };
+    }
     /**
      * Get delay in seconds for positions before track to ensure correct delay propagation
      *
@@ -60,7 +470,7 @@ class PositionsManager {
      * @param positionOriginUnixTimestamp The Unix Epoch timestamp of the current position, in milliseconds
      * @param startDayUnixTimestamp The Unix Epoch timestamp of the start of the service day, in milliseconds
      */
-    static getDelayBeforeTrack(lastPositionDelay, firstStopDepartureTime, positionOriginUnixTimestamp, startDayUnixTimestamp) {
+    getDelayBeforeTrack(lastPositionDelay, firstStopDepartureTime, positionOriginUnixTimestamp, startDayUnixTimestamp) {
         if (typeof lastPositionDelay !== "number") {
             return null;
         }
@@ -72,8 +482,8 @@ class PositionsManager {
         const positionOriginTimeInSeconds = Math.floor(positionOriginUnixTimestamp / ONE_SECOND_IN_MILLIS);
         return Math.max(lastPositionDelay, positionOriginTimeInSeconds - departureTimeInSeconds);
     }
-    static getStateAndStopSequences(gtfsRouteType, tripStopTimes, thisClosestPoint, positionProperties, context) {
-        var _b;
+    getStateAndStopSequences(gtfsRouteType, tripStopTimes, thisClosestPoint, positionProperties, context) {
+        var _a;
         let statePosition = thisClosestPoint.this_stop_sequence ? const_1.StatePositionEnum.AT_STOP : const_1.StatePositionEnum.ON_TRACK;
         let thisStopSequence = thisClosestPoint.this_stop_sequence;
         let lastStopSequence = thisClosestPoint.last_stop_sequence;
@@ -83,7 +493,7 @@ class PositionsManager {
             positionProperties.tcp_event === const_1.TCPEventEnum.TIME &&
             (context === null || context === void 0 ? void 0 : context.lastPositionTracking)) {
             const previousPositionTcpEvent = context.lastPositionTracking.properties.tcp_event;
-            const previousLastStopSequence = (_b = context.lastPositionTracking.properties.last_stop_sequence) !== null && _b !== void 0 ? _b : 0;
+            const previousLastStopSequence = (_a = context.lastPositionTracking.properties.last_stop_sequence) !== null && _a !== void 0 ? _a : 0;
             // if previous position was 'P' and current last stop sequence is lower than the previous last stop sequence
             // or if previous position was 'O', current position is at stop
             //    and current last stop sequence is lower than the previous last stop sequence
@@ -113,399 +523,14 @@ class PositionsManager {
             nextStopSequence,
         };
     }
-    static isAfterTrack(lastStopSequence, lastTripShapePoint) {
+    isAfterTrack(lastStopSequence, lastTripShapePoint) {
         // Trip is terminated OR the vehicle is close to/in the terminus
         return lastStopSequence >= lastTripShapePoint.last_stop_sequence;
     }
-}
-_a = PositionsManager;
-/**
- * Compute positions and return computed positions
- *
- * @param {ITripPositionsWithGTFS} tripPositions - Trip positions with shape anchors data
- * @returns {Promise<IProcessedPositions>} - Returns computed/updated positions
- */
-PositionsManager.computePositions = (tripPositions, schedule) => __awaiter(void 0, void 0, void 0, function* () {
-    const startTimestamp = tripPositions.start_timestamp.getTime();
-    const startDayTimestamp = _a.getStartDayTimestamp(startTimestamp, tripPositions.gtfsData.shapes_anchor_points[0].time_scheduled_seconds);
-    const gtfsRouteType = tripPositions.gtfs_route_type;
-    const context = PositionsManager.getCurrentContext(tripPositions);
-    const computedPositions = [];
-    const endTimestamp = tripPositions.end_timestamp;
-    return PositionsManager.updatePositions({ tripPositions, startTimestamp, endTimestamp, startDayTimestamp, context, computedPositions, gtfsRouteType }, schedule);
-});
-/**
- * Takes position one by one, set proper handler for type of position, and do the process of position
- *
- * @param {number} i - Iteration
- * @param {IUpdatePositionsIteratorOptions} options - Initial options
- * @param {number} cb - Callback function of iterator
- * @returns {void} - void
- */
-PositionsManager.updatePositions = (options, schedule) => __awaiter(void 0, void 0, void 0, function* () {
-    var _b, _c, _d, _e, _f, _g, _h;
-    const { tripPositions, startDayTimestamp, startTimestamp, endTimestamp, context, computedPositions, gtfsRouteType } = options;
-    for (let i = 0; i < tripPositions.positions.length; i++) {
-        const position = tripPositions.positions[i];
-        let positionToUpdate = null;
-        // situations
-        switch (_a.setPositionUpdateHandler(position)) {
-            case PositionHandlerEnum_1.PositionHandlerEnum.TRACKING:
-                const currentPosition = turf.point([position.lng, position.lat], {
-                    id: position.id,
-                    origin_time: position.origin_time,
-                    origin_timestamp: position.origin_timestamp,
-                    scheduled_timestamp: position.scheduled_timestamp,
-                    this_stop_id: position.this_stop_id,
-                    tcp_event: position.tcp_event,
-                });
-                positionToUpdate = _a.getEstimatedPoint(tripPositions.gtfsData, currentPosition, context, startDayTimestamp, tripPositions.gtfs_route_type);
-                if (positionToUpdate.state_position !== const_1.StatePositionEnum.MISMATCHED) {
-                    positionToUpdate = ComputeDelayHelper_1.default.updatePositionToUpdate(context, positionToUpdate, position, gtfsRouteType);
-                }
-                positionToUpdate.bearing = (_b = position.bearing) !== null && _b !== void 0 ? _b : positionToUpdate.bearing;
-                break;
-            case PositionHandlerEnum_1.PositionHandlerEnum.NOT_TRACKING:
-                // if there is no previous positions with tracking status, set position as before_track
-                const firstShapesAnchorPoint = tripPositions.gtfsData.shapes_anchor_points[0];
-                if (context.lastPositionTracking === null &&
-                    (endTimestamp === null ||
-                        position.scheduled_timestamp === null ||
-                        endTimestamp > position.scheduled_timestamp)) {
-                    const firstStopTime = tripPositions.gtfsData.stop_times[0];
-                    // if there is propagated delay we can use it for new position
-                    const lastPositionDelayed = context.lastPositionBeforeTrackDelayed;
-                    // if there is no delay to duplicate and DPP trip is far from start then invisible
-                    const setAsInvisible = !lastPositionDelayed &&
-                        DPPUtils_1.default.isInvisible(tripPositions.agency_name_scheduled, position.origin_timestamp, startTimestamp, [position.lng, position.lat], firstShapesAnchorPoint.coordinates, schedule, tripPositions.gtfs_trip_id, context.lastPositionTracking, position.is_tracked);
-                    positionToUpdate = Object.assign({ id: position.id, next_stop_arrival_time: new Date(startDayTimestamp + firstStopTime.arrival_time_seconds * 1000), next_stop_departure_time: new Date(startDayTimestamp + firstStopTime.departure_time_seconds * 1000), next_stop_id: firstStopTime.stop_id, next_stop_sequence: firstStopTime.stop_sequence, next_stop_name: firstStopTime.stop.stop_name, shape_dist_traveled: firstStopTime.shape_dist_traveled, state_position: setAsInvisible ? const_1.StatePositionEnum.INVISIBLE : const_1.StatePositionEnum.BEFORE_TRACK, state_process: const_1.StateProcessEnum.PROCESSED }, (firstStopTime.stop_headsign && {
-                        last_stop_headsign: firstStopTime.stop_headsign,
-                    }));
-                    if (positionToUpdate.state_position === const_1.StatePositionEnum.BEFORE_TRACK) {
-                        positionToUpdate.delay = _a.getDelayBeforeTrack((_c = lastPositionDelayed === null || lastPositionDelayed === void 0 ? void 0 : lastPositionDelayed.delay) !== null && _c !== void 0 ? _c : position.delay, firstStopTime.departure_time_seconds, position.origin_timestamp.getTime(), startDayTimestamp);
-                    }
-                }
-                else {
-                    // if there is tracking 2 position with same origin_timestamp then this position is duplicate
-                    const statePosition = position.origin_timestamp.getTime() === context.lastPositionOriginTimestamp ||
-                        tripPositions.positions.findIndex((positionItem) => positionItem.origin_timestamp.getTime() === position.origin_timestamp.getTime() &&
-                            positionItem.is_tracked) >= 0
-                        ? const_1.StatePositionEnum.DUPLICATE
-                        : const_1.StatePositionEnum.AFTER_TRACK;
-                    const lastShapesAnchorPoint = tripPositions.gtfsData.shapes_anchor_points[tripPositions.gtfsData.shapes_anchor_points.length - 1];
-                    const lastStopTime = tripPositions.gtfsData.stop_times[tripPositions.gtfsData.stop_times.length - 1];
-                    // set as invisible if there are some AFTER_TRACK before
-                    const setAsInvisible = DPPUtils_1.default.isInvisible(tripPositions.agency_name_scheduled, position.origin_timestamp, startTimestamp, [position.lng, position.lat], firstShapesAnchorPoint.coordinates, schedule, tripPositions.gtfs_trip_id, context.lastPositionTracking, position.is_tracked) && statePosition === const_1.StatePositionEnum.AFTER_TRACK;
-                    positionToUpdate = Object.assign({ id: position.id, last_stop_arrival_time: new Date(startDayTimestamp + lastShapesAnchorPoint.time_scheduled_seconds * 1000), last_stop_departure_time: new Date(startDayTimestamp + lastShapesAnchorPoint.time_scheduled_seconds * 1000), last_stop_id: lastStopTime.stop_id, last_stop_sequence: lastShapesAnchorPoint.last_stop_sequence, shape_dist_traveled: lastShapesAnchorPoint.shape_dist_traveled, state_position: setAsInvisible ? const_1.StatePositionEnum.INVISIBLE : statePosition, state_process: const_1.StateProcessEnum.PROCESSED, delay: (_d = position.delay) !== null && _d !== void 0 ? _d : null }, (lastStopTime.stop_headsign && {
-                        last_stop_headsign: lastStopTime.stop_headsign,
-                    }));
-                    positionToUpdate = ComputeDelayHelper_1.default.updatePositionToUpdate(context, positionToUpdate, position, gtfsRouteType);
-                }
-                break;
-            case PositionHandlerEnum_1.PositionHandlerEnum.CANCELED:
-                positionToUpdate = {
-                    id: position.id,
-                    state_position: const_1.StatePositionEnum.CANCELED,
-                    state_process: const_1.StateProcessEnum.PROCESSED,
-                };
-                break;
-            case PositionHandlerEnum_1.PositionHandlerEnum.DO_NOTHING:
-                break;
-            default:
-                break;
-        }
-        // if not null push to update
-        if (positionToUpdate) {
-            (_e = positionToUpdate.is_tracked) !== null && _e !== void 0 ? _e : (positionToUpdate.is_tracked = position.is_tracked);
-            positionToUpdate.valid_to = ValidToCalculator_1.default.getValidToAttribute(positionToUpdate, position, gtfsRouteType, tripPositions.gtfsData, startTimestamp, startDayTimestamp);
-            computedPositions.push(positionToUpdate);
-        }
-        context.lastPositionState = (_f = positionToUpdate === null || positionToUpdate === void 0 ? void 0 : positionToUpdate.state_position) !== null && _f !== void 0 ? _f : position.state_position;
-        // set last known BEFORE_TRACK_DELAYED position
-        if (position.state_position === const_1.StatePositionEnum.BEFORE_TRACK_DELAYED) {
-            context.lastPositionBeforeTrackDelayed = {
-                delay: (_g = positionToUpdate === null || positionToUpdate === void 0 ? void 0 : positionToUpdate.delay) !== null && _g !== void 0 ? _g : position.delay,
-                origin_timestamp: (_h = positionToUpdate === null || positionToUpdate === void 0 ? void 0 : positionToUpdate.origin_timestamp) !== null && _h !== void 0 ? _h : position.origin_timestamp,
-            };
-        }
-        // set last position tracking (only for at_stop and on_track)
-        if ((positionToUpdate === null || positionToUpdate === void 0 ? void 0 : positionToUpdate.state_position) === const_1.StatePositionEnum.AT_STOP ||
-            (positionToUpdate === null || positionToUpdate === void 0 ? void 0 : positionToUpdate.state_position) === const_1.StatePositionEnum.ON_TRACK ||
-            position.state_position === const_1.StatePositionEnum.AT_STOP ||
-            position.state_position === const_1.StatePositionEnum.ON_TRACK) {
-            context.lastPositionTracking = turf.point([position.lng, position.lat], Object.assign(Object.assign({}, position), positionToUpdate));
-        }
-        // set new first position at stop streak if this stop seqence is set and it is not same as before
-        if (positionToUpdate
-            ? positionToUpdate.this_stop_sequence &&
-                context.atStopStreak.stop_sequence !== positionToUpdate.this_stop_sequence
-            : position.this_stop_sequence && context.atStopStreak.stop_sequence !== position.this_stop_sequence) {
-            context.atStopStreak.stop_sequence = positionToUpdate
-                ? positionToUpdate.this_stop_sequence
-                : position.this_stop_sequence;
-            context.atStopStreak.firstPositionTimestamp = position.origin_timestamp.getTime();
-            context.atStopStreak.firstPositionDelay = positionToUpdate ? positionToUpdate.delay : position.delay;
-        }
-        // IF currently valid updated position / position was processed before
-        // and it is NOT AT_STOP
-        // then disrupt atStopStreak
-        if (positionToUpdate &&
-            positionToUpdate.state_position !== const_1.StatePositionEnum.MISMATCHED &&
-            !positionToUpdate.this_stop_sequence) {
-            context.atStopStreak.stop_sequence = null;
-        }
-        else if (!positionToUpdate && !position.this_stop_sequence) {
-            context.atStopStreak.stop_sequence = null;
-        }
-        // duplicated or mismatched position should not be considered at all
-        if ((positionToUpdate === null || positionToUpdate === void 0 ? void 0 : positionToUpdate.state_position) !== const_1.StatePositionEnum.DUPLICATE &&
-            (positionToUpdate === null || positionToUpdate === void 0 ? void 0 : positionToUpdate.state_position) !== const_1.StatePositionEnum.INVISIBLE &&
-            (positionToUpdate === null || positionToUpdate === void 0 ? void 0 : positionToUpdate.state_position) !== const_1.StatePositionEnum.MISMATCHED) {
-            context.lastPositionId = position.id;
-            context.lastPositionCanceled = position.is_canceled;
-            context.lastPositionOriginTimestamp = position.origin_timestamp.getTime();
-            ComputeDelayHelper_1.default.updateContext(context, positionToUpdate, position, gtfsRouteType);
-        }
-    }
-    return {
-        context,
-        positions: computedPositions,
-    };
-});
-PositionsManager.getCurrentContext = (tripPositions) => {
-    var _b;
-    const context = (_b = tripPositions.last_position_context) !== null && _b !== void 0 ? _b : {
-        atStopStreak: {
-            stop_sequence: null,
-            firstPositionTimestamp: null,
-            firstPositionDelay: null,
-        },
-        lastPositionLastStop: {
-            id: null,
-            sequence: null,
-            arrival_time: null,
-            arrival_delay: null,
-            departure_time: null,
-            departure_delay: null,
-        },
-        lastPositionDelay: null,
-        lastPositionId: null,
-        lastPositionOriginTimestamp: null,
-        lastPositionTracking: null,
-        lastPositionCanceled: null,
-        lastPositionBeforeTrackDelayed: null,
-        lastPositionState: null,
-        tripId: tripPositions.id,
-    };
-    return context;
-};
-/**
- * Decide how to process input position data
- *
- * @param {IVPTripsPositionAttributes} position - Input vehiclepositions_positions row data
- * @returns {PositionHandlerEnum} - Returns action handler enum
- */
-PositionsManager.setPositionUpdateHandler = (position) => {
-    if (position.state_process === const_1.StateProcessEnum.PROCESSED)
-        return PositionHandlerEnum_1.PositionHandlerEnum.DO_NOTHING;
-    else if (position.is_canceled)
-        return PositionHandlerEnum_1.PositionHandlerEnum.CANCELED;
-    else if (position.is_tracked)
-        return PositionHandlerEnum_1.PositionHandlerEnum.TRACKING;
-    else
-        return PositionHandlerEnum_1.PositionHandlerEnum.NOT_TRACKING;
-};
-/**
- * Returns estimate of point on shape, where the trip should be with appropriate delay
- *
- * @param {IShapeAnchorPoint[]} tripShapePoints - Precalculated trip shape equidistant points with scheduled times
- * @param {Feature<Point, ICurrentPositionProperties>} currentPosition - Current position of trip
- * @param {IVPTripsLastPositionContext | null} context - Context state, holds information about previous positions
- * @param {number} startDayTimestamp - Unix timestamp of midnight before trip starts
- * @returns {IPositionToUpdate} - Position object to update
- */
-PositionsManager.getEstimatedPoint = (tripGtfsData, currentPosition, context, startDayTimestamp, gtfsRouteType) => {
-    var _b, _c, _d, _e, _f, _g, _h, _j;
-    const anchorPointSegmenter = new AnchorPointSegmenter_1.AnchorPointSegmenter(tripGtfsData.shapes_anchor_points, currentPosition);
-    const defaultStatePosition = const_1.StatePositionEnum.OFF_TRACK;
-    // Initial value
-    let estimatedPoint = Object.assign({ id: currentPosition.properties.id, state_position: defaultStatePosition, state_process: const_1.StateProcessEnum.PROCESSED, tcp_event: currentPosition.properties.tcp_event, valid_to: ValidToCalculator_1.default.getDefaultValidToAttribute(currentPosition.properties.origin_timestamp) }, (context &&
-        ((_b = context.lastPositionTracking) === null || _b === void 0 ? void 0 : _b.properties.last_stop_sequence) && {
-        shape_dist_traveled: (_c = context.lastPositionTracking) === null || _c === void 0 ? void 0 : _c.properties.shape_dist_traveled,
-        last_stop_arrival_time: ((_d = context.lastPositionTracking) === null || _d === void 0 ? void 0 : _d.properties.last_stop_arrival_time)
-            ? new Date((_e = context.lastPositionTracking) === null || _e === void 0 ? void 0 : _e.properties.last_stop_arrival_time)
-            : undefined,
-        last_stop_departure_time: ((_f = context.lastPositionTracking) === null || _f === void 0 ? void 0 : _f.properties.last_stop_departure_time)
-            ? new Date((_g = context.lastPositionTracking) === null || _g === void 0 ? void 0 : _g.properties.last_stop_departure_time)
-            : undefined,
-        last_stop_sequence: (_h = context.lastPositionTracking) === null || _h === void 0 ? void 0 : _h.properties.last_stop_sequence,
-        last_stop_id: (_j = context.lastPositionTracking) === null || _j === void 0 ? void 0 : _j.properties.last_stop_id,
-    }));
-    let lastStopSequence = null;
-    if ((context === null || context === void 0 ? void 0 : context.lastPositionState) === const_1.StatePositionEnum.BEFORE_TRACK) {
-        lastStopSequence = 1;
-    }
-    else if (context === null || context === void 0 ? void 0 : context.lastPositionTracking) {
-        lastStopSequence = context.lastPositionTracking.properties.last_stop_sequence;
-    }
-    const closesPoint = anchorPointSegmenter.getClosesPoint(lastStopSequence);
-    if (!closesPoint) {
-        return estimatedPoint;
-    }
-    return _a.getClosestPoint(currentPosition, context, startDayTimestamp, closesPoint, tripGtfsData, gtfsRouteType);
-};
-/**
- * Picks only one closest point for multiple possible points based on delay of last position and stop times
- *
- * @param {Feature<Point, ICurrentPositionProperties>} currentPosition - Feature Point of current position
- * @param {IVPTripsLastPositionContext | null} context - Context state, holds information about previous positions
- * @param {number} startDayTimestamp - Unix timestamp of start of the day
- * @param {IShapeAnchorPoint[]} closestPts - All closest points of possible segments
- * @param {IComputationTrip} tripGtfsData - GTFS data and all set of known positions
- * @returns {IPositionToUpdate} - Result point as position to update in DB
- */
-PositionsManager.getClosestPoint = (currentPosition, context, startDayTimestamp, thisClosestPoint, tripGtfsData, gtfsRouteType) => {
-    // want to find minimum difference of our prediction, where the bus should be
-    const tripShapePoints = tripGtfsData.shapes_anchor_points;
-    const tripStopTimes = tripGtfsData.stop_times;
-    const firstTripShapePoint = tripShapePoints[0];
-    const lastTripShapePoint = tripShapePoints[tripShapePoints.length - 1];
-    const timeScheduledTimestamp = DateTimeUtils_1.DateTimeUtils.getStopDateTimeForDayStart(
-    // take stop arrival time if is point at stop
-    thisClosestPoint.this_stop_sequence
-        ? tripStopTimes[thisClosestPoint.this_stop_sequence - 1].arrival_time_seconds
-        : thisClosestPoint.time_scheduled_seconds, startDayTimestamp);
-    let timeDelayInSeconds = Math.round((currentPosition.properties.origin_timestamp.getTime() - timeScheduledTimestamp.getTime()) / 1000);
-    const isBusOrTram = gtfsRouteType === RouteTypeEnums_1.GTFSRouteTypeEnum.BUS ||
-        gtfsRouteType === RouteTypeEnums_1.GTFSRouteTypeEnum.TROLLEYBUS ||
-        gtfsRouteType === RouteTypeEnums_1.GTFSRouteTypeEnum.TRAM;
-    // push trip into nearest at_stop shape anchor point if trip "P" event  (TCP tram or bus)
-    if (isBusOrTram &&
-        currentPosition.properties.tcp_event === const_1.TCPEventEnum.ARRIVAL_ANNOUNCED &&
-        thisClosestPoint.this_stop_sequence === null) {
-        if (thisClosestPoint.last_stop_sequence === 1 && !(context === null || context === void 0 ? void 0 : context.lastPositionTracking)) {
-            thisClosestPoint = firstTripShapePoint;
-        }
-        else {
-            let movingShapePointIndex = thisClosestPoint.index;
-            while (thisClosestPoint.this_stop_sequence === null && movingShapePointIndex < lastTripShapePoint.index) {
-                movingShapePointIndex++;
-                thisClosestPoint = tripShapePoints[movingShapePointIndex];
-            }
-        }
-    }
-    // lets correct delay if it is at stop
-    if (thisClosestPoint.this_stop_sequence) {
-        const thisStopSequence = thisClosestPoint.this_stop_sequence;
-        timeDelayInSeconds = _a.getCorrectedTimeDelay(timeDelayInSeconds, context, currentPosition, thisStopSequence, {
-            departureTime: tripStopTimes[thisStopSequence - 1].departure_time_seconds,
-            arrivalTime: tripStopTimes[thisStopSequence - 1].arrival_time_seconds,
-        });
-        // delay can not be negative if the vehicle is at the first stop
-        if (thisStopSequence === firstTripShapePoint.this_stop_sequence) {
-            timeDelayInSeconds = Math.max(timeDelayInSeconds, 0);
-        }
-    }
-    let { statePosition, thisStopSequence, lastStopSequence, nextStopSequence } = PositionsManager.getStateAndStopSequences(gtfsRouteType, tripStopTimes, thisClosestPoint, currentPosition.properties, context);
-    // test if TCP trip with DEPARTURED event should not be at stop (not applied for last stop)
-    if (currentPosition.properties.tcp_event === const_1.TCPEventEnum.DEPARTURED &&
-        thisStopSequence !== lastTripShapePoint.this_stop_sequence) {
-        statePosition = const_1.StatePositionEnum.ON_TRACK;
-    }
-    if (isBusOrTram && PositionsManager.isAfterTrack(lastStopSequence, lastTripShapePoint)) {
-        statePosition = const_1.StatePositionEnum.AFTER_TRACK;
-        thisStopSequence = lastTripShapePoint.this_stop_sequence;
-        lastStopSequence = lastTripShapePoint.last_stop_sequence;
-        nextStopSequence = lastTripShapePoint.next_stop_sequence;
-        timeDelayInSeconds = 0;
-    }
-    // save it for result
-    const estimatedPoint = {
-        id: currentPosition.properties.id,
-        bearing: thisClosestPoint.bearing,
-        shape_dist_traveled: Math.round(thisClosestPoint.shape_dist_traveled * 1000) / 1000,
-        next_stop_id: tripStopTimes[nextStopSequence - 1].stop_id,
-        last_stop_id: tripStopTimes[lastStopSequence - 1].stop_id,
-        next_stop_name: tripStopTimes[nextStopSequence - 1].stop.stop_name,
-        last_stop_name: tripStopTimes[lastStopSequence - 1].stop.stop_name,
-        next_stop_sequence: nextStopSequence,
-        last_stop_sequence: lastStopSequence,
-        next_stop_arrival_time: DateTimeUtils_1.DateTimeUtils.getStopDateTimeForDayStart(tripStopTimes[nextStopSequence - 1].arrival_time_seconds, startDayTimestamp),
-        last_stop_arrival_time: DateTimeUtils_1.DateTimeUtils.getStopDateTimeForDayStart(tripStopTimes[lastStopSequence - 1].arrival_time_seconds, startDayTimestamp),
-        next_stop_departure_time: DateTimeUtils_1.DateTimeUtils.getStopDateTimeForDayStart(tripStopTimes[nextStopSequence - 1].departure_time_seconds, startDayTimestamp),
-        last_stop_departure_time: DateTimeUtils_1.DateTimeUtils.getStopDateTimeForDayStart(tripStopTimes[lastStopSequence - 1].departure_time_seconds, startDayTimestamp),
-        delay: timeDelayInSeconds,
-        this_stop_id: (statePosition === const_1.StatePositionEnum.AT_STOP &&
-            thisStopSequence &&
-            tripStopTimes[thisStopSequence - 1].stop_id) ||
-            undefined,
-        this_stop_name: (statePosition === const_1.StatePositionEnum.AT_STOP &&
-            thisStopSequence &&
-            tripStopTimes[thisStopSequence - 1].stop.stop_name) ||
-            undefined,
-        this_stop_sequence: (statePosition === const_1.StatePositionEnum.AT_STOP && thisStopSequence) || undefined,
-        last_stop_headsign: tripStopTimes[lastStopSequence - 1].stop_headsign || undefined,
-        state_position: statePosition,
-        state_process: const_1.StateProcessEnum.PROCESSED,
-        valid_to: ValidToCalculator_1.default.getDefaultValidToAttribute(currentPosition.properties.origin_timestamp),
-        is_tracked: statePosition !== const_1.StatePositionEnum.AFTER_TRACK && statePosition !== const_1.StatePositionEnum.MISMATCHED,
-    };
-    return estimatedPoint;
-};
-/**
- * Corrects time delay at stop with dwelling time
- *
- * @param {number} timeDelay - Initial computed delay in seconds, can be negative for trip ahead
- * @param {IVPTripsLastPositionContext | null} context - Context state, holds information about previous positions
- * @param {Feature<Point, ICurrentPositionProperties>} currentPosition - Feature Point of current position
- * @param {IShapeAnchorPoint} thisClosestPoint - Closest point of shape anchors
- * @param { departureTime: number; arrivalTime: number } stopTimes - departure and arrival stop times in seconds
- * @returns {number} - Result delay in seconds, can be negative for trip ahead
- */
-PositionsManager.getCorrectedTimeDelay = (timeDelay, context, currentPosition, thisStopSequence, stopTimes) => {
-    // compute dwell time in stop, most common is zero
-    const stopDwellTimeSeconds = stopTimes.departureTime - stopTimes.arrivalTime;
-    // if dwell time is sheduled as zero, return initial computed delay
-    if (stopDwellTimeSeconds <= 0) {
-        return timeDelay;
-    }
-    // if last position was not in this same stop or there is no last position at all
-    if (!context || context.atStopStreak.stop_sequence !== thisStopSequence) {
-        // timeDelay >= 0 trip is DELAYED
-        // we presume it will lower delay by shortening its scheduled dwell time,
-        // cant go under zero of course, trip should not go ahead
-        // else trip is AHeAD
-        // left computed delay as it was
-        return timeDelay >= 0 ? Math.max(timeDelay - stopDwellTimeSeconds, 0) : timeDelay;
-    }
-    // we presume that first position at same stop is real arrival time
-    if (context.atStopStreak.firstPositionDelay >= 0) {
-        // trip was DELAYED before
-        // we presume it will lower delay by shortening its scheduled dwell time,
-        // cant go under zero of course, trip should not go ahead
-        return Math.max(timeDelay - stopDwellTimeSeconds, 0);
-    }
-    // trip was AHEAD before
-    // real dwell time so far
-    const realDwellTimeSeconds = Math.round((currentPosition.properties.origin_timestamp.getTime() - context.atStopStreak.firstPositionTimestamp) / 1000);
-    // if real dwell is longer than scheduled, then add to negative delay time
-    return context.atStopStreak.firstPositionDelay + Math.max(realDwellTimeSeconds - stopDwellTimeSeconds, 0);
-};
-/**
- * Compute UTC timestamp of start of day when trip starts
- *
- * @param {number} startTimestamp - Unix timestamp of start of the trip
- * @param {number} firstStopTimeScheduledSeconds - Number of seconds from midnight of first stop departure
- * @returns {number} - Returns unix timestamp in milliseconds.
- */
-PositionsManager.getStartDayTimestamp = (startTimestamp, firstStopTimeScheduledSeconds) => {
-    let startDayTimestamp = moment_timezone_1.default.utc(startTimestamp).tz("Europe/Prague").startOf("day");
-    const stopTimeDayOverflow = Math.floor(firstStopTimeScheduledSeconds / ONE_DAY_IN_SECONDS);
-    // if trip has 24+ stop times set real startDay to yesterday
-    if (stopTimeDayOverflow > 0) {
-        startDayTimestamp.subtract(1, "day");
-    }
-    return startDayTimestamp.valueOf();
 };
-exports.default = PositionsManager;
+exports.PositionsManager = PositionsManager = __decorate([
+    (0, tsyringe_1.injectable)(),
+    __param(0, (0, tsyringe_1.inject)(VPContainerToken_1.VPContainerToken.ValidToCalculator)),
+    __metadata("design:paramtypes", [ValidToCalculator_1.ValidToCalculator])
+], PositionsManager);
 //# sourceMappingURL=PositionsManager.js.map