/*
 * Copyright 2010-2017 Haiku Inc. All rights reserved.
 * Distributed under the terms of the MIT License.
 *
 * Authors:
 *              Christophe Huriaux, c.huriaux@gmail.com
 *              Adrien Destugues, pulkomandy@pulkomandy.tk
 */


#include <UrlProtocolAsynchronousListener.h>

#include <new>

#include <AppKit.h>
#include <Archivable.h>
#include <Debug.h>
#include <String.h>
#include <UrlResult.h>

using namespace BPrivate::Network;


extern const char* kUrlProtocolMessageType;
extern const char* kUrlProtocolCaller;


BUrlProtocolAsynchronousListener::BUrlProtocolAsynchronousListener(
        bool transparent)
        :
        BHandler("UrlProtocolAsynchronousListener"),
        BUrlProtocolListener(),
        fSynchronousListener(NULL)
{
        if (be_app->Lock()) {
                be_app->AddHandler(this);
                be_app->Unlock();
        } else
                PRINT(("Cannot lock be_app\n"));

        if (transparent) {
                fSynchronousListener
                        = new(std::nothrow) BUrlProtocolDispatchingListener(this);
        }
}


BUrlProtocolAsynchronousListener::~BUrlProtocolAsynchronousListener()
{
        if (be_app->Lock()) {
                be_app->RemoveHandler(this);
                be_app->Unlock();
        }
        delete fSynchronousListener;
}


// #pragma mark Synchronous listener access


BUrlProtocolListener*
BUrlProtocolAsynchronousListener::SynchronousListener()
{
        return fSynchronousListener;
}


void
BUrlProtocolAsynchronousListener::MessageReceived(BMessage* message)
{
        if (message->what != B_URL_PROTOCOL_NOTIFICATION) {
                BHandler::MessageReceived(message);
                return;
        }

        BUrlRequest* caller;
        if (message->FindPointer(kUrlProtocolCaller, (void**)&caller) != B_OK)
                return;

        int8 notification;
        if (message->FindInt8(kUrlProtocolMessageType, &notification) != B_OK)
                return;

        switch (notification) {
                case B_URL_PROTOCOL_CONNECTION_OPENED:
                        ConnectionOpened(caller);
                        break;

                case B_URL_PROTOCOL_HOSTNAME_RESOLVED:
                        {
                                const char* ip;
                                message->FindString("url:ip", &ip);

                                HostnameResolved(caller, ip);
                        }
                        break;

                case B_URL_PROTOCOL_RESPONSE_STARTED:
                        ResponseStarted(caller);
                        break;

                case B_URL_PROTOCOL_HEADERS_RECEIVED:
                        HeadersReceived(caller);
                        break;

                case B_URL_PROTOCOL_BYTES_WRITTEN:
                        {
                                size_t bytesWritten = message->FindInt32("url:bytesWritten");

                                BytesWritten(caller, bytesWritten);
                        }
                        break;

                case B_URL_PROTOCOL_DOWNLOAD_PROGRESS:
                        {
                                off_t bytesReceived;
                                off_t bytesTotal;
                                message->FindInt64("url:bytesReceived", &bytesReceived);
                                message->FindInt64("url:bytesTotal", &bytesTotal);

                                DownloadProgress(caller, bytesReceived, bytesTotal);
                        }
                        break;

                case B_URL_PROTOCOL_UPLOAD_PROGRESS:
                        {
                                off_t bytesSent;
                                off_t bytesTotal;
                                message->FindInt64("url:bytesSent", &bytesSent);
                                message->FindInt64("url:bytesTotal", &bytesTotal);

                                UploadProgress(caller, bytesSent, bytesTotal);
                        }
                        break;

                case B_URL_PROTOCOL_REQUEST_COMPLETED:
                        {
                                bool success;
                                message->FindBool("url:success", &success);

                                RequestCompleted(caller, success);
                        }
                        break;

                case B_URL_PROTOCOL_DEBUG_MESSAGE:
                        {
                                BUrlProtocolDebugMessage type
                                        = (BUrlProtocolDebugMessage)message->FindInt32("url:type");
                                BString text = message->FindString("url:text");

                                DebugMessage(caller, type, text);
                        }
                        break;

                case B_URL_PROTOCOL_CERTIFICATE_VERIFICATION_FAILED:
                        {
                                const char* error = message->FindString("url:error");
                                BCertificate* certificate;
                                message->FindPointer("url:certificate", (void**)&certificate);
                                bool result = CertificateVerificationFailed(caller,
                                        *certificate, error);

                                BMessage reply;
                                reply.AddBool("url:continue", result);
                                message->SendReply(&reply);
                        }
                        break;

                default:
                        PRINT(("BUrlProtocolAsynchronousListener: Unknown notification %d\n",
                                notification));
                        break;
        }
}