#include <string>
#include <iostream>
#include <vector>
#include <span>

namespace {

enum Dominoes : char {
    Dot = '.',
    L = 'L',
    R = 'R',
};

using Range = std::tuple<size_t, size_t>;
using Ranges = std::vector<Range>; 

class Solution {
    Ranges findRanges(const std::string& dominoes) {
        Ranges ranges;
        ranges.reserve(dominoes.size() / 2);

        size_t start = -1;

        for (size_t i = 0; i < dominoes.size(); ++i) {
            char d = dominoes[i];

            if (d == Dot && start == -1) {
                start = i;
            } else if (d != Dot && start != -1) {
                ranges.emplace_back(start, i);
                start = -1;
            }
        }

        if (start != -1) {
            ranges.emplace_back(start, dominoes.size());
        }

        return ranges;
    }
    void processRange(const Range& range, std::string& dominoes) {
        bool left_r = false;
        bool right_l = false;

        const auto& [start, end] = range;

        if (start > 0 && dominoes[start - 1] == R)
            left_r = true;
        if (end < (dominoes.size()) && dominoes[end] == L)
            right_l = true;

        if (left_r && right_l) {
            /*
            * 3 4 5 6 7
            * . . . . L
            */
           auto difference = end - start;
           auto steps = difference / 2;

           for (auto i = 0; i < steps; ++i) {
                dominoes[start + i] = R;
                dominoes[end - 1 - i] = L;
           }
        } else if (left_r) {
            for (auto i = start; i < end; ++i) dominoes[i] = R;
        } else if (right_l) {
            for (auto i = start; i < end; ++i) dominoes[i] = L;
        }
    }
    public:
        std::string pushDominoes(std::string dominoes) {
            auto ranges = findRanges(dominoes);
            for (const auto& range : ranges) {
                auto& [start, end] = range;
                std::cout << "[" << start << ", " << end << "]\n";
                processRange(range, dominoes);
            }
            return dominoes;
        }
    };
}

#include <gtest/gtest.h>

TEST(P838_2, 1) {
    std::string input = ".L.R...LR..L..";
    Solution s;
    auto result = s.pushDominoes(input);
    EXPECT_EQ(result, std::string("LL.RR.LLRRLL.."));
}