#include "engine/guidance/post_processing.hpp"
#include "extractor/guidance/constants.hpp"
#include "extractor/guidance/turn_instruction.hpp"

#include "engine/guidance/assemble_steps.hpp"
#include "engine/guidance/lane_processing.hpp"

#include "util/bearing.hpp"
#include "util/guidance/name_announcements.hpp"
#include "util/guidance/turn_lanes.hpp"

#include <boost/assert.hpp>
#include <boost/numeric/conversion/cast.hpp>
#include <boost/range/algorithm_ext/erase.hpp>
#include <boost/range/iterator_range.hpp>

#include <algorithm>
#include <cmath>
#include <cstddef>
#include <limits>
#include <utility>

using TurnInstruction = osrm::extractor::guidance::TurnInstruction;
namespace TurnType = osrm::extractor::guidance::TurnType;
namespace DirectionModifier = osrm::extractor::guidance::DirectionModifier;
using osrm::util::angularDeviation;
using osrm::extractor::guidance::getTurnDirection;
using osrm::extractor::guidance::hasRampType;
using osrm::extractor::guidance::mirrorDirectionModifier;
using osrm::extractor::guidance::bearingToDirectionModifier;

namespace osrm
{
namespace engine
{
namespace guidance
{

namespace
{
const constexpr std::size_t MIN_END_OF_ROAD_INTERSECTIONS = std::size_t{2};
const constexpr double MAX_COLLAPSE_DISTANCE = 30;

// check if at least one of the turns is actually a maneuver
inline bool hasManeuver(const RouteStep &first, const RouteStep &second)
{
    return (first.maneuver.instruction.type != TurnType::Suppressed ||
            second.maneuver.instruction.type != TurnType::Suppressed) &&
           (first.maneuver.instruction.type != TurnType::NoTurn &&
            second.maneuver.instruction.type != TurnType::NoTurn);
}

inline bool choiceless(const RouteStep &step, const RouteStep &previous)
{
    // if the next turn is choiceless, we consider longer turn roads collapsable than usually
    // accepted. We might need to improve this to find out whether we merge onto a through-street.
    BOOST_ASSERT(!step.intersections.empty());
    const auto is_without_choice = previous.distance < 4 * MAX_COLLAPSE_DISTANCE &&
                                   1 >= std::count(step.intersections.front().entry.begin(),
                                                   step.intersections.front().entry.end(),
                                                   true);

    return is_without_choice && step.maneuver.instruction.type != TurnType::EndOfRoad;
}

// List of types that can be collapsed, if all other restrictions pass
bool isCollapsableInstruction(const TurnInstruction instruction)
{
    return instruction.type == TurnType::NewName ||
           (instruction.type == TurnType::Suppressed &&
            instruction.direction_modifier == DirectionModifier::Straight) ||
           (instruction.type == TurnType::Turn &&
            instruction.direction_modifier == DirectionModifier::Straight) ||
           (instruction.type == TurnType::Continue &&
            instruction.direction_modifier == DirectionModifier::Straight) ||
           (instruction.type == TurnType::Merge);
}

bool compatible(const RouteStep &lhs, const RouteStep &rhs) { return lhs.mode == rhs.mode; }

// Checks if name change happens the user wants to know about.
// Treats e.g. "Name (Ref)" -> "Name" changes still as same name.
bool isNoticeableNameChange(const RouteStep &lhs, const RouteStep &rhs)
{
    // TODO: rotary_name is not handled at the moment.
    return util::guidance::requiresNameAnnounced(
        lhs.name, lhs.ref, lhs.pronunciation, rhs.name, rhs.ref, rhs.pronunciation);
}

double nameSegmentLength(std::size_t at, const std::vector<RouteStep> &steps)
{
    BOOST_ASSERT(at < steps.size());

    double result = steps[at].distance;
    while (at + 1 < steps.size() && !isNoticeableNameChange(steps[at], steps[at + 1]))
    {
        at += 1;
        result += steps[at].distance;
    }
    return result;
}

void fixFinalRoundabout(std::vector<RouteStep> &steps)
{
    for (std::size_t propagation_index = steps.size() - 1; propagation_index > 0;
         --propagation_index)
    {
        auto &propagation_step = steps[propagation_index];
        propagation_step.maneuver.exit = 0;
        if (entersRoundabout(propagation_step.maneuver.instruction))
        {
            // remember the current name as rotary name in tha case we end in a rotary
            if (propagation_step.maneuver.instruction.type == TurnType::EnterRotary ||
                propagation_step.maneuver.instruction.type == TurnType::EnterRotaryAtExit)
            {
                propagation_step.rotary_name = propagation_step.name;
                propagation_step.rotary_pronunciation = propagation_step.pronunciation;
            }
            else if (propagation_step.maneuver.instruction.type ==
                         TurnType::EnterRoundaboutIntersection ||
                     propagation_step.maneuver.instruction.type ==
                         TurnType::EnterRoundaboutIntersectionAtExit)
            {
                propagation_step.maneuver.instruction.type = TurnType::EnterRoundabout;
            }

            return;
        }
        // accumulate turn data into the enter instructions
        else if (propagation_step.maneuver.instruction.type == TurnType::StayOnRoundabout)
        {
            // TODO this operates on the data that is in the instructions.
            // We are missing out on the final segment after the last stay-on-roundabout
            // instruction though. it is not contained somewhere until now
            steps[propagation_index - 1].ElongateBy(propagation_step);
            steps[propagation_index - 1].maneuver.exit = propagation_step.maneuver.exit;
            propagation_step.Invalidate();
        }
    }
}

bool setUpRoundabout(RouteStep &step)
{
    // basic entry into a roundabout
    // Special case handling, if an entry is directly tied to an exit
    const auto instruction = step.maneuver.instruction;
    if (instruction.type == TurnType::EnterRotaryAtExit ||
        instruction.type == TurnType::EnterRoundaboutAtExit ||
        instruction.type == TurnType::EnterRoundaboutIntersectionAtExit)
    {
        // Here we consider an actual entry, not an exit. We simply have to count the additional
        // exit
        step.maneuver.exit = 1;
        // prevent futher special case handling of these two.
        if (instruction.type == TurnType::EnterRotaryAtExit)
            step.maneuver.instruction.type = TurnType::EnterRotary;
        else if (instruction.type == TurnType::EnterRoundaboutAtExit)
            step.maneuver.instruction.type = TurnType::EnterRoundabout;
        else
            step.maneuver.instruction.type = TurnType::EnterRoundaboutIntersection;
    }

    if (leavesRoundabout(instruction))
    {
        // This set-up, even though it looks the same, is actually looking at entering AND exiting
        step.maneuver.exit = 1; // count the otherwise missing exit

        // prevent futher special case handling of these two.
        if (instruction.type == TurnType::EnterAndExitRotary)
            step.maneuver.instruction.type = TurnType::EnterRotary;
        else if (instruction.type == TurnType::EnterAndExitRoundabout)
            step.maneuver.instruction.type = TurnType::EnterRoundabout;
        else
            step.maneuver.instruction.type = TurnType::EnterRoundaboutIntersection;
        return false;
    }
    else
    {
        return true;
    }
}

void closeOffRoundabout(const bool on_roundabout,
                        std::vector<RouteStep> &steps,
                        const std::size_t step_index)
{
    auto &step = steps[step_index];
    step.maneuver.exit += 1;
    if (!on_roundabout)
    {
        // We reached a special case that requires the addition of a special route step in the
        // beginning. We started in a roundabout, so to announce the exit, we move use the exit
        // instruction and move it right to the beginning to make sure to immediately announce the
        // exit.
        BOOST_ASSERT(leavesRoundabout(steps[1].maneuver.instruction) ||
                     steps[1].maneuver.instruction.type == TurnType::StayOnRoundabout ||
                     steps[1].maneuver.instruction.type == TurnType::Suppressed ||
                     steps[1].maneuver.instruction.type == TurnType::NoTurn ||
                     steps[1].maneuver.instruction.type == TurnType::UseLane);
        steps[0].geometry_end = 1;
        steps[1].geometry_begin = 0;
        steps[1].AddInFront(steps[0]);
        steps[1].intersections.erase(steps[1].intersections.begin()); // otherwise we copy the
                                                                      // source
        if (leavesRoundabout(steps[1].maneuver.instruction))
            steps[1].maneuver.exit = 1;
        steps[0].duration = 0;
        steps[0].distance = 0;
        const auto exitToEnter = [](const TurnType::Enum type) {
            if (TurnType::ExitRotary == type)
                return TurnType::EnterRotary;
            // if we do not enter the roundabout Intersection, we cannot treat the full traversal as
            // a turn. So we switch it up to the roundabout type
            else if (type == TurnType::ExitRoundaboutIntersection)
                return TurnType::EnterRoundabout;
            else
                return TurnType::EnterRoundabout;
        };
        steps[1].maneuver.instruction.type = exitToEnter(step.maneuver.instruction.type);
        if (steps[1].maneuver.instruction.type == TurnType::EnterRotary)
        {
            steps[1].rotary_name = steps[0].name;
            steps[1].rotary_pronunciation = steps[0].pronunciation;
        }
    }

    // Normal exit from the roundabout, or exit from a previously fixed roundabout. Propagate the
    // index back to the entering location and prepare the current silent set of instructions for
    // removal.
    std::vector<std::size_t> intermediate_steps;
    BOOST_ASSERT(!steps[step_index].intersections.empty());
    // the very first intersection in the steps represents the location of the turn. Following
    // intersections are locations passed along the way
    const auto exit_intersection = steps[step_index].intersections.front();
    const auto exit_bearing = exit_intersection.bearings[exit_intersection.out];
    const auto destination_copy = step;
    if (step_index > 1)
    {
        // The very first route-step is head, so we cannot iterate past that one
        for (std::size_t propagation_index = step_index - 1; propagation_index > 0;
             --propagation_index)
        {
            auto &propagation_step = steps[propagation_index];
            propagation_step.ElongateBy(steps[propagation_index + 1]);
            propagation_step.maneuver.exit = steps[propagation_index + 1].maneuver.exit;
            if (entersRoundabout(propagation_step.maneuver.instruction))
            {
                const auto entry_intersection = propagation_step.intersections.front();

                // remember rotary name
                if (propagation_step.maneuver.instruction.type == TurnType::EnterRotary ||
                    propagation_step.maneuver.instruction.type == TurnType::EnterRotaryAtExit)
                {
                    propagation_step.rotary_name = propagation_step.name;
                    propagation_step.rotary_pronunciation = propagation_step.pronunciation;
                }
                else if (propagation_step.maneuver.instruction.type ==
                             TurnType::EnterRoundaboutIntersection ||
                         propagation_step.maneuver.instruction.type ==
                             TurnType::EnterRoundaboutIntersectionAtExit)
                {
                    BOOST_ASSERT(!propagation_step.intersections.empty());
                    const double angle = util::bearing::angleBetween(
                        util::bearing::reverse(entry_intersection.bearings[entry_intersection.in]),
                        exit_bearing);

                    auto bearings = propagation_step.intersections.front().bearings;
                    propagation_step.maneuver.instruction.direction_modifier =
                        getTurnDirection(angle);
                }

                propagation_step.AdaptStepSignage(destination_copy);
                steps[propagation_index + 1].Invalidate();
                break;
            }
            else
            {
                steps[propagation_index + 1].Invalidate();
            }
        }
        // remove exit
    }
}

bool bearingsAreReversed(const double bearing_in, const double bearing_out)
{
    // Nearly perfectly reversed angles have a difference close to 180 degrees (straight)
    const double left_turn_angle = [&]() {
        if (0 <= bearing_out && bearing_out <= bearing_in)
            return bearing_in - bearing_out;
        return bearing_in + 360 - bearing_out;
    }();
    return angularDeviation(left_turn_angle, 180) <= 35;
}

bool isLinkroad(const RouteStep &pre_link_step,
                const RouteStep &link_step,
                const RouteStep &post_link_step)
{
    const constexpr double MAX_LINK_ROAD_LENGTH = 60.0;
    return link_step.distance <= MAX_LINK_ROAD_LENGTH && link_step.name_id == EMPTY_NAMEID &&
           pre_link_step.name_id != EMPTY_NAMEID && post_link_step.name_id != EMPTY_NAMEID;
}

bool isUTurn(const RouteStep &in_step, const RouteStep &out_step, const RouteStep &pre_in_step)
{
    const bool is_possible_candidate =
        in_step.distance <= MAX_COLLAPSE_DISTANCE || choiceless(out_step, in_step) ||
        (isLinkroad(pre_in_step, in_step, out_step) && out_step.name_id != EMPTY_NAMEID &&
         pre_in_step.name_id != EMPTY_NAMEID && !isNoticeableNameChange(pre_in_step, out_step));
    const bool takes_u_turn = bearingsAreReversed(
        util::bearing::reverse(
            in_step.intersections.front().bearings[in_step.intersections.front().in]),
        out_step.intersections.front().bearings[out_step.intersections.front().out]);

    return is_possible_candidate && takes_u_turn && compatible(in_step, out_step);
}

double findTotalTurnAngle(const RouteStep &entry_step, const RouteStep &exit_step)
{
    const auto exit_intersection = exit_step.intersections.front();
    const auto exit_step_exit_bearing = exit_intersection.bearings[exit_intersection.out];
    const auto exit_step_entry_bearing =
        util::bearing::reverse(exit_intersection.bearings[exit_intersection.in]);

    const auto entry_intersection = entry_step.intersections.front();
    const auto entry_step_entry_bearing =
        util::bearing::reverse(entry_intersection.bearings[entry_intersection.in]);
    const auto entry_step_exit_bearing = entry_intersection.bearings[entry_intersection.out];

    const auto exit_angle =
        util::bearing::angleBetween(exit_step_entry_bearing, exit_step_exit_bearing);
    const auto entry_angle =
        util::bearing::angleBetween(entry_step_entry_bearing, entry_step_exit_bearing);

    const double total_angle =
        util::bearing::angleBetween(entry_step_entry_bearing, exit_step_exit_bearing);
    // We allow for minor deviations from a straight line
    if (((entry_step.distance < MAX_COLLAPSE_DISTANCE && exit_step.intersections.size() == 1) ||
         (entry_angle <= 185 && exit_angle <= 185) || (entry_angle >= 175 && exit_angle >= 175)) &&
        angularDeviation(total_angle, 180) > 20)
    {
        // both angles are in the same direction, the total turn gets increased
        //
        // a ---- b
        //           \ 
        //              c
        //              |
        //              d
        //
        // Will be considered just like
        // a -----b
        //        |
        //        c
        //        |
        //        d
        return total_angle;
    }
    else
    {
        // to prevent ignoring angles like
        // a -- b
        //      |
        //      c -- d
        // We don't combine both turn angles here but keep the very first turn angle.
        // We choose the first one, since we consider the first maneuver in a merge range the
        // important one
        return entry_angle;
    }
}

std::size_t getPreviousIndex(std::size_t index, const std::vector<RouteStep> &steps)
{
    BOOST_ASSERT(index > 0);
    BOOST_ASSERT(index < steps.size());
    --index;
    while (index > 0 && steps[index].maneuver.instruction.type == TurnType::NoTurn)
        --index;

    return index;
}

void collapseUTurn(std::vector<RouteStep> &steps,
                   const std::size_t two_back_index,
                   const std::size_t one_back_index,
                   const std::size_t step_index)
{
    BOOST_ASSERT(two_back_index < steps.size());
    BOOST_ASSERT(step_index < steps.size());
    BOOST_ASSERT(one_back_index < steps.size());
    const auto &current_step = steps[step_index];

    // the simple case is a u-turn that changes directly into the in-name again
    const bool direct_u_turn = !isNoticeableNameChange(steps[two_back_index], current_step);

    // however, we might also deal with a dual-collapse scenario in which we have to
    // additionall collapse a name-change as well
    const auto next_step_index = step_index + 1;
    const bool continues_with_name_change =
        (next_step_index < steps.size()) && compatible(steps[step_index], steps[next_step_index]) &&
        ((steps[next_step_index].maneuver.instruction.type == TurnType::UseLane &&
          steps[next_step_index].maneuver.instruction.direction_modifier ==
              DirectionModifier::Straight) ||
         isCollapsableInstruction(steps[next_step_index].maneuver.instruction));
    const bool u_turn_with_name_change =
        continues_with_name_change && steps[next_step_index].name_id != EMPTY_NAMEID &&
        !isNoticeableNameChange(steps[two_back_index], steps[next_step_index]);

    if (direct_u_turn || u_turn_with_name_change)
    {
        steps[one_back_index].ElongateBy(steps[step_index]);
        steps[step_index].Invalidate();
        if (u_turn_with_name_change)
        {
            BOOST_ASSERT_MSG(compatible(steps[one_back_index], steps[next_step_index]),
                             "Compatibility should be transitive");
            steps[one_back_index].ElongateBy(steps[next_step_index]);
            steps[next_step_index].Invalidate(); // will be skipped due to the
                                                 // continue statement at the
                                                 // beginning of this function
        }
        steps[one_back_index].AdaptStepSignage(steps[two_back_index]);
        steps[one_back_index].maneuver.instruction.type = TurnType::Continue;
        steps[one_back_index].maneuver.instruction.direction_modifier = DirectionModifier::UTurn;
    }
}

void collapseTurnAt(std::vector<RouteStep> &steps,
                    const std::size_t two_back_index,
                    const std::size_t one_back_index,
                    const std::size_t step_index)
{
    BOOST_ASSERT(step_index < steps.size());
    BOOST_ASSERT(one_back_index < steps.size());
    const auto &current_step = steps[step_index];
    const auto &one_back_step = steps[one_back_index];
    // Don't collapse roundabouts
    if (entersRoundabout(current_step.maneuver.instruction) ||
        entersRoundabout(one_back_step.maneuver.instruction))
        return;

    // This function assumes driving on the right hand side of the streat
    BOOST_ASSERT(!one_back_step.intersections.empty() && !current_step.intersections.empty());

    if (!hasManeuver(one_back_step, current_step))
        return;

    // A maneuver is preceded by a name change if the instruction just before can be collapsed
    // normally or the instruction itself is collapsable and does not actually present a choice
    const auto maneuverPrecededByNameChange = [](const RouteStep &turning_point,
                                                 const RouteStep &possible_name_change_location,
                                                 const RouteStep &preceeding_step) {
        // the check against merge is a workaround for motorways
        if (possible_name_change_location.maneuver.instruction.type == TurnType::Merge ||
            !compatible(possible_name_change_location, preceeding_step))
            return false;

        return collapsable(possible_name_change_location, turning_point) ||
               (isCollapsableInstruction(possible_name_change_location.maneuver.instruction) &&
                choiceless(possible_name_change_location, preceeding_step));
    };

    // check if the actual turn we wan't to announce is delayed. This situation describes a turn
    // that is expressed by two turns,
    const auto isDelayedTurn = [](
        const RouteStep &opening_turn, const RouteStep &finishing_turn, const RouteStep &pre_turn) {
        // only possible if both are compatible
        if (!compatible(opening_turn, finishing_turn))
            return false;
        else
        {
            const auto is_short_and_collapsable =
                opening_turn.distance <= MAX_COLLAPSE_DISTANCE &&
                isCollapsableInstruction(finishing_turn.maneuver.instruction);

            const auto without_choice = choiceless(finishing_turn, opening_turn);

            const auto is_not_too_long_and_choiceless =
                opening_turn.distance <= 2 * MAX_COLLAPSE_DISTANCE && without_choice;

            // for ramps we allow longer stretches, since they are often on some major brides/large
            // roads. A combined distance of of 4 intersections would be to long for a normal
            // collapse. In case of a ramp though, we also account for situations that have the ramp
            // tagged late
            const auto is_delayed_turn_onto_a_ramp =
                opening_turn.distance <= 4 * MAX_COLLAPSE_DISTANCE && without_choice &&
                hasRampType(finishing_turn.maneuver.instruction);

            const auto linkroad = isLinkroad(pre_turn, opening_turn, finishing_turn);

            return !hasRampType(opening_turn.maneuver.instruction) &&
                   (is_short_and_collapsable || is_not_too_long_and_choiceless || linkroad ||
                    is_delayed_turn_onto_a_ramp);
        }
    };

    // Handle possible u-turns
    if (isUTurn(one_back_step, current_step, steps[two_back_index]))
        collapseUTurn(steps, two_back_index, one_back_index, step_index);
    // Very Short New Name that will be suppressed. Turn location remains at current_step
    else if (maneuverPrecededByNameChange(current_step, one_back_step, steps[two_back_index]))
    {
        BOOST_ASSERT(two_back_index < steps.size());
        BOOST_ASSERT(!one_back_step.intersections.empty());
        if (TurnType::Merge == current_step.maneuver.instruction.type)
        {
            steps[step_index].maneuver.instruction.direction_modifier =
                mirrorDirectionModifier(steps[step_index].maneuver.instruction.direction_modifier);
            steps[step_index].maneuver.instruction.type = TurnType::Turn;
        }
        else
        {
            const bool continue_or_suppressed =
                (TurnType::Continue == current_step.maneuver.instruction.type ||
                 (TurnType::Suppressed == current_step.maneuver.instruction.type &&
                  current_step.maneuver.instruction.direction_modifier !=
                      DirectionModifier::Straight));

            const bool turning_name =
                (TurnType::NewName == current_step.maneuver.instruction.type &&
                 current_step.maneuver.instruction.direction_modifier !=
                     DirectionModifier::Straight &&
                 one_back_step.intersections.front().bearings.size() > 2);

            if (continue_or_suppressed)
                steps[step_index].maneuver.instruction.type = TurnType::Turn;
            else if (turning_name)
                steps[step_index].maneuver.instruction.type = TurnType::Turn;
            else if (TurnType::UseLane == current_step.maneuver.instruction.type &&
                     current_step.maneuver.instruction.direction_modifier !=
                         DirectionModifier::Straight &&
                     one_back_step.intersections.front().bearings.size() > 2)
                steps[step_index].maneuver.instruction.type = TurnType::Turn;

            // A new name with a continue/turning suppressed/name requires the adaption of the
            // direction modifier. The combination of the in-bearing and the out bearing gives the
            // new modifier for the turn
            if (continue_or_suppressed || turning_name)
            {
                const auto in_bearing = [](const RouteStep &step) {
                    return util::bearing::reverse(
                        step.intersections.front().bearings[step.intersections.front().in]);
                };
                const auto out_bearing = [](const RouteStep &step) {
                    return step.intersections.front().bearings[step.intersections.front().out];
                };

                const auto first_angle = util::bearing::angleBetween(in_bearing(one_back_step),
                                                                     out_bearing(one_back_step));
                const auto second_angle = util::bearing::angleBetween(in_bearing(current_step),
                                                                      out_bearing(current_step));
                const auto bearing_turn_angle = util::bearing::angleBetween(
                    in_bearing(one_back_step), out_bearing(current_step));

                // When looking at an intersection, some angles, even though present, feel more like
                // a straight turn. This happens most often at segregated intersections.
                // We consider two cases
                // I) a shift in the road:
                //
                // a       g      h
                //     .   |      |
                //         b ---- c
                //         |      |    .
                //         f      e        d
                //
                // Where a-d technicall continues straight, even though the shift models it as a
                // slight left and a slight right turn.
                //
                // II) A curved road
                //
                //         g      h
                //         |      |
                //         b ---- c
                //    .    |      |    .
                // a       f      e        d
                //
                // where a-d is a curve passing by an intersection.
                //
                // We distinguish this case from other bearings though where the interpretation as
                // straight would end up disguising turns.

                // check if there is another similar turn next to the turn itself
                const auto hasSimilarAngle = [&](const std::size_t index,
                                                 const std::vector<short> &bearings) {
                    return (angularDeviation(bearings[index],
                                             bearings[(index + 1) % bearings.size()]) <
                            extractor::guidance::NARROW_TURN_ANGLE) ||
                           (angularDeviation(
                                bearings[index],
                                bearings[(index + bearings.size() - 1) % bearings.size()]) <
                            extractor::guidance::NARROW_TURN_ANGLE);
                };

                const auto is_shift_or_curve = [&]() -> bool {
                    // since we move an intersection modifier from a slight turn to a straight, we
                    // need to make sure that there is not a similar angle which could prevent this
                    // perception of angles to be true.
                    if (hasSimilarAngle(one_back_step.intersections.front().in,
                                        one_back_step.intersections.front().bearings) ||
                        hasSimilarAngle(current_step.intersections.front().out,
                                        current_step.intersections.front().bearings))
                        return false;

                    // Check if we are on a potential curve, both angles go in the same direction
                    if (angularDeviation(first_angle, second_angle) <
                        extractor::guidance::FUZZY_ANGLE_DIFFERENCE)
                    {
                        // We limit perceptive angles to narrow turns. If the total turn is going to
                        // be not-narrow, we assume it to be more than a simple curve.
                        return angularDeviation(bearing_turn_angle,
                                                extractor::guidance::STRAIGHT_ANGLE) <
                               extractor::guidance::NARROW_TURN_ANGLE;
                    }
                    // if one of the angles is a left turn and the other one is a right turn, we
                    // nearly reverse the angle
                    else if ((first_angle > extractor::guidance::STRAIGHT_ANGLE) !=
                             (second_angle > extractor::guidance::STRAIGHT_ANGLE))
                    {
                        // since we are not in a curve, we can check for a shift. If we are going
                        // nearly straight, we call it a shift.
                        return angularDeviation(bearing_turn_angle,
                                                extractor::guidance::STRAIGHT_ANGLE) <
                               extractor::guidance::NARROW_TURN_ANGLE;
                    }
                    else
                    {
                        return false;
                    }
                }();

                // if the angles continue similar, it looks like we might be in a normal curve
                if (is_shift_or_curve)
                    steps[step_index].maneuver.instruction.direction_modifier =
                        DirectionModifier::Straight;
                else
                    steps[step_index].maneuver.instruction.direction_modifier =
                        getTurnDirection(bearing_turn_angle);

                // if the total direction of this turn is now straight, we can keep it suppressed/as
                // a new name. Else we have to interpret it as a turn.
                if (!is_shift_or_curve)
                    steps[step_index].maneuver.instruction.type = TurnType::Turn;
                else
                    steps[step_index].maneuver.instruction.type = TurnType::NewName;
            }
            else
            {
                const auto total_angle = findTotalTurnAngle(steps[one_back_index], current_step);
                steps[step_index].maneuver.instruction.direction_modifier =
                    getTurnDirection(total_angle);
            }
        }

        steps[two_back_index].ElongateBy(one_back_step);
        // If the previous instruction asked to continue, the name change will have to
        // be changed into a turn
        steps[one_back_index].Invalidate();
    }
    // very short segment after turn, turn location remains at one_back_step
    else if (isDelayedTurn(
                 one_back_step, current_step, steps[two_back_index])) // checks for compatibility
    {
        steps[one_back_index].ElongateBy(steps[step_index]);
        // TODO check for lanes (https://github.com/Project-OSRM/osrm-backend/issues/2553)
        if (TurnType::Continue == one_back_step.maneuver.instruction.type &&
            isNoticeableNameChange(steps[two_back_index], current_step))
        {
            if (current_step.maneuver.instruction.type == TurnType::OnRamp ||
                current_step.maneuver.instruction.type == TurnType::OffRamp)
                steps[one_back_index].maneuver.instruction.type =
                    current_step.maneuver.instruction.type;
            else
                steps[one_back_index].maneuver.instruction.type = TurnType::Turn;
        }
        else if (TurnType::Turn == one_back_step.maneuver.instruction.type &&
                 !isNoticeableNameChange(steps[two_back_index], current_step))
        {
            steps[one_back_index].maneuver.instruction.type = TurnType::Continue;

            const auto getBearing = [](bool in, const RouteStep &step) {
                const auto index =
                    in ? step.intersections.front().in : step.intersections.front().out;
                return step.intersections.front().bearings[index];
            };

            // If we Merge onto the same street, we end up with a u-turn in some cases
            if (bearingsAreReversed(util::bearing::reverse(getBearing(true, one_back_step)),
                                    getBearing(false, current_step)))
            {
                steps[one_back_index].maneuver.instruction.direction_modifier =
                    DirectionModifier::UTurn;
            }
            steps[one_back_index].AdaptStepSignage(current_step);
        }
        else if (TurnType::NewName == one_back_step.maneuver.instruction.type ||
                 (TurnType::NewName == current_step.maneuver.instruction.type &&
                  steps[one_back_index].maneuver.instruction.type == TurnType::Suppressed))
            steps[one_back_index].maneuver.instruction.type = TurnType::Turn;

        if (TurnType::Merge == one_back_step.maneuver.instruction.type &&
            current_step.maneuver.instruction.type !=
                TurnType::Suppressed) // This suppressed is a check for highways. We might
                                      // need a highway-suppressed to get the turn onto a
                                      // highway...
        {
            steps[one_back_index].maneuver.instruction.direction_modifier = mirrorDirectionModifier(
                steps[one_back_index].maneuver.instruction.direction_modifier);
        }
        // on non merge-types, we check for a combined turn angle
        else if (TurnType::Merge != one_back_step.maneuver.instruction.type)
        {
            const auto combined_angle = findTotalTurnAngle(one_back_step, current_step);
            steps[one_back_index].maneuver.instruction.direction_modifier =
                getTurnDirection(combined_angle);
        }

        steps[one_back_index].name = current_step.name;
        steps[one_back_index].name_id = current_step.name_id;
        steps[step_index].Invalidate();
    }
    else if (TurnType::Suppressed == current_step.maneuver.instruction.type &&
             !isNoticeableNameChange(one_back_step, current_step) &&
             compatible(one_back_step, current_step))
    {
        steps[one_back_index].ElongateBy(current_step);
        const auto angle = findTotalTurnAngle(one_back_step, current_step);
        steps[one_back_index].maneuver.instruction.direction_modifier = getTurnDirection(angle);
        steps[step_index].Invalidate();
    }
    else if (TurnType::Turn == one_back_step.maneuver.instruction.type &&
             TurnType::OnRamp == current_step.maneuver.instruction.type &&
             compatible(one_back_step, current_step))
    {
        // turning onto a ramp makes the first turn into a ramp
        steps[one_back_index].ElongateBy(current_step);
        steps[one_back_index].maneuver.instruction.type = TurnType::OnRamp;
        const auto angle = findTotalTurnAngle(one_back_step, current_step);
        steps[one_back_index].maneuver.instruction.direction_modifier = getTurnDirection(angle);

        steps[one_back_index].AdaptStepSignage(current_step);
        steps[step_index].Invalidate();
    }
}

// Staggered intersection are very short zig-zags of a few meters.
// We do not want to announce these short left-rights or right-lefts:
//
//      * -> b      a -> *
//      |       or       |       becomes  a   ->   b
// a -> *                * -> b
//
bool isStaggeredIntersection(const std::vector<RouteStep> &steps,
                             const std::size_t &current_index,
                             const std::size_t &previous_index)
{
    const RouteStep previous = steps[previous_index];
    const RouteStep current = steps[current_index];

    // don't touch roundabouts
    if (entersRoundabout(previous.maneuver.instruction) ||
        entersRoundabout(current.maneuver.instruction))
        return false;
    // Base decision on distance since the zig-zag is a visual clue.
    // If adjusted, make sure to check validity of the is_right/is_left classification below
    const constexpr auto MAX_STAGGERED_DISTANCE = 3; // debatable, but keep short to be on safe side

    const auto angle = [](const RouteStep &step) {
        const auto &intersection = step.intersections.front();
        const auto entry_bearing = intersection.bearings[intersection.in];
        const auto exit_bearing = intersection.bearings[intersection.out];
        return util::bearing::angleBetween(entry_bearing, exit_bearing);
    };

    // Instead of using turn modifiers (e.g. as in isRightTurn) we want to be more strict here.
    // We do not want to trigger e.g. on sharp uturn'ish turns or going straight "turns".
    // Therefore we use the turn angle to derive 90 degree'ish right / left turns.
    // This more closely resembles what we understand as Staggered Intersection.
    // We have to be careful in cases with larger MAX_STAGGERED_DISTANCE values. If the distance
    // gets large, sharper angles might be not obvious enough to consider them a staggered
    // intersection. We might need to consider making the decision here dependent on the actual turn
    // angle taken. To do so, we could scale the angle-limits by a factor depending on the distance
    // between the turns.
    const auto is_right = [](const double angle) { return angle > 45 && angle < 135; };
    const auto is_left = [](const double angle) { return angle > 225 && angle < 315; };

    const auto left_right = is_left(angle(previous)) && is_right(angle(current));
    const auto right_left = is_right(angle(previous)) && is_left(angle(current));

    // A RouteStep holds distance/duration from the maneuver to the subsequent step.
    // We are only interested in the distance between the first and the second.
    const auto is_short = previous.distance < MAX_STAGGERED_DISTANCE;

    auto intermediary_mode_change = false;
    if (current_index > 1)
    {
        const auto &two_back_index = getPreviousIndex(previous_index, steps);
        const auto two_back_step = steps[two_back_index];
        intermediary_mode_change =
            two_back_step.mode == current.mode && previous.mode != current.mode;
    }

    // previous step maneuver intersections should be length 1 to indicate that
    // there are no intersections between the two potentially collapsible turns
    const auto no_intermediary_intersections = previous.intersections.size() == 1;

    return is_short && (left_right || right_left) && !intermediary_mode_change &&
           no_intermediary_intersections;
}

} // namespace

// A check whether two instructions can be treated as one. This is only the case for very short
// maneuvers that can, in some form, be seen as one. Lookahead of one step.
bool collapsable(const RouteStep &step, const RouteStep &next)
{
    const auto is_short_step = step.distance < MAX_COLLAPSE_DISTANCE;
    const auto instruction_can_be_collapsed = isCollapsableInstruction(step.maneuver.instruction);

    const auto is_use_lane = step.maneuver.instruction.type == TurnType::UseLane;
    const auto lanes_dont_change =
        step.intersections.front().lanes == next.intersections.front().lanes;

    if (is_short_step && instruction_can_be_collapsed)
        return true;

    // Prevent collapsing away important lane change steps
    if (is_short_step && is_use_lane && lanes_dont_change)
        return true;

    return false;
}

// Post processing can invalidate some instructions. For example StayOnRoundabout
// is turned into exit counts. These instructions are removed by the following function

std::vector<RouteStep> removeNoTurnInstructions(std::vector<RouteStep> steps)
{
    // finally clean up the post-processed instructions.
    // Remove all invalid instructions from the set of instructions.
    // An instruction is invalid, if its NO_TURN and has WaypointType::None.
    // Two valid NO_TURNs exist in each leg in the form of Depart/Arrive

    // keep valid instructions
    const auto not_is_valid = [](const RouteStep &step) {
        return step.maneuver.instruction == TurnInstruction::NO_TURN() &&
               step.maneuver.waypoint_type == WaypointType::None;
    };

    boost::remove_erase_if(steps, not_is_valid);

    // the steps should still include depart and arrive at least
    BOOST_ASSERT(steps.size() >= 2);

    BOOST_ASSERT(steps.front().intersections.size() >= 1);
    BOOST_ASSERT(steps.front().intersections.front().bearings.size() == 1);
    BOOST_ASSERT(steps.front().intersections.front().entry.size() == 1);
    BOOST_ASSERT(steps.front().maneuver.waypoint_type == WaypointType::Depart);

    BOOST_ASSERT(steps.back().intersections.size() == 1);
    BOOST_ASSERT(steps.back().intersections.front().bearings.size() == 1);
    BOOST_ASSERT(steps.back().intersections.front().entry.size() == 1);
    BOOST_ASSERT(steps.back().maneuver.waypoint_type == WaypointType::Arrive);

    return steps;
}

// Every Step Maneuver consists of the information until the turn.
// This list contains a set of instructions, called silent, which should
// not be part of the final output.
// They are required for maintenance purposes. We can calculate the number
// of exits to pass in a roundabout and the number of intersections
// that we come across.
std::vector<RouteStep> postProcess(std::vector<RouteStep> steps)
{
    // the steps should always include the first/last step in form of a location
    BOOST_ASSERT(steps.size() >= 2);
    if (steps.size() == 2)
        return steps;

    // Count Street Exits forward
    bool on_roundabout = false;
    bool has_entered_roundabout = false;

    // count the exits forward. if enter/exit roundabout happen both, no further treatment is
    // required. We might end up with only one of them (e.g. starting within a roundabout)
    // or having a via-point in the roundabout.
    // In this case, exits are numbered from the start of the leg.
    for (std::size_t step_index = 0; step_index < steps.size(); ++step_index)
    {
        const auto next_step_index = step_index + 1;
        auto &step = steps[step_index];
        const auto instruction = step.maneuver.instruction;
        if (entersRoundabout(instruction))
        {
            has_entered_roundabout = setUpRoundabout(step);

            if (has_entered_roundabout && next_step_index < steps.size())
                steps[next_step_index].maneuver.exit = step.maneuver.exit;
        }
        else if (instruction.type == TurnType::StayOnRoundabout)
        {
            on_roundabout = true;
            // increase the exit number we require passing the exit
            step.maneuver.exit += 1;
            if (next_step_index < steps.size())
                steps[next_step_index].maneuver.exit = step.maneuver.exit;
        }
        else if (leavesRoundabout(instruction))
        {
            // if (!has_entered_roundabout)
            // in case the we are not on a roundabout, the very first instruction
            // after the depart will be transformed into a roundabout and become
            // the first valid instruction
            closeOffRoundabout(has_entered_roundabout, steps, step_index);
            has_entered_roundabout = false;
            on_roundabout = false;
        }
        else if (on_roundabout && next_step_index < steps.size())
        {
            steps[next_step_index].maneuver.exit = step.maneuver.exit;
        }
    }

    // unterminated roundabout
    // Move backwards through the instructions until the start and remove the exit number
    // A roundabout without exit translates to enter-roundabout
    if (has_entered_roundabout || on_roundabout)
    {
        fixFinalRoundabout(steps);
    }

    BOOST_ASSERT(steps.front().intersections.size() >= 1);
    BOOST_ASSERT(steps.front().intersections.front().bearings.size() == 1);
    BOOST_ASSERT(steps.front().intersections.front().entry.size() == 1);
    BOOST_ASSERT(steps.front().maneuver.waypoint_type == WaypointType::Depart);

    BOOST_ASSERT(steps.back().intersections.size() == 1);
    BOOST_ASSERT(steps.back().intersections.front().bearings.size() == 1);
    BOOST_ASSERT(steps.back().intersections.front().entry.size() == 1);
    BOOST_ASSERT(steps.back().maneuver.waypoint_type == WaypointType::Arrive);

    return removeNoTurnInstructions(std::move(steps));
}

// Post Processing to collapse unnecessary sets of combined instructions into a single one
std::vector<RouteStep> collapseTurns(std::vector<RouteStep> steps)
{
    if (steps.size() <= 2)
        return steps;

    const auto getPreviousNameIndex = [&steps](std::size_t index) {
        BOOST_ASSERT(index > 0);
        BOOST_ASSERT(index < steps.size());
        --index; // make sure to skip the current name
        while (index > 0 && steps[index].name_id == EMPTY_NAMEID)
        {
            --index;
        }
        return index;
    };

    // a series of turns is only possible to collapse if its only name changes and suppressed turns.
    const auto canCollapseAll = [&steps](std::size_t index, const std::size_t end_index) {
        BOOST_ASSERT(end_index <= steps.size());
        if (!compatible(steps[index], steps[index + 1]))
            return false;
        ++index;
        for (; index < end_index; ++index)
        {
            if (steps[index].maneuver.instruction.type != TurnType::Suppressed &&
                steps[index].maneuver.instruction.type != TurnType::NewName)
                return false;
            if (index + 1 < end_index && !compatible(steps[index], steps[index + 1]))
                return false;
        }
        return true;
    };

    // first and last instructions are waypoints that cannot be collapsed
    for (std::size_t step_index = 1; step_index + 1 < steps.size(); ++step_index)
    {
        const auto &current_step = steps[step_index];
        const auto next_step_index = step_index + 1;
        const auto one_back_index = getPreviousIndex(step_index, steps);

        BOOST_ASSERT(one_back_index < steps.size());

        const auto &one_back_step = steps[one_back_index];
        if (hasRoundaboutType(current_step.maneuver.instruction) ||
            hasRoundaboutType(one_back_step.maneuver.instruction))
            continue;

        if (!hasManeuver(one_back_step, current_step))
            continue;

        // how long has a name change to be so that we announce it, even as a bridge?
        const constexpr auto name_segment_cutoff_length = 100;
        const auto isBasicNameChange = [](const RouteStep &step) {
            return step.intersections.size() == 1 &&
                   step.intersections.front().bearings.size() == 2 &&
                   DirectionModifier::Straight == step.maneuver.instruction.direction_modifier;
        };

        // Handle sliproads from motorways in urban areas, save from modifying depart, since
        // TurnType::Sliproad != TurnType::NoTurn
        if (one_back_step.maneuver.instruction.type == TurnType::Sliproad)
        {
            if (current_step.maneuver.instruction.type == TurnType::Suppressed &&
                compatible(one_back_step, current_step) && current_step.intersections.size() == 1 &&
                current_step.intersections.front().entry.size() == 2)
            {
                // Traffic light on the sliproad, the road itself will be handled in the next
                // iteration, when one-back-index again points to the sliproad.
                steps[one_back_index].ElongateBy(steps[step_index]);
                steps[step_index].Invalidate();
            }
            else
            {
                // Handle possible u-turns between highways that look like slip-roads
                if (steps[getPreviousIndex(one_back_index, steps)].name_id ==
                        steps[step_index].name_id &&
                    steps[step_index].name_id != EMPTY_NAMEID)
                {
                    steps[one_back_index].maneuver.instruction.type = TurnType::Continue;
                }
                else
                {
                    steps[one_back_index].maneuver.instruction.type = TurnType::Turn;
                }
                if (compatible(one_back_step, current_step))
                {
                    // Turn Types in the response depend on whether we find the same road name
                    // (sliproad indcating a u-turn) or if we are turning onto a different road, in
                    // which case we use a turn.
                    if (!isNoticeableNameChange(steps[getPreviousIndex(one_back_index, steps)],
                                                current_step) &&
                        current_step.name_id != EMPTY_NAMEID)
                        steps[one_back_index].maneuver.instruction.type = TurnType::Continue;
                    else
                        steps[one_back_index].maneuver.instruction.type = TurnType::Turn;

                    steps[one_back_index].ElongateBy(steps[step_index]);

                    steps[one_back_index].AdaptStepSignage(steps[step_index]);
                    // the turn lanes for this turn are on the sliproad itself, so we have to
                    // remember  them
                    steps[one_back_index].intersections.front().lanes =
                        current_step.intersections.front().lanes;
                    steps[one_back_index].intersections.front().lane_description =
                        current_step.intersections.front().lane_description;

                    const auto angle = findTotalTurnAngle(one_back_step, current_step);
                    steps[one_back_index].maneuver.instruction.direction_modifier =
                        getTurnDirection(angle);
                    steps[step_index].Invalidate();
                }
                else
                {
                    // the sliproad turn is incompatible. So we handle it as a turn
                    steps[one_back_index].maneuver.instruction.type = TurnType::Turn;
                }
            }
        }
        // Due to empty segments, we can get name-changes from A->A
        // These have to be handled in post-processing
        else if (isCollapsableInstruction(current_step.maneuver.instruction) &&
                 current_step.maneuver.instruction.type != TurnType::Suppressed &&
                 !isNoticeableNameChange(steps[getPreviousNameIndex(step_index)], current_step) &&
                 // canCollapseAll is also checking for compatible(step,step+1) for all indices
                 canCollapseAll(getPreviousNameIndex(step_index), next_step_index))
        {
            BOOST_ASSERT(step_index > 0);
            const std::size_t last_available_name_index = getPreviousNameIndex(step_index);

            for (std::size_t index = last_available_name_index + 1; index <= step_index; ++index)
            {
                steps[last_available_name_index].ElongateBy(steps[index]);
                steps[index].Invalidate();
            }
        }
        // If we look at two consecutive name changes, we can check for a name oscillation.
        // A name oscillation changes from name A shortly to name B and back to A.
        // In these cases, the name change will be suppressed.
        else if (one_back_index > 0 && compatible(current_step, one_back_step) &&
                 ((isCollapsableInstruction(current_step.maneuver.instruction) &&
                   isCollapsableInstruction(one_back_step.maneuver.instruction)) ||
                  isStaggeredIntersection(steps, step_index, one_back_index)))
        {
            const auto two_back_index = getPreviousIndex(one_back_index, steps);
            BOOST_ASSERT(two_back_index < steps.size());
            // valid, since one_back is collapsable or a turn and therefore not depart:
            if (!isNoticeableNameChange(steps[two_back_index], current_step))
            {
                if (compatible(one_back_step, steps[two_back_index]))
                {
                    steps[two_back_index]
                        .ElongateBy(steps[one_back_index])
                        .ElongateBy(steps[step_index]);
                    steps[one_back_index].Invalidate();
                    steps[step_index].Invalidate();
                }
                // TODO discuss: we could think about changing the new-name to a pure notification
                // about mode changes
            }
            else if (nameSegmentLength(one_back_index, steps) < name_segment_cutoff_length &&
                     isBasicNameChange(one_back_step) && isBasicNameChange(current_step))
            {
                if (compatible(steps[two_back_index], steps[one_back_index]))
                {
                    steps[two_back_index].ElongateBy(steps[one_back_index]);
                    steps[one_back_index].Invalidate();
                    if (nameSegmentLength(step_index, steps) < name_segment_cutoff_length &&
                        compatible(steps[two_back_index], steps[step_index]))
                    {
                        steps[two_back_index].ElongateBy(steps[step_index]);
                        steps[step_index].Invalidate();
                    }
                }
            }
            else if (step_index + 2 < steps.size() &&
                     current_step.maneuver.instruction.type == TurnType::NewName &&
                     steps[next_step_index].maneuver.instruction.type == TurnType::NewName &&
                     !isNoticeableNameChange(one_back_step, steps[next_step_index]))
            {
                if (compatible(steps[step_index], steps[next_step_index]))
                {
                    // if we are crossing an intersection and go immediately after into a name
                    // change,
                    // we don't wan't to collapse the initial intersection.
                    // a - b ---BRIDGE -- c
                    steps[one_back_index]
                        .ElongateBy(steps[step_index])
                        .ElongateBy(steps[next_step_index]);
                    steps[step_index].Invalidate();
                    steps[next_step_index].Invalidate();
                }
            }
            else if (choiceless(current_step, one_back_step) ||
                     one_back_step.distance <= MAX_COLLAPSE_DISTANCE)
            {
                // check for one of the multiple collapse scenarios and, if possible, collapse the
                // turn
                const auto two_back_index = getPreviousIndex(one_back_index, steps);
                BOOST_ASSERT(two_back_index < steps.size());
                collapseTurnAt(steps, two_back_index, one_back_index, step_index);
            }
        }
        else if (one_back_index > 0 &&
                 (one_back_step.distance <= MAX_COLLAPSE_DISTANCE ||
                  choiceless(current_step, one_back_step) ||
                  isLinkroad(
                      steps[getPreviousIndex(one_back_index, steps)], one_back_step, current_step)))
        {
            // check for one of the multiple collapse scenarios and, if possible, collapse the turn
            const auto two_back_index = getPreviousIndex(one_back_index, steps);
            BOOST_ASSERT(two_back_index < steps.size());
            // all turns that are handled lower down are also compatible
            collapseTurnAt(steps, two_back_index, one_back_index, step_index);
        }

        if (steps[step_index].maneuver.instruction.type == TurnType::Turn)
        {
            const auto u_turn_one_back_index = getPreviousIndex(step_index, steps);
            if (u_turn_one_back_index > 0)
            {
                const auto u_turn_two_back_index = getPreviousIndex(u_turn_one_back_index, steps);
                if (isUTurn(steps[u_turn_one_back_index],
                            steps[step_index],
                            steps[u_turn_two_back_index]))
                {
                    collapseUTurn(steps, u_turn_two_back_index, u_turn_one_back_index, step_index);
                }
            }
        }
    }

    // handle final sliproad
    if (steps.size() >= 3 &&
        steps[getPreviousIndex(steps.size() - 1, steps)].maneuver.instruction.type ==
            TurnType::Sliproad)
    {
        steps[getPreviousIndex(steps.size() - 1, steps)].maneuver.instruction.type = TurnType::Turn;
    }

    BOOST_ASSERT(steps.front().intersections.size() >= 1);
    BOOST_ASSERT(steps.front().intersections.front().bearings.size() == 1);
    BOOST_ASSERT(steps.front().intersections.front().entry.size() == 1);
    BOOST_ASSERT(steps.front().maneuver.waypoint_type == WaypointType::Depart);

    BOOST_ASSERT(steps.back().intersections.size() == 1);
    BOOST_ASSERT(steps.back().intersections.front().bearings.size() == 1);
    BOOST_ASSERT(steps.back().intersections.front().entry.size() == 1);
    BOOST_ASSERT(steps.back().maneuver.waypoint_type == WaypointType::Arrive);

    return removeNoTurnInstructions(std::move(steps));
}

// Doing this step in post-processing provides a few challenges we cannot overcome.
// The removal of an initial step imposes some copy overhead in the steps, moving all later
// steps to the front. In addition, we cannot reduce the travel time that is accumulated at a
// different location.
// As a direct implication, we have to keep the time of the initial/final turns (which adds a
// few seconds of inaccuracy at both ends. This is acceptable, however, since the turn should
// usually not be as relevant.
void trimShortSegments(std::vector<RouteStep> &steps, LegGeometry &geometry)
{
    if (steps.size() < 2 || geometry.locations.size() <= 2)
        return;

    // if phantom node is located at the connection of two segments, either one can be selected
    // as
    // turn
    //
    // a --- b
    //       |
    //       c
    //
    // If a route from b to c is requested, both a--b and b--c could be selected as start
    // segment.
    // In case of a--b, we end up with an unwanted turn saying turn-right onto b-c.
    // These cases start off with an initial segment which is of zero length.
    // We have to be careful though, since routing that starts in a roundabout has a valid.
    // To catch these cases correctly, we have to perform trimming prior to the post-processing

    BOOST_ASSERT(geometry.locations.size() >= steps.size());
    // Look for distances under 1m
    const bool zero_length_step = steps.front().distance <= 1 && steps.size() > 2;
    const bool duplicated_coordinate = util::coordinate_calculation::haversineDistance(
                                           geometry.locations[0], geometry.locations[1]) <= 1;
    if (zero_length_step || duplicated_coordinate)
    {

        // remove the initial distance value
        geometry.segment_distances.erase(geometry.segment_distances.begin());

        const auto offset = zero_length_step ? geometry.segment_offsets[1] : 1;
        if (offset > 0)
        {
            // fixup the coordinates/annotations/ids
            geometry.locations.erase(geometry.locations.begin(),
                                     geometry.locations.begin() + offset);
            geometry.annotations.erase(geometry.annotations.begin(),
                                       geometry.annotations.begin() + offset);
            geometry.osm_node_ids.erase(geometry.osm_node_ids.begin(),
                                        geometry.osm_node_ids.begin() + offset);
        }

        // We have to adjust the first step both for its name and the bearings
        if (zero_length_step)
        {
            // since we are not only checking for epsilon but for a full meter, we can have multiple
            // coordinates here. Move all offsets to the front and reduce by one. (This is an
            // inplace forward one and reduce by one)
            std::transform(geometry.segment_offsets.begin() + 1,
                           geometry.segment_offsets.end(),
                           geometry.segment_offsets.begin(),
                           [offset](const std::size_t val) { return val - offset; });

            geometry.segment_offsets.pop_back();
            const auto &current_depart = steps.front();
            auto &designated_depart = *(steps.begin() + 1);

            // FIXME this is required to be consistent with the route durations. The initial
            // turn is not actually part of the route, though
            designated_depart.duration += current_depart.duration;

            // update initial turn direction/bearings. Due to the duplicated first coordinate,
            // the initial bearing is invalid
            designated_depart.maneuver.waypoint_type = WaypointType::Depart;
            designated_depart.maneuver.bearing_before = 0;
            designated_depart.maneuver.instruction = TurnInstruction::NO_TURN();
            // we need to make this conform with the intersection format for the first intersection
            auto &first_intersection = designated_depart.intersections.front();
            designated_depart.intersections.front().lanes = util::guidance::LaneTuple();
            designated_depart.intersections.front().lane_description.clear();
            first_intersection.bearings = {first_intersection.bearings[first_intersection.out]};
            first_intersection.entry = {true};
            first_intersection.in = IntermediateIntersection::NO_INDEX;
            first_intersection.out = 0;

            // finally remove the initial (now duplicated move)
            steps.erase(steps.begin());
        }
        else
        {
            // we need to make this at least 1 because we will substract 1
            // from all offsets at the end of the loop.
            steps.front().geometry_begin = 1;

            // reduce all offsets by one (inplace)
            std::transform(geometry.segment_offsets.begin(),
                           geometry.segment_offsets.end(),
                           geometry.segment_offsets.begin(),
                           [](const std::size_t val) { return val - 1; });
        }

        // and update the leg geometry indices for the removed entry
        std::for_each(steps.begin(), steps.end(), [offset](RouteStep &step) {
            step.geometry_begin -= offset;
            step.geometry_end -= offset;
        });

        auto &first_step = steps.front();
        // we changed the geometry, we need to recalculate the bearing
        auto bearing = std::round(util::coordinate_calculation::bearing(
            geometry.locations[first_step.geometry_begin],
            geometry.locations[first_step.geometry_begin + 1]));
        first_step.maneuver.bearing_after = bearing;
        first_step.intersections.front().bearings.front() = bearing;
    }

    BOOST_ASSERT(steps.front().intersections.size() >= 1);
    BOOST_ASSERT(steps.front().intersections.front().bearings.size() == 1);
    BOOST_ASSERT(steps.front().intersections.front().entry.size() == 1);
    BOOST_ASSERT(steps.front().maneuver.waypoint_type == WaypointType::Depart);

    BOOST_ASSERT(steps.back().intersections.size() == 1);
    BOOST_ASSERT(steps.back().intersections.front().bearings.size() == 1);
    BOOST_ASSERT(steps.back().intersections.front().entry.size() == 1);
    BOOST_ASSERT(steps.back().maneuver.waypoint_type == WaypointType::Arrive);

    // make sure we still have enough segments
    if (steps.size() < 2 || geometry.locations.size() == 2)
        return;

    BOOST_ASSERT(geometry.locations.size() >= steps.size());
    auto &next_to_last_step = *(steps.end() - 2);
    // in the end, the situation with the roundabout cannot occur. As a result, we can remove
    // all zero-length instructions
    if (next_to_last_step.distance <= 1 && steps.size() > 2)
    {
        geometry.segment_offsets.pop_back();
        // remove all the last coordinates from the geometry
        geometry.locations.resize(geometry.segment_offsets.back() + 1);
        geometry.annotations.resize(geometry.segment_offsets.back() + 1);
        geometry.osm_node_ids.resize(geometry.segment_offsets.back() + 1);

        BOOST_ASSERT(geometry.segment_distances.back() <= 1);
        geometry.segment_distances.pop_back();

        next_to_last_step.maneuver.waypoint_type = WaypointType::Arrive;
        next_to_last_step.maneuver.instruction = TurnInstruction::NO_TURN();
        next_to_last_step.maneuver.bearing_after = 0;
        next_to_last_step.intersections.front().lanes = util::guidance::LaneTuple();
        next_to_last_step.intersections.front().lane_description.clear();
        next_to_last_step.geometry_end = next_to_last_step.geometry_begin + 1;
        BOOST_ASSERT(next_to_last_step.intersections.size() == 1);
        auto &last_intersection = next_to_last_step.intersections.back();
        last_intersection.bearings = {last_intersection.bearings[last_intersection.in]};
        last_intersection.entry = {true};
        last_intersection.out = IntermediateIntersection::NO_INDEX;
        last_intersection.in = 0;
        steps.pop_back();

        // Because we eliminated a really short segment, it was probably
        // near an intersection.  The convention is *not* to make the
        // turn, so the `arrive` instruction should be on the same road
        // as the segment before it.  Thus, we have to copy the names
        // and travel modes from the new next_to_last step.
        auto &new_next_to_last = *(steps.end() - 2);
        next_to_last_step.AdaptStepSignage(new_next_to_last);
        next_to_last_step.mode = new_next_to_last.mode;
        // the geometry indices of the last step are already correct;
    }
    else if (util::coordinate_calculation::haversineDistance(
                 geometry.locations[geometry.locations.size() - 2],
                 geometry.locations[geometry.locations.size() - 1]) <= 1)
    {
        // correct steps but duplicated coordinate in the end.
        // This can happen if the last coordinate snaps to a node in the unpacked geometry
        geometry.locations.pop_back();
        geometry.annotations.pop_back();
        geometry.osm_node_ids.pop_back();
        geometry.segment_offsets.back()--;
        // since the last geometry includes the location of arrival, the arrival instruction
        // geometry overlaps with the previous segment
        BOOST_ASSERT(next_to_last_step.geometry_end == steps.back().geometry_begin + 1);
        BOOST_ASSERT(next_to_last_step.geometry_begin < next_to_last_step.geometry_end);
        next_to_last_step.geometry_end--;
        auto &last_step = steps.back();
        last_step.geometry_begin--;
        last_step.geometry_end--;
        BOOST_ASSERT(next_to_last_step.geometry_end == last_step.geometry_begin + 1);
        BOOST_ASSERT(last_step.geometry_begin == last_step.geometry_end - 1);
        BOOST_ASSERT(next_to_last_step.geometry_end >= 2);
        // we changed the geometry, we need to recalculate the bearing
        auto bearing = std::round(util::coordinate_calculation::bearing(
            geometry.locations[next_to_last_step.geometry_end - 2],
            geometry.locations[last_step.geometry_begin]));
        last_step.maneuver.bearing_before = bearing;
        last_step.intersections.front().bearings.front() = util::bearing::reverse(bearing);
    }

    BOOST_ASSERT(steps.back().geometry_end == geometry.locations.size());

    BOOST_ASSERT(steps.front().intersections.size() >= 1);
    BOOST_ASSERT(steps.front().intersections.front().bearings.size() == 1);
    BOOST_ASSERT(steps.front().intersections.front().entry.size() == 1);
    BOOST_ASSERT(steps.front().maneuver.waypoint_type == WaypointType::Depart);

    BOOST_ASSERT(steps.back().intersections.size() == 1);
    BOOST_ASSERT(steps.back().intersections.front().bearings.size() == 1);
    BOOST_ASSERT(steps.back().intersections.front().entry.size() == 1);
    BOOST_ASSERT(steps.back().maneuver.waypoint_type == WaypointType::Arrive);
}

// assign relative locations to depart/arrive instructions
std::vector<RouteStep> assignRelativeLocations(std::vector<RouteStep> steps,
                                               const LegGeometry &leg_geometry,
                                               const PhantomNode &source_node,
                                               const PhantomNode &target_node)
{
    // We report the relative position of source/target to the road only within a range that is
    // sufficiently different but not full of the path
    BOOST_ASSERT(steps.size() >= 2);
    BOOST_ASSERT(leg_geometry.locations.size() >= 2);
    const constexpr double MINIMAL_RELATIVE_DISTANCE = 5., MAXIMAL_RELATIVE_DISTANCE = 300.;
    const auto distance_to_start = util::coordinate_calculation::haversineDistance(
        source_node.input_location, leg_geometry.locations[0]);
    const auto initial_modifier =
        distance_to_start >= MINIMAL_RELATIVE_DISTANCE &&
                distance_to_start <= MAXIMAL_RELATIVE_DISTANCE
            ? bearingToDirectionModifier(util::coordinate_calculation::computeAngle(
                  source_node.input_location, leg_geometry.locations[0], leg_geometry.locations[1]))
            : extractor::guidance::DirectionModifier::UTurn;

    steps.front().maneuver.instruction.direction_modifier = initial_modifier;

    const auto distance_from_end = util::coordinate_calculation::haversineDistance(
        target_node.input_location, leg_geometry.locations.back());
    const auto final_modifier =
        distance_from_end >= MINIMAL_RELATIVE_DISTANCE &&
                distance_from_end <= MAXIMAL_RELATIVE_DISTANCE
            ? bearingToDirectionModifier(util::coordinate_calculation::computeAngle(
                  leg_geometry.locations[leg_geometry.locations.size() - 2],
                  leg_geometry.locations[leg_geometry.locations.size() - 1],
                  target_node.input_location))
            : extractor::guidance::DirectionModifier::UTurn;

    steps.back().maneuver.instruction.direction_modifier = final_modifier;

    BOOST_ASSERT(steps.front().intersections.size() >= 1);
    BOOST_ASSERT(steps.front().intersections.front().bearings.size() == 1);
    BOOST_ASSERT(steps.front().intersections.front().entry.size() == 1);
    BOOST_ASSERT(steps.front().maneuver.waypoint_type == WaypointType::Depart);

    BOOST_ASSERT(steps.back().intersections.size() == 1);
    BOOST_ASSERT(steps.back().intersections.front().bearings.size() == 1);
    BOOST_ASSERT(steps.back().intersections.front().entry.size() == 1);
    BOOST_ASSERT(steps.back().maneuver.waypoint_type == WaypointType::Arrive);
    return steps;
}

LegGeometry resyncGeometry(LegGeometry leg_geometry, const std::vector<RouteStep> &steps)
{
    // The geometry uses an adjacency array-like structure for representation.
    // To sync it back up with the steps, we cann add a segment for every step.
    leg_geometry.segment_offsets.clear();
    leg_geometry.segment_distances.clear();
    leg_geometry.segment_offsets.push_back(0);

    for (const auto &step : steps)
    {
        leg_geometry.segment_distances.push_back(step.distance);
        // the leg geometry does not follow the begin/end-convetion. So we have to subtract one
        // to get the back-index.
        leg_geometry.segment_offsets.push_back(step.geometry_end - 1);
    }

    // remove the data from the reached-target step again
    leg_geometry.segment_offsets.pop_back();
    leg_geometry.segment_distances.pop_back();

    return leg_geometry;
}

std::vector<RouteStep> buildIntersections(std::vector<RouteStep> steps)
{
    std::size_t last_valid_instruction = 0;
    for (std::size_t step_index = 0; step_index < steps.size(); ++step_index)
    {
        auto &step = steps[step_index];
        const auto instruction = step.maneuver.instruction;
        if (instruction.type == TurnType::Suppressed)
        {
            BOOST_ASSERT(compatible(steps[last_valid_instruction], step));
            // count intersections. We cannot use exit, since intersections can follow directly
            // after a roundabout
            steps[last_valid_instruction].ElongateBy(step);
            steps[step_index].Invalidate();
        }
        else if (!isSilent(instruction))
        {

            // End of road is a turn that helps to identify the location of a turn. If the turn does
            // not pass by any oter intersections, the end-of-road characteristic does not improve
            // the instructions.
            // Here we reduce the verbosity of our output by reducing end-of-road emissions in cases
            // where no intersections have been passed in between.
            // Since the instruction is located at the beginning of a step, we need to check the
            // previous instruction.
            if (instruction.type == TurnType::EndOfRoad)
            {
                BOOST_ASSERT(step_index > 0);
                const auto &previous_step = steps[last_valid_instruction];
                if (previous_step.intersections.size() < MIN_END_OF_ROAD_INTERSECTIONS)
                    step.maneuver.instruction.type = TurnType::Turn;
            }

            // Remember the last non silent instruction
            last_valid_instruction = step_index;
        }
    }
    return removeNoTurnInstructions(std::move(steps));
}

// `useLane` steps are only returned on `straight` maneuvers when there
// are surrounding lanes also tagged as `straight`. If there are no other `straight`
// lanes, it is not an ambiguous maneuver, and we can collapse the `useLane` step.
std::vector<RouteStep> collapseUseLane(std::vector<RouteStep> steps)
{
    const auto containsTag = [](const extractor::guidance::TurnLaneType::Mask mask,
                                const extractor::guidance::TurnLaneType::Mask tag) {
        return (mask & tag) != extractor::guidance::TurnLaneType::empty;
    };

    const auto canCollapseUseLane = [containsTag](const RouteStep &step) {
        // the lane description is given left to right, lanes are counted from the right.
        // Therefore we access the lane description using the reverse iterator

        auto right_most_lanes = step.LanesToTheRight();
        if (!right_most_lanes.empty() && containsTag(right_most_lanes.front(),
                                                     (extractor::guidance::TurnLaneType::straight |
                                                      extractor::guidance::TurnLaneType::none)))
            return false;

        auto left_most_lanes = step.LanesToTheLeft();
        if (!left_most_lanes.empty() && containsTag(left_most_lanes.back(),
                                                    (extractor::guidance::TurnLaneType::straight |
                                                     extractor::guidance::TurnLaneType::none)))
            return false;

        return true;
    };

    for (std::size_t step_index = 1; step_index < steps.size(); ++step_index)
    {
        const auto &step = steps[step_index];
        if (step.maneuver.instruction.type == TurnType::UseLane && canCollapseUseLane(step))
        {
            const auto previous = getPreviousIndex(step_index, steps);
            if (compatible(steps[previous], step))
            {
                steps[previous].ElongateBy(steps[step_index]);
                steps[step_index].Invalidate();
            }
        }
    }
    return removeNoTurnInstructions(std::move(steps));
}

} // namespace guidance
} // namespace engine
} // namespace osrm