// AbstractConnection.cpp

#include "AbstractConnection.h"

#include <AutoLocker.h>

#include "Channel.h"
#include "DebugSupport.h"

// constructor
AbstractConnection::AbstractConnection()
        : Connection(),
          fInitStatus(B_NO_INIT),
          fDownStreamChannels(),
          fUpStreamChannelSemaphore(-1),
          fUpStreamChannelLock(),
          fUpStreamChannels(),
          fFreeUpStreamChannels(0)
{
}

// destructor
AbstractConnection::~AbstractConnection()
{
        // Danger: If derived classes implement Close(), this call will not reach
        // them. So, the caller should rather call Close() explicitely before
        // destroying the connection.
        Close();
        // delete all channels
        for (ChannelVector::Iterator it = fDownStreamChannels.Begin();
                 it != fDownStreamChannels.End();
                 it++) {
                delete *it;
        }
        fDownStreamChannels.MakeEmpty();
        AutoLocker<Locker> _(fUpStreamChannelLock);
        for (ChannelVector::Iterator it = fUpStreamChannels.Begin();
                 it != fUpStreamChannels.End();
                 it++) {
                delete *it;
        }
        fUpStreamChannels.MakeEmpty();
}

// Init
status_t
AbstractConnection::Init()
{
        fInitStatus = B_OK;
        // create upstream channel semaphore
        fUpStreamChannelSemaphore = create_sem(0, "upstream channels");
        if (fUpStreamChannelSemaphore < 0)
                return (fInitStatus = fUpStreamChannelSemaphore);
        return fInitStatus;
}

// Close
void
AbstractConnection::Close()
{
        // close all channels
        for (ChannelVector::Iterator it = fDownStreamChannels.Begin();
                 it != fDownStreamChannels.End();
                 it++) {
                (*it)->Close();
        }
        AutoLocker<Locker> _(fUpStreamChannelLock);
        for (ChannelVector::Iterator it = fUpStreamChannels.Begin();
                 it != fUpStreamChannels.End();
                 it++) {
                (*it)->Close();
        }
}

//// GetAuthorizedUser
//User*
//AbstractConnection::GetAuthorizedUser()
//{
//      return NULL;
//}

// AddDownStreamChannel
status_t
AbstractConnection::AddDownStreamChannel(Channel* channel)
{
        if (!channel)
                return B_BAD_VALUE;
        return fDownStreamChannels.PushBack(channel);
}

// AddUpStreamChannel
status_t
AbstractConnection::AddUpStreamChannel(Channel* channel)
{
        if (!channel)
                return B_BAD_VALUE;
        AutoLocker<Locker> _(fUpStreamChannelLock);
        status_t error = fUpStreamChannels.PushBack(channel);
        if (error != B_OK)
                return error;
        PutUpStreamChannel(channel);
        return B_OK;
}

// CountDownStreamChannels
int32
AbstractConnection::CountDownStreamChannels() const
{
        return fDownStreamChannels.Count();
}

// GetDownStreamChannel
Channel*
AbstractConnection::DownStreamChannelAt(int32 index) const
{
        if (index < 0 || index >= fDownStreamChannels.Count())
                return NULL;
        return fDownStreamChannels.ElementAt(index);
}

// GetUpStreamChannel
status_t
AbstractConnection::GetUpStreamChannel(Channel** channel, bigtime_t timeout)
{
        if (!channel)
                return B_BAD_VALUE;
        if (timeout < 0)
                timeout = 0;
        // acquire the semaphore
        status_t error = acquire_sem_etc(fUpStreamChannelSemaphore, 1,
                B_RELATIVE_TIMEOUT, timeout);
        if (error != B_OK)
                return error;
        // we've acquire the semaphore successfully, so a free channel must be
        // waiting for us
        AutoLocker<Locker> _(fUpStreamChannelLock);
        if (fFreeUpStreamChannels < 1) {
                ERROR(("AbstractConnection::GetUpStreamChannel(): Acquired the "
                        "upstream semaphore successfully, but there's no free channel!\n"));
                return B_ERROR;
        }
        fFreeUpStreamChannels--;
        *channel = fUpStreamChannels.ElementAt(fFreeUpStreamChannels);
        return B_OK;
}

// PutUpStreamChannel
status_t
AbstractConnection::PutUpStreamChannel(Channel* channel)
{
        if (!channel)
                return B_BAD_VALUE;
        // find the channel
        AutoLocker<Locker> _(fUpStreamChannelLock);
        int32 index = fUpStreamChannels.IndexOf(channel, fFreeUpStreamChannels);
        if (index < 0)
                return B_BAD_VALUE;
        // swap it with the first non-free channel, release the semaphore,
        // and bump the free channel count
        if (index != fFreeUpStreamChannels) {
                Channel*& target = fUpStreamChannels.ElementAt(fFreeUpStreamChannels);
                fUpStreamChannels.ElementAt(index) = target;
                target = channel;
        }
        status_t error = release_sem(fUpStreamChannelSemaphore);
        if (error == B_OK)
                fFreeUpStreamChannels++;
        return error;
}