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


#include "ListSelectionModel.h"


// #pragma mark - ListSelectionModel


ListSelectionModel::ListSelectionModel()
{
}


ListSelectionModel::ListSelectionModel(const ListSelectionModel& other)
{
        *this = other;
}


ListSelectionModel::~ListSelectionModel()
{
}


void
ListSelectionModel::Clear()
{
        int32 selectedCount = fSelectedItems.Count();
        if (selectedCount > 0) {
                int32 firstSelected = fSelectedItems[0];
                int32 lastSelected = fSelectedItems[selectedCount - 1];

                fSelectedItems.Clear();

                _NotifyItemsDeselected(firstSelected, lastSelected - firstSelected + 1);
        }
}


bool
ListSelectionModel::SelectItems(int32 itemIndex, int32 count,
        bool extendSelection)
{
        int32 endItemIndex = itemIndex + count;

        int32 index;
        if (extendSelection) {
                if (count <= 0)
                        return true;

                index = _FindItem(itemIndex);

                // count already selected items
                int32 alreadySelectedCount = _CountSelectedItemsInRange(index,
                        endItemIndex);
                if (alreadySelectedCount == count)
                        return true;

                // make room for the new items
                if (!fSelectedItems.InsertUninitialized(index + alreadySelectedCount,
                                count - alreadySelectedCount)) {
                        return false;
                }
        } else {
                // TODO: Don't clear -- just resize to the right size!
                Clear();
                if (count <= 0)
                        return true;

                index = 0;
                if (!fSelectedItems.AddUninitialized(count))
                        return false;
        }

        for (int32 i = 0; i < count; i++)
                fSelectedItems[index + i] = itemIndex + i;

        _NotifyItemsSelected(itemIndex, count);

        return true;
}


void
ListSelectionModel::DeselectItems(int32 itemIndex, int32 count)
{
        int32 endItemIndex = itemIndex + count;
        int32 index = _FindItem(itemIndex);

        // count actually selected items
        int32 actuallySelectedCount = _CountSelectedItemsInRange(index,
                endItemIndex);
        if (actuallySelectedCount == 0)
                return;

        fSelectedItems.Remove(index, actuallySelectedCount);

        _NotifyItemsDeselected(itemIndex, count);
}


void
ListSelectionModel::ItemsAdded(int32 itemIndex, int32 count)
{
        if (count <= 0)
                return;

        // re-index following items
        int32 index = _FindItem(itemIndex);
        int32 selectedCount = fSelectedItems.Count();
        for (int32 i = index; i < selectedCount; i++)
                fSelectedItems[i] += count;
}


void
ListSelectionModel::ItemsRemoved(int32 itemIndex, int32 count)
{
        if (count <= 0)
                return;

        int32 index = _FindItem(itemIndex);

        // count selected items in the range
        int32 actuallySelectedCount = _CountSelectedItemsInRange(index,
                itemIndex + count);
        if (actuallySelectedCount > 0)
                fSelectedItems.Remove(index, actuallySelectedCount);

        // re-index following items
        int32 selectedCount = fSelectedItems.Count();
        for (int32 i = index; i < selectedCount; i++)
                fSelectedItems[i] -= count;
}


bool
ListSelectionModel::AddListener(Listener* listener)
{
        return fListeners.AddItem(listener);
}


void
ListSelectionModel::RemoveListener(Listener* listener)
{
        fListeners.RemoveItem(listener);
}


ListSelectionModel&
ListSelectionModel::operator=(const ListSelectionModel& other)
{
        Clear();

        fSelectedItems = other.fSelectedItems;

        int32 selectedCount = CountSelectedItems();
        if (selectedCount > 0) {
                int32 firstSelected = fSelectedItems[0];
                int32 lastSelected = fSelectedItems[selectedCount - 1];
                _NotifyItemsDeselected(firstSelected, lastSelected - firstSelected + 1);
        }

        return *this;
}


int32
ListSelectionModel::_FindItem(int32 itemIndex) const
{
        // binary search the index of the first item >= itemIndex
        int32 lower = 0;
        int32 upper = fSelectedItems.Count();

        while (lower < upper) {
                int32 mid = (lower + upper) / 2;

                if (fSelectedItems[mid] < itemIndex)
                        lower = mid + 1;
                else
                        upper = mid;
        }

        return lower;
}


int32
ListSelectionModel::_CountSelectedItemsInRange(int32 index,
        int32 endItemIndex) const
{
        int32 count = 0;
        int32 selectedCount = fSelectedItems.Count();
        for (int32 i = index; i < selectedCount; i++) {
                if (SelectedItemAt(i) >= endItemIndex)
                        break;
                count++;
        }

        return count;
}


void
ListSelectionModel::_NotifyItemsSelected(int32 index, int32 count)
{
        int32 listenerCount = fListeners.CountItems();
        for (int32 i = listenerCount - 1; i >= 0; i--)
                fListeners.ItemAt(i)->ItemsSelected(this, index, count);
}


void
ListSelectionModel::_NotifyItemsDeselected(int32 index, int32 count)
{
        int32 listenerCount = fListeners.CountItems();
        for (int32 i = listenerCount - 1; i >= 0; i--)
                fListeners.ItemAt(i)->ItemsDeselected(this, index, count);
}


// #pragma mark - Listener


ListSelectionModel::Listener::~Listener()
{
}


void
ListSelectionModel::Listener::ItemsSelected(ListSelectionModel* model,
        int32 index, int32 count)
{
}


void
ListSelectionModel::Listener::ItemsDeselected(ListSelectionModel* model,
        int32 index, int32 count)
{
}