/*
 * Copyright 2016, Rene Gollent, rene@gollent.com.
 * Distributed under the terms of the MIT License.
 */

#include "TargetHostInterface.h"

#include <stdio.h>

#include <AutoLocker.h>

#include "DebuggerInterface.h"
#include "MessageCodes.h"
#include "TeamDebugger.h"


// #pragma mark - TeamDebuggerOptions


TeamDebuggerOptions::TeamDebuggerOptions()
        :
        requestType(TEAM_DEBUGGER_REQUEST_UNKNOWN),
        commandLineArgc(0),
        commandLineArgv(NULL),
        team(-1),
        thread(-1),
        settingsManager(NULL),
        userInterface(NULL),
        coreFilePath(NULL)
{
}


// #pragma mark - TargetHostInterface


TargetHostInterface::TargetHostInterface()
        :
        BLooper(),
        fListeners(),
        fTeamDebuggers(20)
{
}


TargetHostInterface::~TargetHostInterface()
{
        for (ListenerList::Iterator it = fListeners.GetIterator();
                        Listener* listener = it.Next();) {
                listener->TargetHostInterfaceQuit(this);
        }
}


status_t
TargetHostInterface::StartTeamDebugger(const TeamDebuggerOptions& options)
{
        // we only want to stop in main for teams we're responsible for
        // creating ourselves.
        bool stopInMain = options.requestType == TEAM_DEBUGGER_REQUEST_CREATE;
        team_id team = options.team;
        thread_id thread = options.thread;

        AutoLocker<TargetHostInterface> interfaceLocker(this);
        if (options.requestType == TEAM_DEBUGGER_REQUEST_CREATE) {
                status_t error = CreateTeam(options.commandLineArgc,
                        options.commandLineArgv, team);
                if (error != B_OK)
                        return error;
                thread = team;
        }

        if (options.requestType != TEAM_DEBUGGER_REQUEST_LOAD_CORE) {

                if (team < 0 && thread < 0)
                        return B_BAD_VALUE;

                if (team < 0) {
                        status_t error = FindTeamByThread(thread, team);
                        if (error != B_OK)
                                return error;
                }

                TeamDebugger* debugger = FindTeamDebugger(team);
                if (debugger != NULL) {
                        debugger->Activate();
                        return B_OK;
                }
        }

        return _StartTeamDebugger(team, options, stopInMain);
}


int32
TargetHostInterface::CountTeamDebuggers() const
{
        return fTeamDebuggers.CountItems();
}


TeamDebugger*
TargetHostInterface::TeamDebuggerAt(int32 index) const
{
        return fTeamDebuggers.ItemAt(index);
}


TeamDebugger*
TargetHostInterface::FindTeamDebugger(team_id team) const
{
        for (int32 i = 0; i < fTeamDebuggers.CountItems(); i++) {
                TeamDebugger* debugger = fTeamDebuggers.ItemAt(i);
                if (debugger->TeamID() == team && !debugger->IsPostMortem())
                        return debugger;
        }

        return NULL;
}


status_t
TargetHostInterface::AddTeamDebugger(TeamDebugger* debugger)
{
        if (!fTeamDebuggers.BinaryInsert(debugger, &_CompareDebuggers))
                return B_NO_MEMORY;

        return B_OK;
}


void
TargetHostInterface::RemoveTeamDebugger(TeamDebugger* debugger)
{
        for (int32 i = 0; i < fTeamDebuggers.CountItems(); i++) {
                if (fTeamDebuggers.ItemAt(i) == debugger) {
                        fTeamDebuggers.RemoveItemAt(i);
                        break;
                }
        }
}


void
TargetHostInterface::AddListener(Listener* listener)
{
        AutoLocker<TargetHostInterface> interfaceLocker(this);
        fListeners.Add(listener);
}


void
TargetHostInterface::RemoveListener(Listener* listener)
{
        AutoLocker<TargetHostInterface> interfaceLocker(this);
        fListeners.Remove(listener);
}


void
TargetHostInterface::Quit()
{
        if (fTeamDebuggers.CountItems() == 0)
                BLooper::Quit();
}


void
TargetHostInterface::MessageReceived(BMessage* message)
{
        switch (message->what) {
        case MSG_TEAM_DEBUGGER_QUIT:
        {
                thread_id thread;
                if (message->FindInt32("thread", &thread) == B_OK)
                        wait_for_thread(thread, NULL);
                break;
        }
        case MSG_TEAM_RESTART_REQUESTED:
        {
                int32 teamID;
                if (message->FindInt32("team", &teamID) != B_OK)
                        break;

                TeamDebugger* debugger = FindTeamDebugger(teamID);

                UserInterface* userInterface = debugger->GetUserInterface()->Clone();
                if (userInterface == NULL)
                        break;

                BReference<UserInterface> userInterfaceReference(userInterface, true);

                TeamDebuggerOptions options;
                options.requestType = TEAM_DEBUGGER_REQUEST_CREATE;
                options.commandLineArgc = debugger->ArgumentCount();
                options.commandLineArgv = debugger->Arguments();
                options.settingsManager = debugger->GetSettingsManager();
                options.userInterface = userInterface;
                status_t result = StartTeamDebugger(options);
                if (result == B_OK) {
                        userInterfaceReference.Detach();
                        debugger->PostMessage(B_QUIT_REQUESTED);
                }
                break;
        }
        default:
                BLooper::MessageReceived(message);
                break;
        }
}


void
TargetHostInterface::TeamDebuggerStarted(TeamDebugger* debugger)
{
        AutoLocker<TargetHostInterface> locker(this);
        AddTeamDebugger(debugger);
        _NotifyTeamDebuggerStarted(debugger);
}


void
TargetHostInterface::TeamDebuggerRestartRequested(TeamDebugger* debugger)
{
        BMessage message(MSG_TEAM_RESTART_REQUESTED);
        message.AddInt32("team", debugger->TeamID());
        PostMessage(&message);
}


void
TargetHostInterface::TeamDebuggerQuit(TeamDebugger* debugger)
{
        AutoLocker<TargetHostInterface> interfaceLocker(this);
        RemoveTeamDebugger(debugger);

        if (debugger->Thread() >= 0) {
                _NotifyTeamDebuggerQuit(debugger);
                BMessage message(MSG_TEAM_DEBUGGER_QUIT);
                message.AddInt32("thread", debugger->Thread());
                PostMessage(&message);
        }
}


status_t
TargetHostInterface::_StartTeamDebugger(team_id teamID,
        const TeamDebuggerOptions& options, bool stopInMain)
{
        UserInterface* userInterface = options.userInterface;
        if (userInterface == NULL) {
                fprintf(stderr, "Error: Requested team debugger start without "
                        "valid user interface!\n");
                return B_BAD_VALUE;
        }

        thread_id threadID = options.thread;
        if (options.commandLineArgv != NULL)
                threadID = teamID;

        DebuggerInterface* interface = NULL;
        TeamDebugger* debugger = NULL;
        status_t error = B_OK;
        if (options.requestType != TEAM_DEBUGGER_REQUEST_LOAD_CORE) {
                error = Attach(teamID, options.thread, interface);
                if (error != B_OK) {
                        fprintf(stderr, "Error: Failed to attach to team %" B_PRId32
                                ": %s!\n", teamID, strerror(error));
                        return error;
                }
        } else {
                error = LoadCore(options.coreFilePath, interface, threadID);
                if (error != B_OK) {
                        fprintf(stderr, "Error: Failed to load core file '%s': %s!\n",
                                options.coreFilePath, strerror(error));
                        return error;
                }
        }

        BReference<DebuggerInterface> debuggerInterfaceReference(interface,
                true);
        debugger = new(std::nothrow) TeamDebugger(this, userInterface,
                options.settingsManager);
        if (debugger != NULL) {
                error = debugger->Init(interface, threadID,
                        options.commandLineArgc, options.commandLineArgv, stopInMain);
        }

        if (error != B_OK) {
                printf("Error: debugger for team %" B_PRId32 " on interface %s failed"
                        " to init: %s!\n", interface->TeamID(), Name(), strerror(error));
                delete debugger;
                debugger = NULL;
        } else {
                printf("debugger for team %" B_PRId32 " on interface %s created and"
                        " initialized successfully!\n", interface->TeamID(), Name());
        }

        return error;
}


void
TargetHostInterface::_NotifyTeamDebuggerStarted(TeamDebugger* debugger)
{
        for (ListenerList::Iterator it = fListeners.GetIterator();
                        Listener* listener = it.Next();) {
                listener->TeamDebuggerStarted(debugger);
        }
}


void
TargetHostInterface::_NotifyTeamDebuggerQuit(TeamDebugger* debugger)
{
        for (ListenerList::Iterator it = fListeners.GetIterator();
                        Listener* listener = it.Next();) {
                listener->TeamDebuggerQuit(debugger);
        }
}


/*static*/ int
TargetHostInterface::_CompareDebuggers(const TeamDebugger* a,
        const TeamDebugger* b)
{
        return a->TeamID() < b->TeamID() ? -1 : 1;
}


// #pragma mark - TargetHostInterface::Listener


TargetHostInterface::Listener::~Listener()
{
}


void
TargetHostInterface::Listener::TeamDebuggerStarted(TeamDebugger* debugger)
{
}


void
TargetHostInterface::Listener::TeamDebuggerQuit(TeamDebugger* debugger)
{
}


void
TargetHostInterface::Listener::TargetHostInterfaceQuit(
        TargetHostInterface* interface)
{
}