#include "selectors.hh"

#include <algorithm>

namespace Kakoune
{

static bool is_eol(char c)
{
    return c == '\n';
}

static bool is_blank(char c)
{
    return c == ' ' or c == '\t';
}

static bool is_word(char c)
{
    if (c >= '0' and c <= '9')
        return true;
    if (c >= 'a' and c <= 'z')
        return true;
    if (c >= 'A' and c <= 'Z')
        return true;
    if (c == '_')
        return true;
    return false;
}

static bool is_punctuation(char c)
{
    return not (is_word(c) or is_blank(c) or is_eol(c));
}

enum class CharCategories
{
    Blank,
    EndOfLine,
    Word,
    Punctuation,
};

static CharCategories categorize(char c)
{
    if (is_word(c))
        return CharCategories::Word;
    if (is_eol(c))
        return CharCategories::EndOfLine;
    if (is_blank(c))
        return CharCategories::Blank;
    return CharCategories::Punctuation;
}

template<typename T>
void skip_while(BufferIterator& it, T condition)
{
    while (not it.is_end() and condition(*it))
        ++it;
}

template<typename T>
void skip_while_reverse(BufferIterator& it, T condition)
{
    while (not it.is_begin() and condition(*it))
        --it;
}


Selection select_to_next_word(const BufferIterator& cursor)
{
    BufferIterator begin = cursor;
    if (categorize(*begin) != categorize(*(begin+1)))
        ++begin;

    skip_while(begin, is_eol);

    BufferIterator end = begin+1;

    if (is_punctuation(*begin))
        skip_while(end, is_punctuation);
    else if (is_word(*begin))
        skip_while(end, is_word);

    skip_while(end, is_blank);

    return Selection(begin, end-1);
}

Selection select_to_next_word_end(const BufferIterator& cursor)
{
    BufferIterator begin = cursor;
    if (categorize(*begin) != categorize(*(begin+1)))
        ++begin;

    skip_while(begin, is_eol);
    BufferIterator end = begin;
    skip_while(end, is_blank);

    if (is_punctuation(*end))
        skip_while(end, is_punctuation);
    else if (is_word(*end))
        skip_while(end, is_word);

    return Selection(begin, end-1);
}

Selection select_to_previous_word(const BufferIterator& cursor)
{
    BufferIterator begin = cursor;

    if (categorize(*begin) != categorize(*(begin-1)))
        --begin;

    skip_while_reverse(begin, is_eol);
    BufferIterator end = begin;
    skip_while_reverse(end, is_blank);

    if (is_punctuation(*end))
        skip_while_reverse(end, is_punctuation);
    else if (is_word(*end))
        skip_while_reverse(end, is_word);

    return Selection(begin, end+1);
}

Selection select_line(const BufferIterator& cursor)
{
    BufferIterator first = cursor;
    while (not first.is_begin() and *(first - 1) != '\n')
        --first;

    BufferIterator last = cursor;
    while (not (last + 1).is_end() and *last != '\n')
        ++last;
    return Selection(first, last);
}

Selection select_matching(const BufferIterator& cursor)
{
    std::vector<char> matching_pairs = { '(', ')', '{', '}', '[', ']', '<', '>' };
    BufferIterator it = cursor;
    std::vector<char>::iterator match = matching_pairs.end();
    while (not is_eol(*it))
    {
        match = std::find(matching_pairs.begin(), matching_pairs.end(), *it);
        if (match != matching_pairs.end())
            break;
        ++it;
    }
    if (match == matching_pairs.end())
        return Selection(cursor, cursor);

    BufferIterator begin = it;

    if (((match - matching_pairs.begin()) % 2) == 0)
    {
        int level = 0;
        const char opening = *match;
        const char closing = *(match+1);
        while (not it.is_end())
        {
            if (*it == opening)
                ++level;
            else if (*it == closing and --level == 0)
                return Selection(begin, it);

            ++it;
        }
    }
    else
    {
        int level = 0;
        const char opening = *(match-1);
        const char closing = *match;
        while (not it.is_begin())
        {
            if (*it == closing)
                ++level;
            else if (*it == opening and --level == 0)
                return Selection(begin, it);
            --it;
        }
    }
    return Selection(cursor, cursor);
}

Selection select_to(const BufferIterator& cursor, char c, int count, bool inclusive)
{
    BufferIterator end = cursor;
    do
    {
        ++end;
        skip_while(end, [c](char cur) { return not is_eol(cur) and cur != c; });
        if (end.is_end() or is_eol(*end))
            return Selection(cursor, cursor);
    }
    while (--count > 0);

    return Selection(cursor, inclusive ? end : end-1);
}

Selection select_to_reverse(const BufferIterator& cursor, char c, int count, bool inclusive)
{
    BufferIterator end = cursor;
    do
    {
        --end;
        skip_while_reverse(end, [c](char cur) { return not is_eol(cur) and cur != c; });
        if (end.is_begin() or is_eol(*end))
            return Selection(cursor, cursor);
    }
    while (--count > 0);

    return Selection(cursor, inclusive ? end : end+1);
}

Selection select_to_eol(const BufferIterator& cursor)
{
    BufferIterator end = cursor + 1;
    skip_while(end, [](char cur) { return not is_eol(cur); });
    return Selection(cursor, end-1);
}

Selection select_to_eol_reverse(const BufferIterator& cursor)
{
    BufferIterator end = cursor - 1;
    skip_while_reverse(end, [](char cur) { return not is_eol(cur); });
    return Selection(cursor, end.is_begin() ? end : end+1);
}

}