/*
 * Copyright 2009, Ingo Weinhold, ingo_weinhold@gmx.de.
 * Distributed under the terms of the MIT License.
 */

#include "table/Table.h"

#include <new>


// #pragma mark - TableField


class TableField : public BField {
public:
        TableField(int32 rowIndex)
                :
                fRowIndex(rowIndex)
        {
        }

        int32 RowIndex() const
        {
                return fRowIndex;
        }

        void SetRowIndex(int32 rowIndex)
        {
                fRowIndex = rowIndex;
        }

private:
        int32   fRowIndex;
};


// #pragma mark - TableModelListener


TableModelListener::~TableModelListener()
{
}


void
TableModelListener::TableRowsAdded(TableModel* model, int32 rowIndex,
        int32 count)
{
}


void
TableModelListener::TableRowsRemoved(TableModel* model, int32 rowIndex,
        int32 count)
{
}


void
TableModelListener::TableRowsChanged(TableModel* model, int32 rowIndex,
        int32 count)
{
}


void
TableModelListener::TableModelReset(TableModel* model)
{
}


// #pragma mark - TableModel


TableModel::~TableModel()
{
}


bool
TableModel::AddListener(TableModelListener* listener)
{
        return fListeners.AddItem(listener);
}


void
TableModel::RemoveListener(TableModelListener* listener)
{
        fListeners.RemoveItem(listener);
}


void
TableModel::NotifyRowsAdded(int32 rowIndex, int32 count)
{
        int32 listenerCount = fListeners.CountItems();
        for (int32 i = listenerCount - 1; i >= 0; i--) {
                TableModelListener* listener = fListeners.ItemAt(i);
                listener->TableRowsAdded(this, rowIndex, count);
        }
}


void
TableModel::NotifyRowsRemoved(int32 rowIndex, int32 count)
{
        int32 listenerCount = fListeners.CountItems();
        for (int32 i = listenerCount - 1; i >= 0; i--) {
                TableModelListener* listener = fListeners.ItemAt(i);
                listener->TableRowsRemoved(this, rowIndex, count);
        }
}


void
TableModel::NotifyRowsChanged(int32 rowIndex, int32 count)
{
        int32 listenerCount = fListeners.CountItems();
        for (int32 i = listenerCount - 1; i >= 0; i--) {
                TableModelListener* listener = fListeners.ItemAt(i);
                listener->TableRowsChanged(this, rowIndex, count);
        }
}


void
TableModel::NotifyTableModelReset()
{
        int32 listenerCount = fListeners.CountItems();
        for (int32 i = listenerCount - 1; i >= 0; i--) {
                TableModelListener* listener = fListeners.ItemAt(i);
                listener->TableModelReset(this);
        }
}


// #pragma mark - TableSelectionModel

TableSelectionModel::TableSelectionModel(Table* table)
        :
        fTable(table),
        fRows(NULL),
        fRowCount(-1)
{
}


TableSelectionModel::~TableSelectionModel()
{
        delete[] fRows;
}


int32
TableSelectionModel::CountRows()
{
        _Update();

        return fRowCount;
}


int32
TableSelectionModel::RowAt(int32 index)
{
        _Update();

        return index >= 0 && index < fRowCount ? fRows[index] : -1;
}


void
TableSelectionModel::_SelectionChanged()
{
        if (fRowCount >= 0) {
                fRowCount = -1;
                delete[] fRows;
                fRows = NULL;
        }
}


void
TableSelectionModel::_Update()
{
        if (fRowCount >= 0)
                return;

        // count the rows
        fRowCount = 0;
        BRow* row = NULL;
        while ((row = fTable->CurrentSelection(row)) != NULL)
                fRowCount++;

        if (fRowCount == 0)
                return;

        // allocate row array
        fRows = new(std::nothrow) int32[fRowCount];
        if (fRows == NULL) {
                fRowCount = 0;
                return;
        }

        // get the rows
        row = NULL;
        int32 index = 0;
        while ((row = fTable->CurrentSelection(row)) != NULL)
                fRows[index++] = fTable->_ModelIndexOfRow(row);
}


// #pragma mark - TableToolTipProvider


TableToolTipProvider::~TableToolTipProvider()
{
}


// #pragma mark - TableListener


TableListener::~TableListener()
{
}


void
TableListener::TableSelectionChanged(Table* table)
{
}


void
TableListener::TableRowInvoked(Table* table, int32 rowIndex)
{
}


void
TableListener::TableCellMouseDown(Table* table, int32 rowIndex,
        int32 columnIndex, BPoint screenWhere, uint32 buttons)
{
}


void
TableListener::TableCellMouseUp(Table* table, int32 rowIndex, int32 columnIndex,
        BPoint screenWhere, uint32 buttons)
{
}


// #pragma mark - Column


class Table::Column : public AbstractColumn {
public:
                                                                Column(TableModel* model,
                                                                        TableColumn* tableColumn);
        virtual                                         ~Column();

        virtual void                            SetModel(AbstractTableModelBase* model);

protected:
        virtual void                            DrawTitle(BRect rect, BView* targetView);
        virtual void                            DrawField(BField* field, BRect rect,
                                                                        BView* targetView);
        virtual int                                     CompareFields(BField* field1, BField* field2);

        virtual void                            GetColumnName(BString* into) const;
        virtual float                           GetPreferredWidth(BField* field,
                                                                        BView* parent) const;

private:
                        TableModel*                     fModel;
};


Table::Column::Column(TableModel* model, TableColumn* tableColumn)
        :
        AbstractColumn(tableColumn),
        fModel(model)
{
}


Table::Column::~Column()
{
}


void
Table::Column::SetModel(AbstractTableModelBase* model)
{
        fModel = dynamic_cast<TableModel*>(model);
}


void
Table::Column::DrawTitle(BRect rect, BView* targetView)
{
        fTableColumn->DrawTitle(rect, targetView);
}


void
Table::Column::DrawField(BField* _field, BRect rect, BView* targetView)
{
        TableField* field = dynamic_cast<TableField*>(_field);
        if (field == NULL)
                return;

        int32 modelIndex = fTableColumn->ModelIndex();
        BVariant value;
        if (!fModel->GetValueAt(field->RowIndex(), modelIndex, value))
                return;
        fTableColumn->DrawValue(value, rect, targetView);
}


int
Table::Column::CompareFields(BField* _field1, BField* _field2)
{
        TableField* field1 = dynamic_cast<TableField*>(_field1);
        TableField* field2 = dynamic_cast<TableField*>(_field2);

        if (field1 == field2)
                return 0;

        if (field1 == NULL)
                return -1;
        if (field2 == NULL)
                return 1;

        int32 modelIndex = fTableColumn->ModelIndex();
        BVariant value1;
        bool valid1 = fModel->GetValueAt(field1->RowIndex(), modelIndex, value1);
        BVariant value2;
        bool valid2 = fModel->GetValueAt(field2->RowIndex(), modelIndex, value2);

        if (!valid1)
                return valid2 ? -1 : 0;
        if (!valid2)
                return 1;

        return fTableColumn->CompareValues(value1, value2);
}


void
Table::Column::GetColumnName(BString* into) const
{
        fTableColumn->GetColumnName(into);
}


float
Table::Column::GetPreferredWidth(BField* _field, BView* parent) const
{
        TableField* field = dynamic_cast<TableField*>(_field);
        if (field == NULL)
                return Width();

        int32 modelIndex = fTableColumn->ModelIndex();
        BVariant value;
        if (!fModel->GetValueAt(field->RowIndex(), modelIndex, value))
                return Width();
        return fTableColumn->GetPreferredWidth(value, parent);
}


// #pragma mark - Table


Table::Table(const char* name, uint32 flags, border_style borderStyle,
        bool showHorizontalScrollbar)
        :
        AbstractTable(name, flags, borderStyle, showHorizontalScrollbar),
        fModel(NULL),
        fToolTipProvider(NULL),
        fSelectionModel(this),
        fIgnoreSelectionChange(0)
{
}


Table::Table(TableModel* model, const char* name, uint32 flags,
        border_style borderStyle, bool showHorizontalScrollbar)
        :
        AbstractTable(name, flags, borderStyle, showHorizontalScrollbar),
        fModel(NULL),
        fToolTipProvider(NULL),
        fSelectionModel(this),
        fIgnoreSelectionChange(0)
{
        SetTableModel(model);
}


Table::~Table()
{
        // rows are deleted by the BColumnListView destructor automatically
}


void
Table::SetTableModel(TableModel* model)
{
        if (model == fModel)
                return;

        if (fModel != NULL) {
                fModel->RemoveListener(this);

                fRows.MakeEmpty();
                Clear();

                for (int32 i = 0; AbstractColumn* column = fColumns.ItemAt(i); i++)
                        column->SetModel(NULL);
        }

        fModel = model;

        if (fModel == NULL)
                return;

        fModel->AddListener(this);

        for (int32 i = 0; AbstractColumn* column = fColumns.ItemAt(i); i++)
                column->SetModel(fModel);

        TableRowsAdded(fModel, 0, fModel->CountRows());
}


void
Table::SetToolTipProvider(TableToolTipProvider* toolTipProvider)
{
        fToolTipProvider = toolTipProvider;
}


TableSelectionModel*
Table::SelectionModel()
{
        return &fSelectionModel;
}


void
Table::SelectRow(int32 rowIndex, bool extendSelection)
{
        BRow* row = fRows.ItemAt(rowIndex);
        if (row == NULL)
                return;

        if (!extendSelection) {
                fIgnoreSelectionChange++;
                DeselectAll();
                fIgnoreSelectionChange--;
        }

        AddToSelection(row);
}


void
Table::DeselectRow(int32 rowIndex)
{
        if (BRow* row = fRows.ItemAt(rowIndex))
                Deselect(row);
}


void
Table::DeselectAllRows()
{
        DeselectAll();
}


bool
Table::AddTableListener(TableListener* listener)
{
        return fListeners.AddItem(listener);
}


void
Table::RemoveTableListener(TableListener* listener)
{
        fListeners.RemoveItem(listener);
}


status_t
Table::GetCellRectAt(int32 rowIndex, int32 colIndex, BRect& _output) const
{
        BRow* row = fRows.ItemAt(rowIndex);
        if (row == NULL)
                return B_ENTRY_NOT_FOUND;

        AbstractColumn* column = fColumns.ItemAt(colIndex);
        if (column == NULL)
                return B_ENTRY_NOT_FOUND;

        _output = GetFieldRect(row, column);

        return B_OK;
}


bool
Table::GetToolTipAt(BPoint point, BToolTip** _tip)
{
        if (fToolTipProvider == NULL)
                return AbstractTable::GetToolTipAt(point, _tip);

        // get the table row
        BRow* row = RowAt(point);
        int32 rowIndex = row != NULL ? _ModelIndexOfRow(row) : -1;
        if (rowIndex < 0)
                return AbstractTable::GetToolTipAt(point, _tip);

        // get the table column
        BColumn* column = ColumnAt(point);
        int32 columnIndex = column != NULL ? column->LogicalFieldNum() : -1;

        return fToolTipProvider->GetToolTipForTableCell(rowIndex, columnIndex,
                _tip);
}


void
Table::SelectionChanged()
{
        if (fIgnoreSelectionChange > 0)
                return;

        fSelectionModel._SelectionChanged();

        if (!fListeners.IsEmpty()) {
                int32 listenerCount = fListeners.CountItems();
                for (int32 i = listenerCount - 1; i >= 0; i--)
                        fListeners.ItemAt(i)->TableSelectionChanged(this);
        }
}


AbstractTable::AbstractColumn*
Table::CreateColumn(TableColumn* column)
{
        return new Column(fModel, column);
}


void
Table::ColumnMouseDown(AbstractColumn* column, BRow* row, BField* field,
        BPoint screenWhere, uint32 buttons)
{
        if (!fListeners.IsEmpty()) {
                // get the table row and column indices
                int32 rowIndex = _ModelIndexOfRow(row);
                int32 columnIndex = column->LogicalFieldNum();
                if (rowIndex < 0 || columnIndex < 0)
                        return;

                // notify listeners
                int32 listenerCount = fListeners.CountItems();
                for (int32 i = listenerCount - 1; i >= 0; i--) {
                        fListeners.ItemAt(i)->TableCellMouseDown(this, rowIndex,
                                columnIndex, screenWhere, buttons);
                }
        }
}


void
Table::ColumnMouseUp(AbstractColumn* column, BRow* row, BField* field,
        BPoint screenWhere, uint32 buttons)
{
        if (!fListeners.IsEmpty()) {
                // get the table row and column indices
                int32 rowIndex = _ModelIndexOfRow(row);
                int32 columnIndex = column->LogicalFieldNum();
                if (rowIndex < 0 || columnIndex < 0)
                        return;

                // notify listeners
                int32 listenerCount = fListeners.CountItems();
                for (int32 i = listenerCount - 1; i >= 0; i--) {
                        fListeners.ItemAt(i)->TableCellMouseUp(this, rowIndex, columnIndex,
                                screenWhere, buttons);
                }
        }
}


void
Table::TableRowsAdded(TableModel* model, int32 rowIndex, int32 count)
{
        // create the rows
        int32 endRow = rowIndex + count;
        int32 columnCount = fModel->CountColumns();

        for (int32 i = rowIndex; i < endRow; i++) {
                // create row
                BRow* row = new(std::nothrow) BRow();
                if (row == NULL) {
                        // TODO: Report error!
                        return;
                }

                // add dummy fields to row
                for (int32 columnIndex = 0; columnIndex < columnCount; columnIndex++) {
                        // It would be nice to create only a single field and set it for all
                        // columns, but the row takes ultimate ownership, so it have to be
                        // individual objects.
                        TableField* field = new(std::nothrow) TableField(i);
                        if (field == NULL) {
                                // TODO: Report error!
                                delete row;
                                return;
                        }

                        row->SetField(field, columnIndex);
                }

                // add row
                if (!fRows.AddItem(row, i)) {
                        // TODO: Report error!
                        delete row;
                        return;
                }

                AddRow(row, i);
        }

        // re-index the subsequent rows
        _UpdateRowIndices(endRow);
}


void
Table::TableRowsRemoved(TableModel* model, int32 rowIndex, int32 count)
{
        if (rowIndex == 0 && count == fRows.CountItems()) {
                fRows.MakeEmpty();
                Clear();
                return;
        }

        for (int32 i = rowIndex + count - 1; i >= rowIndex; i--) {
                if (BRow* row = fRows.RemoveItemAt(i)) {
                        RemoveRow(row);
                        delete row;
                }
        }

        // re-index the subsequent rows
        _UpdateRowIndices(rowIndex);
}


void
Table::TableRowsChanged(TableModel* model, int32 rowIndex, int32 count)
{
        int32 endIndex = rowIndex + count;
        for (int32 i = rowIndex; i < endIndex; i++) {
                if (BRow* row = fRows.ItemAt(i))
                        UpdateRow(row);
        }
}


void
Table::TableModelReset(TableModel* model)
{
        Clear();
        TableRowsAdded(model, 0, model->CountRows());
}


void
Table::ItemInvoked()
{
        if (fListeners.IsEmpty())
                return;

        int32 index = _ModelIndexOfRow(CurrentSelection());
        if (index < 0)
                return;

        int32 listenerCount = fListeners.CountItems();
        for (int32 i = listenerCount - 1; i >= 0; i--)
                fListeners.ItemAt(i)->TableRowInvoked(this, index);
}


void
Table::_UpdateRowIndices(int32 fromIndex)
{
        for (int32 i = fromIndex; BRow* row = fRows.ItemAt(i); i++) {
                for (int32 k = 0;
                        TableField* field = dynamic_cast<TableField*>(row->GetField(k));
                        k++) {
                        field->SetRowIndex(i);
                }
        }
}


int32
Table::_ModelIndexOfRow(BRow* row)
{
        if (row == NULL)
                return -1;

        TableField* field = dynamic_cast<TableField*>(row->GetField(0));
        if (field == NULL)
                return -1;

        return field->RowIndex();
}