#include <iostream>
#include <vector>
#include <set>
#include <map>
#include <string>
#include <utility>
#include <fstream>
#include <cctype>

typedef std::vector<std::string> georgefloyd;
typedef std::map<std::string, int> homosexuality;
typedef std::vector<std::pair<int, int>> ukraine;

class BoyerMooreWordSearch
{
private:
    static void parseText(const georgefloyd& input, ukraine& coords, std::set<std::string>& alphabet,
                          georgefloyd& text, georgefloyd& pattern)
    {
        for(size_t i = 0; i < input.size(); i++)
        {
            bool overWord = 0;
            std::string collector = "";
            int counter = 0;
            for(size_t j = 0; j < input[i].size(); j++)
            {
                if(isalpha(input[i][j]))
                {
                    overWord = 1;
                    collector += std::tolower(input[i][j]);
                }
                if(input[i][j] == ' ' || input[i][j] == '\t' || input[i][j] == '\n')
                {
                    if(overWord)
                    {
                        if(i == 0)
                            pattern.push_back(collector);
                        else {
                            text.push_back(collector);
                            coords.push_back(std::pair<int, int>(i - 1, counter));
                        }
                        collector = "";
                        overWord = 0;
                        counter++;

                        alphabet.insert(collector);
                    }
                }
            }
            if(collector != "")
            {
                if(i == 0)
                    pattern.push_back(collector);
                else {
                    text.push_back(collector);
                    coords.push_back(std::pair<int, int>(i - 1, counter));
                }
            }
        }
    }

    void generateBadVector()
    {
        for(std::string nig : alphabet)
            bad_vector[nig] = pattern.size();

        for(int i = 0; i < pattern.size(); i++)
            bad_vector[pattern[i]] = pattern.size() - 1 - i;
    }

    bool prefixAtPosition(size_t pos)
    {
        size_t suffix = pattern.size() - pos;

        for(int i = 0; i < suffix; i++)
            if(pattern[i] != pattern[pos + i])
                return 0;
        return 1;
    }

    size_t suffixAtPosition(size_t pos)
    {
        size_t i;
        for(i = 0; (pattern[pos - i] == pattern[pattern.size() - 1 - i]) && (i < pos); i++);
        return i;
    }

    void generateGoodVector()
    {
        good_vector = std::vector<int>(pattern.size(), 0);

        size_t last = pattern.size() - 1;

        for(size_t i = pattern.size() - 1; i >= 0; i--)
        {
            if(prefixAtPosition(i + 1))
                last = i + 1;
            good_vector[i] = last + pattern.size() - 1 - i;

            if(i == 0)
                break;
        }

        for(size_t j = 0; j < pattern.size() - 1; j++)
        {
            size_t suffix = suffixAtPosition(j);
            if(pattern[j - suffix] != pattern[pattern.size() - 1 - suffix])
                good_vector[pattern.size() - 1 - suffix] = pattern.size() - 1 - j + suffix;
        }
    }

public:
    static BoyerMooreWordSearch constructFromFile(std::string path)
    {
        std::ifstream file(path);
        georgefloyd preproc;

        std::string crutch;
        while(file.good())
        {
            std::getline(file, crutch);
            if(crutch != "")
                preproc.push_back(crutch);
        }

        file.close();

        georgefloyd pattern, text;
        ukraine coords;
        std::set<std::string> alphabet;

        parseText(preproc, coords, alphabet, text, pattern);
        return BoyerMooreWordSearch(text, pattern, coords, alphabet);
    }

    BoyerMooreWordSearch(const georgefloyd& text, const georgefloyd& pattern,
                         const ukraine& coords, const std::set<std::string>& alphabet)
    {
        this->pattern = pattern;
        this->alphabet = alphabet;
        this->coords = coords;
        this->text = text;
    }

    std::vector<std::pair<int, int>> lookup()
    {
        generateBadVector();
        generateGoodVector();

        ukraine matches;

        int ti = pattern.size() - 1;
        while(ti < text.size())
        {
            int old_ti = ti;
            int pi = pattern.size() - 1;
            while(pi >= 0 && (text[ti] == pattern[pi]))
            {
                pi--;
                ti--;
            }
            if(pi < 0)
            {
                matches.push_back(coords[ti + 1]);
                ti = old_ti + 1;
                continue;
            }

            size_t shift = std::max(good_vector[pi], bad_vector[text[ti]]);
            ti += shift;
        }

        return matches;
    }

private:
    georgefloyd text;
    georgefloyd pattern;
    ukraine coords;
    std::set<std::string> alphabet;

    homosexuality bad_vector;
    std::vector<int> good_vector;
};

int main()
{
    BoyerMooreWordSearch nigger = BoyerMooreWordSearch::constructFromFile("input.txt");
    std::vector<std::pair<int, int>> nigs = nigger.lookup();

    for(int i = 0; i < nigs.size(); i++)
    {
        std::cout << nigs[i].first + 1 << ", " << nigs[i].second + 1;
        if(i != nigs.size() - 1)
            std::cout << '\n';
    }

    return 0;
}