#include "PieceTable.h"

PieceTable::PieceTable(const uint8_t * file_buffer, unsigned long file_buffer_size)
{
    m_file_buffer = file_buffer;
    m_file_buffer_size = file_buffer_size;
    start_piece = &m_pieces[PIECE_INDEX_START];
    end_piece = &m_pieces[PIECE_INDEX_END];
    start_piece->next = end_piece;
    end_piece->prev = start_piece;
    m_piece_index = 2u;
    tabstop = 4u;
    m_append_buffer_index = 0u;
    m_changes_buffer_index = 0u;
}

void PieceTable::append_initial_line_piece(uint8_t * start, uint32_t length, bool eol)
{
    Piece * piece = add_piece();
    piece->prev = end_piece->prev;
    piece->next = end_piece;
    piece->start = start;
    piece->length = length;
    piece->flags = 0u;
    if (eol)
        piece->flags |= Piece::EOL_FLAG;
    end_piece->prev->next = piece;
    end_piece->prev = piece;
    m_num_lines++;
}

std::shared_ptr<PieceTable::Cursor> PieceTable::add_cursor()
{
    auto cursor = std::make_shared<Cursor>(this);

    m_cursors.push_back(cursor);

    return cursor;
}

PieceTable::Iterator::Iterator(PieceTable * pt)
{
    piece_table = pt;
    piece = pt->start_piece->next;
    offset = 0u;
}

uint8_t PieceTable::Iterator::num_bytes_in_code_point() const
{
    if (offset >= piece->length)
    {
        return 0u;
    }
    else
    {
        return Encoding::num_bytes_in_code_point(piece_table->encoding, &piece->start[offset]);
    }
}

void PieceTable::Iterator::go_next_position()
{
    uint8_t code_point_size = num_bytes_in_code_point();
    if ((offset + code_point_size) >= piece->length)
    {
        go_next_piece();
        return;
    }
    offset += code_point_size;
}

void PieceTable::Iterator::go_prev_position()
{
    if (offset > 0)
    {
        offset = Encoding::beginning_of_code_point(piece_table->encoding, &piece->start[offset - 1u]) - piece->start;
    }
    else if (piece != piece_table->start_piece)
    {
        piece = piece->prev;
        if (piece->length > 0u)
        {
            offset = Encoding::beginning_of_code_point(piece_table->encoding, &piece->start[piece->length - 1u]) - piece->start;
        }
        else
        {
            offset = 0u;
        }
    }
}

void PieceTable::Iterator::go_end_of_piece()
{
    if (piece->length > 0u)
    {
        offset = Encoding::beginning_of_code_point(piece_table->encoding, &piece->start[piece->length - 1u]) - piece->start;
    }
    else
    {
        offset = 0u;
    }
}

void PieceTable::Iterator::go_next_piece()
{
    if (piece != piece_table->end_piece)
    {
        piece = piece->next;
        offset = 0u;
    }
}

void PieceTable::Iterator::go_prev_piece()
{
    if (piece != piece_table->start_piece)
    {
        piece = piece->prev;
        offset = 0u;
    }
}

PieceTable::Cursor::Cursor(PieceTable * pt) : iterator(pt)
{
    line = 0u;
    init_column();
}

bool PieceTable::Cursor::go_start_of_line()
{
    if (!iterator.valid())
        return false;
    bool rv = false;
    while (iterator.valid() &&
            (!iterator.piece->prev->eol()) &&
            (iterator.piece->prev != iterator.piece_table->start_piece))
    {
        iterator.go_prev_piece();
        rv = true;
    }
    if (iterator.offset != 0u)
        rv = true;
    iterator.offset = 0u;
    init_column();
    return rv;
}

bool PieceTable::Cursor::go_end_of_line()
{
    if (!iterator.valid())
        return false;
    bool rv = false;
    while (iterator.valid() &&
            (!iterator.piece->eol()) &&
            (iterator.piece->next != iterator.piece_table->end_piece))
    {
        iterator.go_next_piece();
        rv = true;
    }
    uint32_t current_column = column;
    iterator.go_end_of_piece();
    calculate_column();
    if (column != current_column)
        rv = true;
    return rv;
}

bool PieceTable::Cursor::go_up(int n, uint32_t desired_column)
{
    if (!iterator.valid())
        return false;
    Piece * p = prev_line();
    if (p == nullptr)
    {
        return false;
    }
    iterator.piece = p;
    iterator.offset = 0u;
    line--;
    init_column();
    forward_to_column(desired_column);
    return true;
}

bool PieceTable::Cursor::go_down(int n, uint32_t desired_column)
{
    if (!iterator.valid())
        return false;
    Piece * p = next_line();
    if (p == nullptr)
    {
        return false;
    }
    iterator.piece = p;
    iterator.offset = 0u;
    line++;
    init_column();
    forward_to_column(desired_column);
    return true;
}

bool PieceTable::Cursor::go_left(int n)
{
    if (!iterator.valid())
        return false;
    if (is_start_of_line())
    {
        return false;
    }
    uint32_t chr = *iterator;
    iterator.go_prev_position();
    if (chr == '\t')
    {
        calculate_column();
    }
    else
    {
        /* TODO: handle multi-column characters */
        column--;
    }
    return true;
}

bool PieceTable::Cursor::go_right(int n)
{
    if (!iterator.valid())
        return false;
    if (is_end_of_line())
    {
        return false;
    }
    iterator.go_next_position();
    uint32_t chr = *iterator;
    if (chr == '\t')
    {
        uint8_t tabstop = iterator.piece_table->tabstop;
        column += tabstop - (column + 1u) % tabstop;
    }
    else
    {
        /* TODO: handle multi-column characters */
        column++;
    }
    return true;
}

void PieceTable::Cursor::warp_to_inserted_piece(Piece * piece)
{
    iterator.piece = piece;
    iterator.offset = 0u;
    iterator.go_end_of_piece();
    calculate_column();
}

bool PieceTable::Cursor::is_start_of_line()
{
    return iterator.valid() &&
        (iterator.offset == 0u) &&
        ((iterator.piece->prev == iterator.piece_table->start_piece) ||
         iterator.piece->prev->eol());
}

bool PieceTable::Cursor::is_end_of_line()
{
    return iterator.valid() &&
         ((iterator.offset + iterator.num_bytes_in_code_point()) >= iterator.piece->length) &&
         (iterator.piece->eol() || (iterator.piece->next == iterator.piece_table->end_piece));
}

PieceTable::Piece * PieceTable::Cursor::prev_line() const
{
    Piece * p = iterator.piece;
    while ((!p->prev->eol()) && (p->prev != iterator.piece_table->start_piece))
    {
        p = p->prev;
    }
    if (p->prev == iterator.piece_table->start_piece)
    {
        return nullptr;
    }
    p = p->prev;
    while ((!p->prev->eol()) && (p->prev != iterator.piece_table->start_piece))
    {
        p = p->prev;
    }
    return p;
}

PieceTable::Piece * PieceTable::Cursor::next_line() const
{
    Piece * p = iterator.piece;
    while ((!p->eol()) && (p->next != iterator.piece_table->end_piece))
    {
        p = p->next;
    }
    if (p->next == iterator.piece_table->end_piece)
    {
        return nullptr;
    }
    return p->next;
}

void PieceTable::Cursor::init_column()
{
    uint32_t chr = *iterator;
    /* TODO: handle multi-column characters */
    column = (chr == '\t') ? iterator.piece_table->tabstop - 1u : 0u;
}

void PieceTable::Cursor::calculate_column()
{
    Cursor tmp_cursor = *this;
    tmp_cursor.go_start_of_line();
    while ((tmp_cursor.iterator.piece != iterator.piece) ||
            (tmp_cursor.iterator.offset < iterator.offset))
    {
        tmp_cursor.go_right(1);
    }
    column = tmp_cursor.column;
}

void PieceTable::Cursor::forward_to_column(uint32_t c)
{
    int32_t diff = abs((int32_t)(c - column));
    if (diff == 0)
        return;
    while (go_right(1))
    {
        int32_t new_diff = abs((int32_t)(c - column));
        if (new_diff > diff)
        {
            go_left(1);
            return;
        }
        diff = new_diff;
    }
}

void PieceTable::insertion_test(Cursor & c)
{
    Piece * piece = add_piece();
    piece->start = &m_append_buffer[m_append_buffer_index];
    piece->length = 3u;
    piece->flags = 0u;
    m_append_buffer[m_append_buffer_index++] = 'x';
    m_append_buffer[m_append_buffer_index++] = 'y';
    m_append_buffer[m_append_buffer_index++] = 'z';

    Change * change = &m_changes_buffer[m_changes_buffer_index++];
    change->prior_link[0][0] = c.iterator.piece->prev;
    change->prior_link[0][1] = c.iterator.piece;
    change->prior_link[1][0] = c.iterator.piece;
    change->prior_link[1][1] = c.iterator.piece->next;

    if (c.iterator.valid())
    {
        if (c.iterator.offset > 0u)
        {
            Piece * piece2 = add_piece();
            piece2->start = c.iterator.piece->start;
            piece2->length = c.iterator.offset;
            piece2->flags = 0u;

            Piece * piece3 = add_piece();
            piece3->start = c.iterator.piece->start + c.iterator.offset;
            piece3->length = c.iterator.piece->length - c.iterator.offset;
            piece3->flags = c.iterator.piece->flags;

            piece2->next = piece;
            piece->prev = piece2;
            piece->next = piece3;
            piece3->prev = piece;

            change->new_link[0][0] = c.iterator.piece->prev;
            change->new_link[0][1] = piece2;
            change->new_link[1][0] = piece3;
            change->new_link[1][1] = c.iterator.piece->next;
        }
        else
        {
            if (c.iterator.piece->length == 0u)
            {
                piece->flags = c.iterator.piece->flags;
                change->new_link[0][0] = c.iterator.piece->prev;
                change->new_link[0][1] = piece;
                change->new_link[1][0] = piece;
                change->new_link[1][1] = c.iterator.piece->next;
            }
            else
            {
                change->new_link[0][0] = c.iterator.piece->prev;
                change->new_link[0][1] = piece;
                change->new_link[1][0] = piece;
                change->new_link[1][1] = c.iterator.piece;
            }
        }
    }
    else
    {
        change->new_link[0][0] = start_piece;
        change->new_link[0][1] = piece;
        change->new_link[1][0] = piece;
        change->new_link[1][1] = end_piece;
    }

    change->new_link[0][0]->next = change->new_link[0][1];
    change->new_link[0][1]->prev = change->new_link[0][0];
    change->new_link[1][0]->next = change->new_link[1][1];
    change->new_link[1][1]->prev = change->new_link[1][0];

    c.warp_to_inserted_piece(piece);
}