@golemio/pid 2.13.10-dev.1342209321 → 2.14.0

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

@@ -15,12 +15,6 @@ 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 = {};
@@ -28,12 +22,6 @@ 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) {
@@ -46,414 +34,21 @@ 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 });
-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 moment_timezone_1 = __importDefault(require("@golemio/core/dist/shared/moment-timezone"));
 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 = require("./ValidToCalculator");
+const ValidToCalculator_1 = __importDefault(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;
-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;
-            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,
-                            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) {
-                    (_d = positionToUpdate.is_tracked) !== null && _d !== void 0 ? _d : (positionToUpdate.is_tracked = position.is_tracked);
-                    positionToUpdate.valid_to = this.validToCalculator.getValidToAttribute(positionToUpdate, position, gtfsRouteType, tripPositions.gtfsData, startTimestamp);
-                    computedPositions.push(positionToUpdate);
-                }
-                context.lastPositionState = (_e = positionToUpdate === null || positionToUpdate === void 0 ? void 0 : positionToUpdate.state_position) !== null && _e !== void 0 ? _e : position.state_position;
-                // set last known BEFORE_TRACK_DELAYED position
-                if (position.state_position === const_1.StatePositionEnum.BEFORE_TRACK_DELAYED) {
-                    context.lastPositionBeforeTrackDelayed = {
-                        delay: (_f = positionToUpdate === null || positionToUpdate === void 0 ? void 0 : positionToUpdate.delay) !== null && _f !== void 0 ? _f : position.delay,
-                        origin_timestamp: (_g = positionToUpdate === null || positionToUpdate === void 0 ? void 0 : positionToUpdate.origin_timestamp) !== null && _g !== void 0 ? _g : 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: 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: 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();
-        };
-    }
+class PositionsManager {
     /**
      * Get delay in seconds for positions before track to ensure correct delay propagation
      *
@@ -465,7 +60,7 @@ let PositionsManager = exports.PositionsManager = 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
      */
-    getDelayBeforeTrack(lastPositionDelay, firstStopDepartureTime, positionOriginUnixTimestamp, startDayUnixTimestamp) {
+    static getDelayBeforeTrack(lastPositionDelay, firstStopDepartureTime, positionOriginUnixTimestamp, startDayUnixTimestamp) {
         if (typeof lastPositionDelay !== "number") {
             return null;
         }
@@ -477,8 +72,8 @@ let PositionsManager = exports.PositionsManager = class PositionsManager {
         const positionOriginTimeInSeconds = Math.floor(positionOriginUnixTimestamp / ONE_SECOND_IN_MILLIS);
         return Math.max(lastPositionDelay, positionOriginTimeInSeconds - departureTimeInSeconds);
     }
-    getStateAndStopSequences(gtfsRouteType, tripStopTimes, thisClosestPoint, positionProperties, context) {
-        var _a;
+    static getStateAndStopSequences(gtfsRouteType, tripStopTimes, thisClosestPoint, positionProperties, context) {
+        var _b;
         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;
@@ -488,7 +83,7 @@ let PositionsManager = exports.PositionsManager = 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 = (_a = context.lastPositionTracking.properties.last_stop_sequence) !== null && _a !== void 0 ? _a : 0;
+            const previousLastStopSequence = (_b = context.lastPositionTracking.properties.last_stop_sequence) !== null && _b !== void 0 ? _b : 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
@@ -518,14 +113,399 @@ let PositionsManager = exports.PositionsManager = class PositionsManager {
             nextStopSequence,
         };
     }
-    isAfterTrack(lastStopSequence, lastTripShapePoint) {
+    static 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.PositionsManager = PositionsManager = __decorate([
-    (0, tsyringe_1.injectable)(),
-    __param(0, (0, tsyringe_1.inject)(VPContainerToken_1.VPContainerToken.ValidToCalculator)),
-    __metadata("design:paramtypes", [ValidToCalculator_1.ValidToCalculator])
-], PositionsManager);
+exports.default = PositionsManager;
 //# sourceMappingURL=PositionsManager.js.map