#include "BufferView.h"
#include <list>
#include <utility>
#include <limits.h>

BufferView::BufferView(std::shared_ptr<Buffer> buffer,
        std::shared_ptr<Buffer::Iterator> iterator,
        CharacterWidthDeterminer & character_width_determiner)
    : m_buffer(buffer),
      m_iterator(iterator),
      m_character_width_determiner(character_width_determiner)
{
    m_width = 1;
    m_height = 1;
    m_scroll_offset = 0;
    m_cursor_screen_row = 0;
    m_cursor_screen_column = 0;
    m_cursor_virtual_column = 0;
    m_cursor_row_offset = 0;
    m_rows_in_cursor_line = 0;
    m_target_screen_column = 0;
    m_target_virtual_column = 0;
    m_update_target_column = false;
}

void BufferView::resize(int width, int height)
{
    m_width = std::max(1, width);
    m_height = std::max(1, height);
}

void BufferView::set_scroll_offset(int scroll_offset)
{
    m_scroll_offset = std::max(0, scroll_offset);
}

BufferView::Iterator BufferView::vert_iter()
{
    return Iterator(*this);
}

void BufferView::update()
{
    /* Calculate number of rows in the cursor line and update cursor row offset
     * and cursor column values. */
    auto start_of_line = std::make_shared<Buffer::Iterator>(*m_iterator);
    start_of_line->go_start_of_line();
    m_rows_in_cursor_line = calculate_rows_in_cursor_line(start_of_line);

    /* Limit the cursor screen row taking into account view dimensions,
     * available buffer contents above and below the current line, and scroll
     * offset. */
    std::list<std::pair<int, std::shared_ptr<Buffer::Iterator>>> backward_lines;
    int so = effective_scroll_offset();
    int rows_above = screen_rows_above_line(start_of_line, backward_lines) + m_cursor_row_offset;
    int rows_below = screen_rows_below_line(start_of_line) + std::max(0, m_rows_in_cursor_line - m_cursor_row_offset - 1);
    int min_rows_to_leave_above = std::min(rows_above, so);
    int min_rows_to_leave_below = std::min(rows_below, so);
    m_cursor_screen_row = std::min(m_height - min_rows_to_leave_below - 1, m_cursor_screen_row);
    m_cursor_screen_row = std::max(min_rows_to_leave_above, m_cursor_screen_row);
    m_cursor_screen_row = std::max(m_height - rows_below - 1, m_cursor_screen_row);
    m_cursor_screen_row = std::min(rows_above, m_cursor_screen_row);

    /* Determine the first line that is visible in this view. */
    auto line_iterator = std::make_shared<Buffer::Iterator>(*m_iterator);
    int row_offset = m_cursor_screen_row - m_cursor_row_offset;
    if (row_offset <= 0)
    {
        line_iterator->go_start_of_line();
    }
    else for (auto rows_iterator_pair : backward_lines)
    {
        row_offset -= rows_iterator_pair.first;
        line_iterator = rows_iterator_pair.second;
        if (row_offset <= 0)
        {
            break;
        }
    }

    /* Now start with first visible line and build up all lines visible in the view. */
    m_lines.clear();
    while ((row_offset < m_height) && (line_iterator->valid()))
    {
        LineDescriptor ld;
        ld.row_offset = row_offset;
        ld.n_rows = calculate_rows_in_line(line_iterator);
        ld.line = std::make_shared<Buffer::Iterator>(*line_iterator);
        m_lines.push_back(ld);
        row_offset += ld.n_rows;
        if (!line_iterator->go_next_line())
            break;
    }

    /* Reset some fields if buffer becomes empty. */
    if (!m_iterator->valid())
    {
        m_cursor_screen_row = 0;
        m_cursor_screen_column = 0;
        m_cursor_virtual_column = 0;
    }
}

bool BufferView::cursor_move(CursorMovement which, uint32_t c, bool allow_eol)
{
    bool moved = false;

    switch (which)
    {
    case CursorMovement::LEFT:
        moved = m_iterator->go_left_in_line();
        m_update_target_column = true;
        break;
    case CursorMovement::RIGHT:
        moved = m_iterator->go_right_in_line(allow_eol);
        m_update_target_column = true;
        break;
    case CursorMovement::UP:
        moved = m_iterator->go_previous_line();
        break;
    case CursorMovement::DOWN:
        moved = m_iterator->go_next_line();
        break;
    case CursorMovement::SOL:
        moved = m_iterator->go_start_of_line();
        m_target_screen_column = 0;
        m_target_virtual_column = 0;
        break;
    case CursorMovement::EOL:
        moved = m_iterator->go_end_of_line(allow_eol);
        m_target_screen_column = INT_MAX;
        m_target_virtual_column = INT_MAX;
        break;
    case CursorMovement::START_OF_FILE:
    case CursorMovement::FIRST_LINE:
        {
            auto it = m_buffer->begin();
            if (it != *m_iterator)
            {
                *m_iterator = it;
                moved = true;
            }
        }
        m_target_screen_column = 0;
        m_target_virtual_column = 0;
        break;
    case CursorMovement::END_OF_FILE:
        {
            auto it = m_buffer->end();
            it.go_back();
            /* TODO: optimize this */
            it.go_start_of_line();
            it.go_end_of_line(allow_eol);
            if (it != *m_iterator)
            {
                *m_iterator = it;
                moved = true;
            }
        }
        m_update_target_column = true;
        break;
    case CursorMovement::LAST_LINE:
        {
            auto it = m_buffer->end();
            it.go_back();
            it.go_start_of_line();
            if (it != *m_iterator)
            {
                *m_iterator = it;
                moved = true;
            }
        }
        m_target_screen_column = 0;
        m_target_virtual_column = 0;
        break;
    case CursorMovement::SCREEN_ROW_UP:
        moved = move_cursor_screen_row_up(allow_eol);
        break;
    case CursorMovement::SCREEN_ROW_DOWN:
        moved = move_cursor_screen_row_down(allow_eol);
        break;
    case CursorMovement::FORWARD_UP_TO_CHAR:
        moved = m_iterator->go_forward_in_line_up_to_char(c);
        break;
    case CursorMovement::FORWARD_ON_TO_CHAR:
        moved = m_iterator->go_forward_in_line_on_to_char(c);
        break;
    case CursorMovement::BACK_UP_TO_CHAR:
        moved = m_iterator->go_backward_in_line_up_to_char(c);
        break;
    case CursorMovement::BACK_ON_TO_CHAR:
        moved = m_iterator->go_backward_in_line_on_to_char(c);
        break;
    case CursorMovement::TOP_OF_SCREEN:
        {
            int n_lines = n_screen_rows_with_content();
            int y = (n_lines < m_height) ? 0 : effective_scroll_offset();
            moved = cursor_move_to_screen_position(0, y, allow_eol);
        }
        break;
    case CursorMovement::MIDDLE_OF_SCREEN:
        {
            int n_lines = n_screen_rows_with_content();
            int y = (n_lines < m_height) ? (n_lines / 2) : (m_height / 2);
            moved = cursor_move_to_screen_position(0, y, allow_eol);
        }
        break;
    case CursorMovement::BOTTOM_OF_SCREEN:
        {
            int n_lines = n_screen_rows_with_content();
            int y = (n_lines < m_height) ? (n_lines - 1) : (m_height - effective_scroll_offset() - 1);
            moved = cursor_move_to_screen_position(0, y, allow_eol);
            }
        break;
    }
    if (moved)
    {
        switch (which)
        {
        case CursorMovement::LEFT:
        case CursorMovement::RIGHT:
        case CursorMovement::SCREEN_ROW_UP:
        case CursorMovement::SCREEN_ROW_DOWN:
            determine_new_cursor_screen_row();
            break;
        case CursorMovement::UP:
        case CursorMovement::DOWN:
            move_forward_to_column(m_target_virtual_column, allow_eol);
            determine_new_cursor_screen_row();
            break;
        case CursorMovement::SOL:
        case CursorMovement::EOL:
        case CursorMovement::FORWARD_UP_TO_CHAR:
        case CursorMovement::FORWARD_ON_TO_CHAR:
        case CursorMovement::BACK_UP_TO_CHAR:
        case CursorMovement::BACK_ON_TO_CHAR:
            determine_new_cursor_screen_row();
            break;
        case CursorMovement::START_OF_FILE:
        case CursorMovement::FIRST_LINE:
            m_cursor_screen_row = 0;
            break;
        case CursorMovement::END_OF_FILE:
        case CursorMovement::LAST_LINE:
            m_cursor_screen_row = m_height - 1;
            break;
        case CursorMovement::TOP_OF_SCREEN:
        case CursorMovement::MIDDLE_OF_SCREEN:
        case CursorMovement::BOTTOM_OF_SCREEN:
            m_target_virtual_column = 0;
            m_target_screen_column = 0;
            break;
        }
    }

    return moved;
}

bool BufferView::cursor_move_to_line(size_t target_line)
{
    size_t current_line = m_iterator->line();
    std::shared_ptr<Buffer::Iterator> it;
    if (target_line <= current_line / 2u)
    {
        it = m_buffer->beginp();
    }
    else if (target_line <= ((current_line + m_buffer->end().line()) / 2u))
    {
        it = m_iterator->clonep();
    }
    else
    {
        it = m_buffer->endp();
        it->go_back();
        it->go_start_of_line();
    }
    while (it->line() < target_line)
    {
        if (!it->go_next_line())
            break;
    }
    while (it->line() > target_line)
    {
        if (!it->go_previous_line())
            break;
    }
    if (current_line != it->line())
    {
        *m_iterator = *it;
        determine_new_cursor_screen_row();
        return true;
    }
    return false;
}

bool BufferView::cursor_move_to_screen_position(int x, int y, bool allow_eol)
{
    bool moved = false;
    for (const LineDescriptor & screen_line : m_lines)
    {
        if ((y >= screen_line.row_offset) &&
                (y < (screen_line.row_offset + screen_line.n_rows)))
        {
            Buffer::Iterator scan_iter = *m_iterator;
            bool set = false;
            int desired_row_offset = y - screen_line.row_offset;
            for (auto it = horiz_iter(screen_line.line); it.is_valid(); it++)
            {
                if (it.row_offset() == desired_row_offset)
                {
                    if ((!set) ||
                            ((it.screen_column() <= x) && (allow_eol || (!it.is_eol()))))
                    {
                        scan_iter = *it.iterator();
                        set = true;
                    }
                }
            }
            if (scan_iter != *m_iterator)
            {
                *m_iterator = scan_iter;
                moved = true;
                determine_new_cursor_screen_row();
            }
            break;
        }
    }
    return moved;
}

void BufferView::scroll_view_up(int n_lines, bool allow_eol)
{
    int orig_cursor_screen_row = m_cursor_screen_row;
    int so = effective_scroll_offset();
    int rows_to_move_cursor = (so + n_lines) - (m_height - m_cursor_screen_row - 1);
    rows_to_move_cursor = std::min(calculate_rows_above_screen(rows_to_move_cursor), rows_to_move_cursor);
    int actual_lines_moved = 0;
    while (rows_to_move_cursor-- > 0)
    {
        if (move_cursor_screen_row_up(allow_eol))
        {
            actual_lines_moved++;
            update();
        }
        else
        {
            break;
        }
    }
    m_cursor_screen_row = orig_cursor_screen_row + (n_lines - actual_lines_moved);
}

void BufferView::scroll_view_down(int n_lines, bool allow_eol)
{
    int orig_cursor_screen_row = m_cursor_screen_row;
    int so = effective_scroll_offset();
    int rows_to_move_cursor = (so + n_lines) - m_cursor_screen_row;
    rows_to_move_cursor = std::min(calculate_rows_below_screen(rows_to_move_cursor), rows_to_move_cursor);
    int actual_lines_moved = 0;
    while (rows_to_move_cursor-- > 0)
    {
        if (move_cursor_screen_row_down(allow_eol))
        {
            actual_lines_moved++;
            update();
        }
        else
        {
            break;
        }
    }
    m_cursor_screen_row = orig_cursor_screen_row - (n_lines - actual_lines_moved);
}

/**************************************************************************
 * Internal functions
 *************************************************************************/

void BufferView::determine_new_cursor_screen_row()
{
    if (m_lines.size() > 0)
    {
        if (m_iterator->line() < m_lines.begin()->line->line())
        {
            m_cursor_screen_row = 0;
            return;
        }
        if (m_iterator->line() > m_lines.rbegin()->line->line())
        {
            m_cursor_screen_row = m_height - 1;
            return;
        }
        for (const LineDescriptor & screen_line : m_lines)
        {
            if (screen_line.line->line() == m_iterator->line())
            {
                m_cursor_screen_row = screen_line.row_offset + m_cursor_row_offset;
                return;
            }
        }
    }
}

int BufferView::calculate_rows_in_line(std::shared_ptr<Buffer::Iterator> start_of_line)
{
    int saved_row_offset = 0;
    for (auto it = horiz_iter(start_of_line); it.is_valid(); it++)
    {
        if (!it.is_eol())
        {
            saved_row_offset = it.row_offset();
        }
        else
        {
            break;
        }
    }
    return saved_row_offset + 1;
}

int BufferView::calculate_rows_in_cursor_line(std::shared_ptr<Buffer::Iterator> start_of_line)
{
    int saved_row_offset = 0;
    for (auto it = horiz_iter(start_of_line); it.is_valid(); it++)
    {
        if (*it.iterator() == *m_iterator)
        {
            m_cursor_virtual_column = it.virtual_column();
            m_cursor_screen_column = it.screen_column();
            if (m_update_target_column)
            {
                m_target_screen_column = m_cursor_screen_column;
                m_target_virtual_column = m_cursor_virtual_column;
            }
            m_cursor_row_offset = it.row_offset();
        }
        if (!it.is_eol())
        {
            saved_row_offset = it.row_offset();
        }
        else
        {
            break;
        }
    }
    m_update_target_column = false;
    return saved_row_offset + 1;
}

int BufferView::screen_rows_below_line(std::shared_ptr<Buffer::Iterator> line)
{
    auto i = std::make_shared<Buffer::Iterator>(*line);
    int rows = 0;
    while ((rows < m_height) && i->go_next_line())
    {
        rows += calculate_rows_in_line(i);
    }
    return rows;
}

int BufferView::screen_rows_above_line(
        std::shared_ptr<Buffer::Iterator> line,
        std::list<std::pair<int, std::shared_ptr<Buffer::Iterator>>> & backward_lines)
{
    auto i = std::make_shared<Buffer::Iterator>(*line);
    int rows = 0;
    while ((rows < m_height) && i->go_previous_line())
    {
        int rows_in_this_line = calculate_rows_in_line(i);
        rows += rows_in_this_line;
        backward_lines.push_back(std::pair<int, std::shared_ptr<Buffer::Iterator>>(rows_in_this_line, std::make_shared<Buffer::Iterator>(*i)));
    }
    return rows;
}

void BufferView::move_forward_to_column(int to_column, bool allow_eol)
{
    auto start_of_line = std::make_shared<Buffer::Iterator>(*m_iterator);
    start_of_line->go_start_of_line();
    for (auto it = horiz_iter(start_of_line); it.is_valid(); it++)
    {
        if (allow_eol || (!it.is_eol()))
        {
            if (it.virtual_column() <= to_column)
            {
                *m_iterator = *it.iterator();
            }
            else
            {
                break;
            }
        }
    }
}

bool BufferView::move_cursor_screen_row_up(bool allow_eol)
{
    auto cursor_line_walker = get_cursor_line_walker();
    auto iterator_copy = m_iterator->clonep();
    if (cursor_line_walker.row_offset() > 0)
    {
        /* There are screen rows above the current in the current line. */
        iterator_copy->go_start_of_line();
        move_forward_to_screen_position(iterator_copy, cursor_line_walker.row_offset() - 1, allow_eol);
    }
    else
    {
        if (!iterator_copy->go_previous_line())
        {
            return false;
        }
        int target_row_offset = calculate_rows_in_line(iterator_copy) - 1;
        move_forward_to_screen_position(iterator_copy, target_row_offset, allow_eol);
    }
    return true;
}

bool BufferView::move_cursor_screen_row_down(bool allow_eol)
{
    auto cursor_line_walker = get_cursor_line_walker();
    int target_row_offset = cursor_line_walker.row_offset() + 1;
    bool moved = false;
    for (; cursor_line_walker.is_valid(); cursor_line_walker++)
    {
        if (cursor_line_walker.row_offset() == target_row_offset)
        {
            if (((!cursor_line_walker.is_eol()) || allow_eol) &&
                    ((!moved) || (cursor_line_walker.screen_column() <= m_target_screen_column)))
            {
                *m_iterator = *cursor_line_walker.iterator();
                m_cursor_row_offset = cursor_line_walker.row_offset();
                moved = true;
            }
        }
        else if (cursor_line_walker.row_offset() > target_row_offset)
        {
            break;
        }
    }
    if (!moved)
    {
        auto next_line = m_iterator->clonep();
        if (!next_line->go_next_line())
        {
            return false;
        }
        move_forward_to_screen_position(next_line, 0, allow_eol);
    }
    return true;
}

void BufferView::move_forward_to_screen_position(
        std::shared_ptr<Buffer::Iterator> line, int target_row_offset,
        bool allow_eol)
{
    *m_iterator = *line;
    bool moved_to_target_row = false;
    for (auto it = horiz_iter(line); it.is_valid(); it++)
    {
        if (((!it.is_eol()) || allow_eol) &&
                    ((it.row_offset() < target_row_offset) ||
                     (!moved_to_target_row) ||
                     (it.screen_column() <= m_target_screen_column)))
        {
            *m_iterator = *it.iterator();
            m_cursor_row_offset = it.row_offset();
            if (it.row_offset() == target_row_offset)
            {
                moved_to_target_row = true;
            }
        }
        else
        {
            break;
        }
    }
}

int BufferView::calculate_rows_above_screen(int stop_at)
{
    if (m_lines.empty())
        return 0;
    const LineDescriptor & first_line = *m_lines.begin();
    auto iterator = std::make_shared<Buffer::Iterator>(*first_line.line);
    int lines = std::max(0, -first_line.row_offset);
    while (lines < stop_at)
    {
        if (!iterator->go_previous_line())
            break;
        lines += calculate_rows_in_line(iterator);
    }
    return lines;
}

int BufferView::calculate_rows_below_screen(int stop_at)
{
    if (m_lines.empty())
        return 0;
    const LineDescriptor & last_line = *m_lines.rbegin();
    auto iterator = std::make_shared<Buffer::Iterator>(*last_line.line);
    int lines = std::max(0, last_line.row_offset + last_line.n_rows - m_height);
    while (lines < stop_at)
    {
        if (!iterator->go_next_line())
            break;
        lines += calculate_rows_in_line(iterator);
    }
    return lines;
}

int BufferView::n_screen_rows_with_content() const
{
    if (m_lines.size() > 0u)
    {
        auto line_desc = m_lines.rbegin();
        return line_desc->row_offset + line_desc->n_rows;
    }
    return 0;
}

BufferLineWalker BufferView::get_cursor_line_walker()
{
    auto start_of_line = m_iterator->clonep();
    start_of_line->go_start_of_line();
    for (auto it = horiz_iter(start_of_line); it.is_valid(); it++)
    {
        if (*it.iterator() == *m_iterator)
        {
            return it;
        }
    }
    return horiz_iter(start_of_line);
}