/*
 * Copyright 2001-2015 Haiku, Inc. All rights reserved.
 * Distributed under the terms of the MIT License.
 *
 * Authors:
 *              Ingo Weinhold (bonefish@users.sf.net)
 */


#include <Messenger.h>

#include <new>
#include <stdio.h>
#include <strings.h>

#include <Application.h>
#include <AutoLocker.h>
#include <Handler.h>
#include <Looper.h>
#include <Message.h>
#include <OS.h>
#include <Roster.h>

#include <AppMisc.h>
#include <LaunchRoster.h>
#include <LooperList.h>
#include <MessagePrivate.h>
#include <MessageUtils.h>
#include <TokenSpace.h>


// debugging
//#define DBG(x) x
#define DBG(x)
#define OUT     printf

using BPrivate::gDefaultTokens;
using BPrivate::gLooperList;
using BPrivate::BLooperList;


BMessenger::BMessenger()
        :
        fPort(-1),
        fHandlerToken(B_NULL_TOKEN),
        fTeam(-1)
{
}


BMessenger::BMessenger(const char* signature, team_id team, status_t* result)
        :
        fPort(-1),
        fHandlerToken(B_NULL_TOKEN),
        fTeam(-1)
{
        _InitData(signature, team, result);
}


BMessenger::BMessenger(const BHandler* handler, const BLooper* looper,
        status_t* _result)
        :
        fPort(-1),
        fHandlerToken(B_NULL_TOKEN),
        fTeam(-1)
{
        _InitData(handler, looper, _result);
}


BMessenger::BMessenger(const BMessenger& other)
        :
        fPort(other.fPort),
        fHandlerToken(other.fHandlerToken),
        fTeam(other.fTeam)
{
}


BMessenger::~BMessenger()
{
}


//      #pragma mark - Target


bool
BMessenger::IsTargetLocal() const
{
        return BPrivate::current_team() == fTeam;
}


BHandler*
BMessenger::Target(BLooper** _looper) const
{
        BHandler* handler = NULL;
        if (IsTargetLocal()
                && (fHandlerToken > B_NULL_TOKEN
                        || fHandlerToken == B_PREFERRED_TOKEN)) {
                gDefaultTokens.GetToken(fHandlerToken, B_HANDLER_TOKEN,
                        (void**)&handler);
                if (_looper)
                        *_looper = BPrivate::gLooperList.LooperForPort(fPort);
        } else if (_looper)
                *_looper = NULL;

        return handler;
}


bool
BMessenger::LockTarget() const
{
        BLooper* looper = NULL;
        Target(&looper);
        if (looper != NULL && looper->Lock()) {
                if (looper->fMsgPort == fPort)
                        return true;

                looper->Unlock();
                return false;
        }

        return false;
}


status_t
BMessenger::LockTargetWithTimeout(bigtime_t timeout) const
{
        BLooper* looper = NULL;
        Target(&looper);
        if (looper == NULL)
                return B_BAD_VALUE;

        status_t result = looper->LockWithTimeout(timeout);

        if (result == B_OK && looper->fMsgPort != fPort) {
                looper->Unlock();
                return B_BAD_PORT_ID;
        }

        return result;
}


//      #pragma mark - Message sending


status_t
BMessenger::SendMessage(uint32 command, BHandler* replyTo) const
{
        BMessage message(command);
        return SendMessage(&message, replyTo);
}


status_t
BMessenger::SendMessage(BMessage* message, BHandler* replyTo,
        bigtime_t timeout) const
{
        DBG(OUT("BMessenger::SendMessage2(%.4s)\n", (char*)&message->what));

        status_t result = message != NULL ? B_OK : B_BAD_VALUE;
        if (result == B_OK) {
                BMessenger replyMessenger(replyTo);
                result = SendMessage(message, replyMessenger, timeout);
        }

        DBG(OUT("BMessenger::SendMessage2() done: %lx\n", result));

        return result;
}


status_t
BMessenger::SendMessage(BMessage* message, BMessenger replyTo,
        bigtime_t timeout) const
{
        if (message == NULL)
                return B_BAD_VALUE;

        return BMessage::Private(message).SendMessage(fPort, fTeam, fHandlerToken,
                timeout, false, replyTo);
}


status_t
BMessenger::SendMessage(uint32 command, BMessage* reply) const
{
        BMessage message(command);

        return SendMessage(&message, reply);
}


status_t
BMessenger::SendMessage(BMessage* message, BMessage* reply,
        bigtime_t deliveryTimeout, bigtime_t replyTimeout) const
{
        if (message == NULL || reply == NULL)
                return B_BAD_VALUE;

        status_t result = BMessage::Private(message).SendMessage(fPort, fTeam,
                fHandlerToken, reply, deliveryTimeout, replyTimeout);

        // map this result for now
        if (result == B_BAD_TEAM_ID)
                result = B_BAD_PORT_ID;

        return result;
}


//      #pragma mark - Operators and misc


status_t
BMessenger::SetTo(const char* signature, team_id team)
{
        status_t result = B_OK;
        _InitData(signature, team, &result);

        return result;
}


status_t
BMessenger::SetTo(const BHandler* handler, const BLooper* looper)
{
        status_t result = B_OK;
        _InitData(handler, looper, &result);

        return result;
}


BMessenger&
BMessenger::operator=(const BMessenger& other)
{
        if (this != &other) {
                fPort = other.fPort;
                fHandlerToken = other.fHandlerToken;
                fTeam = other.fTeam;
        }

        return *this;
}


bool
BMessenger::operator==(const BMessenger& other) const
{
        // Note: The fTeam fields are not compared.
        return fPort == other.fPort && fHandlerToken == other.fHandlerToken;
}


bool
BMessenger::IsValid() const
{
        port_info info;
        return fPort >= 0 && get_port_info(fPort, &info) == B_OK;
}


team_id
BMessenger::Team() const
{
        return fTeam;
}


uint32
BMessenger::HashValue() const
{
        return fPort * 19 + fHandlerToken;
}


//      #pragma mark - Private or reserved


/*!     Sets the messenger's team, target looper port and handler token.

        To target the preferred handler, use \c B_PREFERRED_TOKEN as token.

        \param team The target's team.
        \param port The target looper port.
        \param token The target handler token.
*/
void
BMessenger::_SetTo(team_id team, port_id port, int32 token)
{
        fTeam = team;
        fPort = port;
        fHandlerToken = token;
}


/*!     Initializes the BMessenger object's data given the signature and/or
        team ID of a target.

        When only a signature is given, and multiple instances of the application
        are running it is undeterminate which one is chosen as the target. In case
        only a team ID is passed, the target application is identified uniquely.
        If both are supplied, the application identified by the team ID must have
        a matching signature, otherwise the initilization fails.

        \param signature The target application's signature. May be \c NULL.
        \param team The target application's team ID. May be < 0.
        \param result An optional pointer to a pre-allocated status_t into which
                   the result of the initialization is written.
*/
void
BMessenger::_InitData(const char* signature, team_id team, status_t* _result)
{
        status_t result = B_OK;

        // get an app_info
        app_info info;
        if (team < 0) {
                // no team ID given
                if (signature != NULL) {
                        // Try existing launch communication data first
                        BMessage data;
                        if (BLaunchRoster().GetData(signature, data) == B_OK) {
                                info.port = data.GetInt32("port", -1);
                                team = data.GetInt32("team", -5);
                        }
                        if (info.port < 0) {
                                result = be_roster->GetAppInfo(signature, &info);
                                team = info.team;
                                // B_ERROR means that no application with the given signature
                                // is running. But we are supposed to return B_BAD_VALUE.
                                if (result == B_ERROR)
                                        result = B_BAD_VALUE;
                        } else
                                info.flags = 0;
                } else
                        result = B_BAD_TYPE;
        } else {
                // a team ID is given
                result = be_roster->GetRunningAppInfo(team, &info);
                // Compare the returned signature with the supplied one.
                if (result == B_OK && signature != NULL
                        && strcasecmp(signature, info.signature) != 0) {
                        result = B_MISMATCHED_VALUES;
                }
        }
        // check whether the app flags say B_ARGV_ONLY
        if (result == B_OK && (info.flags & B_ARGV_ONLY) != 0) {
                result = B_BAD_TYPE;
                // Set the team ID nevertheless -- that's what Be's implementation
                // does. Don't know, if that is a bug, but at least it doesn't harm.
                fTeam = team;
        }
        // init our members
        if (result == B_OK) {
                fTeam = team;
                fPort = info.port;
                fHandlerToken = B_PREFERRED_TOKEN;
        }

        // return the result
        if (_result != NULL)
                *_result = result;
}


/*!     Initializes the BMessenger to target the local BHandler and/or BLooper.

        When a \c NULL handler is supplied, the preferred handler in the given
        looper is targeted. If no looper is supplied the looper the given handler
        belongs to is used -- that means in particular, that the handler must
        already belong to a looper. If both are supplied the handler must actually
        belong to looper.

        \param handler The target handler. May be \c NULL.
        \param looper The target looper. May be \c NULL.
        \param result An optional pointer to a pre-allocated status_t into which
               the result of the initialization is written.
*/
void
BMessenger::_InitData(const BHandler* handler, const BLooper* looper,
        status_t* _result)
{
        status_t result = (handler != NULL || looper != NULL) ? B_OK : B_BAD_VALUE;
        if (result == B_OK) {
                if (handler != NULL) {
                        // BHandler is given, check/retrieve the looper.
                        if (looper != NULL) {
                                if (handler->Looper() != looper)
                                        result = B_MISMATCHED_VALUES;
                        } else {
                                looper = handler->Looper();
                                if (looper == NULL)
                                        result = B_MISMATCHED_VALUES;
                        }
                }

                // set port, token,...
                if (result == B_OK) {
                        AutoLocker<BLooperList> locker(gLooperList);
                        if (locker.IsLocked() && gLooperList.IsLooperValid(looper)) {
                                fPort = looper->fMsgPort;
                                fHandlerToken = handler != NULL
                                        ? _get_object_token_(handler)
                                        : B_PREFERRED_TOKEN;
                                fTeam = looper->Team();
                        } else
                                result = B_BAD_VALUE;
                }
        }

        if (_result != NULL)
                *_result = result;
}


//      #pragma mark - Operator functions


bool
operator<(const BMessenger& _a, const BMessenger& _b)
{
        BMessenger::Private a(const_cast<BMessenger&>(_a));
        BMessenger::Private b(const_cast<BMessenger&>(_b));

        // significance:
        // 1. fPort
        // 2. fHandlerToken
        // 3. fPreferredTarget
        // fTeam is insignificant
        return (a.Port() < b.Port()
                        || (a.Port() == b.Port()
                                && (a.Token() < b.Token()
                                        || (a.Token() == b.Token()
                                                && !a.IsPreferredTarget()
                                                && b.IsPreferredTarget()))));
}


bool
operator!=(const BMessenger& a, const BMessenger& b)
{
        return !(a == b);
}