/*
 * Copyright 2006-2007, 2023, Haiku.
 * Distributed under the terms of the MIT License.
 *
 * Authors:
 *              Stephan Aßmus <superstippi@gmx.de>
 *              Zardshard
 */
#ifndef CONTAINER_H
#define CONTAINER_H


#include <stdio.h>
#include <string.h>

#include <List.h>
#include <OS.h>
#include <Referenceable.h>

#include "IconBuild.h"

class BReferenceable;


_BEGIN_ICON_NAMESPACE


template<class Type>
class ContainerListener {
 public:
                                                                ContainerListener();
        virtual                                         ~ContainerListener();

        virtual void                            ItemAdded(Type* item, int32 index) = 0;
        virtual void                            ItemRemoved(Type* item) = 0;
};


/*!
        Wraps \c BList and provides some additional features.

        -# It allows listeners to listen when an item is added or removed.
        -# It can take ownership of the objects that it stores.
        -# It casts list items into the correct type.
*/
// TODO: some of these features are provided by BObjectList
template<class Type>
class Container {
 public:
                                                                Container(bool ownsItems);
        virtual                                         ~Container();

                        bool                            AddItem(Type* item);
                        bool                            AddItem(Type* item, int32 index);
                        bool                            RemoveItem(Type* item);
                        Type*                           RemoveItem(int32 index);

                        void                            MakeEmpty();

                        int32                           CountItems() const;
                        bool                            HasItem(Type* item) const;
                        int32                           IndexOf(Type* item) const;

                        Type*                           ItemAt(int32 index) const;
                        Type*                           ItemAtFast(int32 index) const;

                        bool                            AddListener(ContainerListener<Type>* listener);
                        bool                            RemoveListener(ContainerListener<Type>* listener);

 private:
                        void                            _NotifyItemAdded(Type* item, int32 index) const;
                        void                            _NotifyItemRemoved(Type* item) const;

 private:
                        BList                           fItems;
                        bool                            fOwnsItems;

                        BList                           fListeners;
};


template<class Type>
ContainerListener<Type>::ContainerListener() {}


template<class Type>
ContainerListener<Type>::~ContainerListener() {}


template<class Type>
Container<Type>::Container(bool ownsItems)
        : fItems(16),
          fOwnsItems(ownsItems),
          fListeners(2)
{
}


template<class Type>
Container<Type>::~Container()
{
        int32 count = fListeners.CountItems();
        if (count > 0) {
                debugger("~Container() - there are still"
                                 "listeners attached\n");
        }
        MakeEmpty();
}


// #pragma mark -


template<class Type>
bool
Container<Type>::AddItem(Type* item)
{
        return AddItem(item, CountItems());
}


template<class Type>
bool
Container<Type>::AddItem(Type* item, int32 index)
{
        if (!item)
                return false;

        // prevent adding the same item twice
        if (HasItem(item))
                return false;

        if (fItems.AddItem((void*)item, index)) {
                _NotifyItemAdded(item, index);
                return true;
        }

        fprintf(stderr, "Container::AddItem() - out of memory!\n");
        return false;
}


template<class Type>
bool
Container<Type>::RemoveItem(Type* item)
{
        if (fItems.RemoveItem((void*)item)) {
                _NotifyItemRemoved(item);
                return true;
        }

        return false;
}


template<class Type>
Type*
Container<Type>::RemoveItem(int32 index)
{
        Type* item = (Type*)fItems.RemoveItem(index);
        if (item) {
                _NotifyItemRemoved(item);
        }

        return item;
}


template<class Type>
void
Container<Type>::MakeEmpty()
{
        int32 count = CountItems();
        for (int32 i = 0; i < count; i++) {
                Type* item = ItemAtFast(i);
                _NotifyItemRemoved(item);
#ifdef ICON_O_MATIC
                if (fOwnsItems)
                        item->ReleaseReference();
#else
                if (fOwnsItems)
                        delete item;
#endif
        }
        fItems.MakeEmpty();
}


// #pragma mark -


template<class Type>
int32
Container<Type>::CountItems() const
{
        return fItems.CountItems();
}


template<class Type>
bool
Container<Type>::HasItem(Type* item) const
{
        return fItems.HasItem(item);
}


template<class Type>
int32
Container<Type>::IndexOf(Type* item) const
{
        return fItems.IndexOf((void*)item);
}


template<class Type>
Type*
Container<Type>::ItemAt(int32 index) const
{
        return (Type*)fItems.ItemAt(index);
}


template<class Type>
Type*
Container<Type>::ItemAtFast(int32 index) const
{
        return (Type*)fItems.ItemAtFast(index);
}


// #pragma mark -


template<class Type>
bool
Container<Type>::AddListener(ContainerListener<Type>* listener)
{
        if (listener && !fListeners.HasItem(listener))
                return fListeners.AddItem(listener);
        return false;
}


template<class Type>
bool
Container<Type>::RemoveListener(ContainerListener<Type>* listener)
{
        return fListeners.RemoveItem(listener);
}


// #pragma mark -


template<class Type>
void
Container<Type>::_NotifyItemAdded(Type* item, int32 index) const
{
        BList listeners(fListeners);
        int32 count = listeners.CountItems();
        for (int32 i = 0; i < count; i++) {
                ContainerListener<Type>* listener
                        = (ContainerListener<Type>*)listeners.ItemAtFast(i);
                listener->ItemAdded(item, index);
        }
}


template<class Type>
void
Container<Type>::_NotifyItemRemoved(Type* item) const
{
        BList listeners(fListeners);
        int32 count = listeners.CountItems();
        for (int32 i = 0; i < count; i++) {
                ContainerListener<Type>* listener
                        = (ContainerListener<Type>*)listeners.ItemAtFast(i);
                listener->ItemRemoved(item);
        }
}


_END_ICON_NAMESPACE


#endif  // CONTAINER_H