/*
 * Copyright 2024, Haiku, Inc. All rights reserved.
 * Distributed under the terms of the MIT License.
 */

#include <TimedEventQueue.h>

#include <Autolock.h>
#include <Buffer.h>
#include <MediaDebug.h>
#include <InterfaceDefs.h>
#include <util/DoublyLinkedList.h>
#include <locks.h>


//      #pragma mark - media_timed_event


media_timed_event::media_timed_event()
{
        CALLED();
        memset(this, 0, sizeof(*this));
}


media_timed_event::media_timed_event(bigtime_t inTime, int32 inType)
{
        CALLED();
        memset(this, 0, sizeof(*this));

        event_time = inTime;
        type = inType;
}


media_timed_event::media_timed_event(bigtime_t inTime, int32 inType,
        void* inPointer, uint32 inCleanup)
{
        CALLED();
        memset(this, 0, sizeof(*this));

        event_time = inTime;
        type = inType;
        pointer = inPointer;
        cleanup = inCleanup;
}


media_timed_event::media_timed_event(bigtime_t inTime, int32 inType,
        void* inPointer, uint32 inCleanup,
        int32 inData, int64 inBigdata,
        const char* inUserData,  size_t dataSize)
{
        CALLED();
        memset(this, 0, sizeof(*this));

        event_time = inTime;
        type = inType;
        pointer = inPointer;
        cleanup = inCleanup;
        data = inData;
        bigdata = inBigdata;
        memcpy(user_data, inUserData,
                min_c(sizeof(media_timed_event::user_data), dataSize));
}


media_timed_event::media_timed_event(const media_timed_event& clone)
{
        CALLED();
        *this = clone;
}


void
media_timed_event::operator=(const media_timed_event& clone)
{
        CALLED();
        memcpy(this, &clone, sizeof(*this));
}


media_timed_event::~media_timed_event()
{
        CALLED();
}


//      #pragma mark - media_timed_event global operators


bool
operator==(const media_timed_event& a, const media_timed_event& b)
{
        CALLED();
        return (memcmp(&a, &b, sizeof(media_timed_event)) == 0);
}


bool
operator!=(const media_timed_event& a, const media_timed_event& b)
{
        CALLED();
        return (memcmp(&a, &b, sizeof(media_timed_event)) != 0);
}


bool
operator<(const media_timed_event& a, const media_timed_event& b)
{
        CALLED();
        return a.event_time < b.event_time;
}


bool
operator>(const media_timed_event& a, const media_timed_event& b)
{
        CALLED();
        return a.event_time > b.event_time;
}


//      #pragma mark - BTimedEventQueue


namespace {

struct queue_entry : public DoublyLinkedListLinkImpl<queue_entry> {
        media_timed_event       event;
};
typedef DoublyLinkedList<queue_entry> QueueEntryList;

} // namespace


class BPrivate::TimedEventQueueData {
public:
        TimedEventQueueData()
                :
                fLock("BTimedEventQueue")
        {
                mutex_init(&fEntryAllocationLock, "BTimedEventQueue entry allocation");

                fEventCount = 0;
                fCleanupHook = NULL;
                fCleanupHookContext = NULL;

                for (size_t i = 0; i < B_COUNT_OF(fInlineEntries); i++)
                        fFreeEntries.Add(&fInlineEntries[i]);
        }
        ~TimedEventQueueData()
        {
                while (queue_entry* chunk = fChunkHeads.RemoveHead())
                        free(chunk);
        }

        queue_entry* AllocateEntry()
        {
                MutexLocker locker(fEntryAllocationLock);
                if (fFreeEntries.Head() != NULL)
                        return fFreeEntries.RemoveHead();

                // We need a new chunk.
                const size_t chunkSize = B_PAGE_SIZE;
                queue_entry* newEntries = (queue_entry*)malloc(chunkSize);
                fChunkHeads.Add(&newEntries[0]);
                for (size_t i = 1; i < (chunkSize / sizeof(queue_entry)); i++)
                        fFreeEntries.Add(&newEntries[i]);

                return fFreeEntries.RemoveHead();
        }

        void FreeEntry(queue_entry* entry)
        {
                MutexLocker locker(fEntryAllocationLock);
                fFreeEntries.Add(entry);

                // TODO: Chunks are currently only freed in the destructor.
                // (Is that a problem? They're probably rarely used, anyway.)
        }

        status_t        AddEntry(queue_entry* newEntry);
        void            RemoveEntry(queue_entry* newEntry);
        void            CleanupAndFree(queue_entry* entry);

public:
        BLocker                         fLock;
        QueueEntryList          fEvents;
        int32                           fEventCount;

        BTimedEventQueue::cleanup_hook  fCleanupHook;
        void*                           fCleanupHookContext;

private:
        mutex                           fEntryAllocationLock;
        QueueEntryList          fFreeEntries;
        QueueEntryList          fChunkHeads;
        queue_entry                     fInlineEntries[8];
};

using BPrivate::TimedEventQueueData;


BTimedEventQueue::BTimedEventQueue()
        : fData(new TimedEventQueueData)
{
        CALLED();
}


BTimedEventQueue::~BTimedEventQueue()
{
        CALLED();

        FlushEvents(0, B_ALWAYS);
        delete fData;
}


status_t
BTimedEventQueue::AddEvent(const media_timed_event& event)
{
        CALLED();

        if (event.type < B_START)
                return B_BAD_VALUE;

        queue_entry* newEntry = fData->AllocateEntry();
        if (newEntry == NULL)
                return B_NO_MEMORY;

        newEntry->event = event;

        BAutolock locker(fData->fLock);
        return fData->AddEntry(newEntry);
}


status_t
BTimedEventQueue::RemoveEvent(const media_timed_event* event)
{
        CALLED();
        BAutolock locker(fData->fLock);

        QueueEntryList::Iterator it = fData->fEvents.GetIterator();
        while (queue_entry* entry = it.Next()) {
                if (entry->event != *event)
                        continue;

                fData->RemoveEntry(entry);

                locker.Unlock();

                // No cleanup.
                fData->FreeEntry(entry);
                return B_OK;
        }

        return B_ERROR;
}


status_t
BTimedEventQueue::RemoveFirstEvent(media_timed_event* _event)
{
        CALLED();
        BAutolock locker(fData->fLock);

        if (fData->fEventCount == 0)
                return B_ERROR;

        queue_entry* entry = fData->fEvents.Head();
        fData->RemoveEntry(entry);

        locker.Unlock();

        if (_event != NULL) {
                // No cleanup.
                *_event = entry->event;
                fData->FreeEntry(entry);
        } else {
                fData->CleanupAndFree(entry);
        }
        return B_OK;
}


status_t
TimedEventQueueData::AddEntry(queue_entry* newEntry)
{
        ASSERT(fLock.IsLocked());

        if (fEvents.IsEmpty()) {
                fEvents.Add(newEntry);
                fEventCount++;
                return B_OK;
        }
        if (fEvents.First()->event.event_time > newEntry->event.event_time) {
                fEvents.Add(newEntry, false);
                fEventCount++;
                return B_OK;
        }

        QueueEntryList::ReverseIterator it = fEvents.GetReverseIterator();
        while (queue_entry* entry = it.Next()) {
                if (newEntry->event.event_time < entry->event.event_time)
                        continue;

                // Insert the new event after this entry.
                fEvents.InsertAfter(entry, newEntry);
                fEventCount++;
                return B_OK;
        }

        debugger("BTimedEventQueue::AddEvent: Invalid queue!");
        return B_ERROR;
}


void
TimedEventQueueData::RemoveEntry(queue_entry* entry)
{
        ASSERT(fLock.IsLocked());

        fEvents.Remove(entry);
        fEventCount--;
}


void
TimedEventQueueData::CleanupAndFree(queue_entry* entry)
{
        uint32 cleanup = entry->event.cleanup;
        if (cleanup == B_DELETE) {
                // B_DELETE is a keyboard code, but the Be Book indicates it's a valid
                // cleanup value. (Early sample code may have used it too.)
                cleanup = BTimedEventQueue::B_USER_CLEANUP;
        }

        if (cleanup == BTimedEventQueue::B_NO_CLEANUP) {
                // Nothing to do.
        } else if (entry->event.type == BTimedEventQueue::B_HANDLE_BUFFER
                        && cleanup == BTimedEventQueue::B_RECYCLE_BUFFER) {
                (reinterpret_cast<BBuffer*>(entry->event.pointer))->Recycle();
        } else if (cleanup == BTimedEventQueue::B_EXPIRE_TIMER) {
                // TimerExpired() is invoked in BMediaEventLooper::DispatchEvent; nothing to do.
        } else if (cleanup >= BTimedEventQueue::B_USER_CLEANUP) {
                if (fCleanupHook != NULL)
                        (*fCleanupHook)(&entry->event, fCleanupHookContext);
        } else {
                ERROR("BTimedEventQueue: Unhandled cleanup! (type %" B_PRId32 ", "
                        "cleanup %" B_PRId32 ")\n", entry->event.type, entry->event.cleanup);
        }

        FreeEntry(entry);
}


void
BTimedEventQueue::SetCleanupHook(cleanup_hook hook, void* context)
{
        CALLED();

        BAutolock lock(fData->fLock);
        fData->fCleanupHook = hook;
        fData->fCleanupHookContext = context;
}


bool
BTimedEventQueue::HasEvents() const
{
        CALLED();

        BAutolock locker(fData->fLock);
        return fData->fEventCount != 0;
}


int32
BTimedEventQueue::EventCount() const
{
        CALLED();

        BAutolock locker(fData->fLock);
        return fData->fEventCount;
}


const media_timed_event*
BTimedEventQueue::FirstEvent() const
{
        CALLED();
        BAutolock locker(fData->fLock);

        queue_entry* entry = fData->fEvents.First();
        if (entry == NULL)
                return NULL;
        return &entry->event;
}


bigtime_t
BTimedEventQueue::FirstEventTime() const
{
        CALLED();
        BAutolock locker(fData->fLock);

        queue_entry* entry = fData->fEvents.First();
        if (entry == NULL)
                return B_INFINITE_TIMEOUT;
        return entry->event.event_time;
}


const media_timed_event*
BTimedEventQueue::LastEvent() const
{
        CALLED();
        BAutolock locker(fData->fLock);

        queue_entry* entry = fData->fEvents.Last();
        if (entry == NULL)
                return NULL;
        return &entry->event;
}


bigtime_t
BTimedEventQueue::LastEventTime() const
{
        CALLED();
        BAutolock locker(fData->fLock);

        queue_entry* entry = fData->fEvents.Last();
        if (entry == NULL)
                return B_INFINITE_TIMEOUT;
        return entry->event.event_time;
}


const media_timed_event*
BTimedEventQueue::FindFirstMatch(bigtime_t eventTime,
        time_direction direction, bool inclusive, int32 eventType)
{
        CALLED();
        BAutolock locker(fData->fLock);

        QueueEntryList::Iterator it = fData->fEvents.GetIterator();
        while (queue_entry* entry = it.Next()) {
                int match = _Match(entry->event, eventTime, direction, inclusive, eventType);
                if (match == B_DONE)
                        break;
                if (match == B_NO_ACTION)
                        continue;

                return &entry->event;
        }

        return NULL;
}


status_t
BTimedEventQueue::DoForEach(for_each_hook hook, void* context,
        bigtime_t eventTime, time_direction direction,
        bool inclusive, int32 eventType)
{
        CALLED();
        BAutolock locker(fData->fLock);

        bool resort = false;

        QueueEntryList::Iterator it = fData->fEvents.GetIterator();
        while (queue_entry* entry = it.Next()) {
                int match = _Match(entry->event, eventTime, direction, inclusive, eventType);
                if (match == B_DONE)
                        break;
                if (match == B_NO_ACTION)
                        continue;

                queue_action action = hook(&entry->event, context);
                if (action == B_DONE)
                        break;

                switch (action) {
                        case B_REMOVE_EVENT:
                                fData->RemoveEntry(entry);
                                fData->CleanupAndFree(entry);
                                break;

                        case B_RESORT_QUEUE:
                                resort = true;
                                break;

                        case B_NO_ACTION:
                        default:
                                break;
                }
        }

        if (resort) {
                QueueEntryList entries;
                entries.TakeFrom(&fData->fEvents);
                fData->fEventCount = 0;

                while (queue_entry* entry = entries.RemoveHead())
                        fData->AddEntry(entry);
        }

        return B_OK;
}


status_t
BTimedEventQueue::FlushEvents(bigtime_t eventTime, time_direction direction,
        bool inclusive, int32 eventType)
{
        CALLED();
        BAutolock locker(fData->fLock);

        QueueEntryList::Iterator it = fData->fEvents.GetIterator();
        while (queue_entry* entry = it.Next()) {
                int match = _Match(entry->event, eventTime, direction, inclusive, eventType);
                if (match == B_DONE)
                        break;
                if (match == B_NO_ACTION)
                        continue;

                fData->RemoveEntry(entry);
                fData->CleanupAndFree(entry);
        }

        return B_OK;
}


int
BTimedEventQueue::_Match(const media_timed_event& event,
        bigtime_t eventTime, time_direction direction,
        bool inclusive, int32 eventType)
{
        if (direction == B_ALWAYS) {
                // Nothing to check.
        } else if (direction == B_BEFORE_TIME) {
                if (event.event_time > eventTime)
                        return B_DONE;
                if (event.event_time == eventTime && !inclusive)
                        return B_DONE;
        } else if (direction == B_AT_TIME) {
                if (event.event_time > eventTime)
                        return B_DONE;
                if (event.event_time != eventTime)
                        return B_NO_ACTION;
        } else if (direction == B_AFTER_TIME) {
                if (event.event_time < eventTime)
                        return B_NO_ACTION;
                if (event.event_time == eventTime && !inclusive)
                        return B_NO_ACTION;
        }

        if (eventType != B_ANY_EVENT && eventType != event.type)
                return B_NO_ACTION;

        return 1;
}


//      #pragma mark - C++ binary compatibility


void*
BTimedEventQueue::operator new(size_t size)
{
        CALLED();
        return ::operator new(size);
}


void
BTimedEventQueue::operator delete(void* ptr, size_t s)
{
        CALLED();
        return ::operator delete(ptr);
}


void BTimedEventQueue::_ReservedTimedEventQueue0() {}
void BTimedEventQueue::_ReservedTimedEventQueue1() {}
void BTimedEventQueue::_ReservedTimedEventQueue2() {}
void BTimedEventQueue::_ReservedTimedEventQueue3() {}
void BTimedEventQueue::_ReservedTimedEventQueue4() {}
void BTimedEventQueue::_ReservedTimedEventQueue5() {}
void BTimedEventQueue::_ReservedTimedEventQueue6() {}
void BTimedEventQueue::_ReservedTimedEventQueue7() {}
void BTimedEventQueue::_ReservedTimedEventQueue8() {}
void BTimedEventQueue::_ReservedTimedEventQueue9() {}
void BTimedEventQueue::_ReservedTimedEventQueue10() {}
void BTimedEventQueue::_ReservedTimedEventQueue11() {}
void BTimedEventQueue::_ReservedTimedEventQueue12() {}
void BTimedEventQueue::_ReservedTimedEventQueue13() {}
void BTimedEventQueue::_ReservedTimedEventQueue14() {}
void BTimedEventQueue::_ReservedTimedEventQueue15() {}
void BTimedEventQueue::_ReservedTimedEventQueue16() {}
void BTimedEventQueue::_ReservedTimedEventQueue17() {}
void BTimedEventQueue::_ReservedTimedEventQueue18() {}
void BTimedEventQueue::_ReservedTimedEventQueue19() {}
void BTimedEventQueue::_ReservedTimedEventQueue20() {}
void BTimedEventQueue::_ReservedTimedEventQueue21() {}
void BTimedEventQueue::_ReservedTimedEventQueue22() {}
void BTimedEventQueue::_ReservedTimedEventQueue23() {}