/*
 * Copyright 2009, Ingo Weinhold, ingo_weinhold@gmx.de.
 * Copyright 2011-2016, Rene Gollent, rene@gollent.com.
 * Distributed under the terms of the MIT License.
 */


#include "BreakpointsView.h"

#include <new>

#include <Button.h>
#include <CheckBox.h>
#include <LayoutBuilder.h>

#include <AutoLocker.h>
#include <ObjectList.h>

#include "AppMessageCodes.h"
#include "MessageCodes.h"
#include "Team.h"
#include "UserBreakpoint.h"


// #pragma mark - BreakpointsView


BreakpointsView::BreakpointsView(Team* team, Listener* listener)
        :
        BGroupView(B_HORIZONTAL, 4.0f),
        fTeam(team),
        fListView(NULL),
        fToggleBreakpointButton(NULL),
        fEditBreakpointButton(NULL),
        fRemoveBreakpointButton(NULL),
        fListener(listener)
{
        SetName("Breakpoints");
}


BreakpointsView::~BreakpointsView()
{
        if (fListView != NULL)
                fListView->UnsetListener();
}


/*static*/ BreakpointsView*
BreakpointsView::Create(Team* team, Listener* listener)
{
        BreakpointsView* self = new BreakpointsView(team, listener);

        try {
                self->_Init();
        } catch (...) {
                delete self;
                throw;
        }

        return self;
}


void
BreakpointsView::UnsetListener()
{
        fListener = NULL;
}


void
BreakpointsView::UserBreakpointChanged(UserBreakpoint* breakpoint)
{
        fListView->UserBreakpointChanged(breakpoint);

        _UpdateButtons();
}


void
BreakpointsView::WatchpointChanged(Watchpoint* watchpoint)
{
        fListView->WatchpointChanged(watchpoint);

        _UpdateButtons();
}


void
BreakpointsView::MessageReceived(BMessage* message)
{
        switch (message->what) {
                case MSG_ENABLE_BREAKPOINT:
                case MSG_DISABLE_BREAKPOINT:
                case MSG_CLEAR_BREAKPOINT:
                        _HandleBreakpointAction(message->what);
                        break;

                case MSG_SHOW_BREAKPOINT_EDIT_WINDOW:
                        message->AddPointer("breakpoint",
                                fSelectedBreakpoints.ItemAt(0)->GetBreakpoint());
                        Window()->PostMessage(message);
                        break;

                default:
                        BGroupView::MessageReceived(message);
                        break;
        }
}


void
BreakpointsView::AttachedToWindow()
{
        fEditBreakpointButton->SetTarget(this);
        fToggleBreakpointButton->SetTarget(this);
        fRemoveBreakpointButton->SetTarget(this);
}


void
BreakpointsView::LoadSettings(const BMessage& settings)
{
        BMessage breakpointListSettings;
        if (settings.FindMessage("breakpointList", &breakpointListSettings)
                == B_OK)
                fListView->LoadSettings(breakpointListSettings);
}


status_t
BreakpointsView::SaveSettings(BMessage& settings)
{
        BMessage breakpointListSettings;
        if (fListView->SaveSettings(breakpointListSettings) != B_OK)
                return B_NO_MEMORY;

        if (settings.AddMessage("breakpointList", &breakpointListSettings) != B_OK)
                return B_NO_MEMORY;

        return B_OK;
}


void
BreakpointsView::BreakpointSelectionChanged(BreakpointProxyList& proxies)
{
        if (fListener != NULL)
                fListener->BreakpointSelectionChanged(proxies);

        _SetSelection(proxies);
}


void
BreakpointsView::_Init()
{
        BLayoutBuilder::Group<>(this, B_VERTICAL, 0.0f)
                .Add(fListView = BreakpointListView::Create(fTeam, this, this))
                .AddGroup(B_HORIZONTAL, B_USE_SMALL_SPACING)
                        .SetInsets(B_USE_SMALL_SPACING)
                        .AddGlue()
                        .Add(fRemoveBreakpointButton = new BButton("Remove"))
                        .Add(fEditBreakpointButton = new BButton("Edit" B_UTF8_ELLIPSIS))
                        .Add(fToggleBreakpointButton = new BButton("Toggle"))
                .End();

        fToggleBreakpointButton->SetMessage(new BMessage(MSG_ENABLE_BREAKPOINT));
        fRemoveBreakpointButton->SetMessage(new BMessage(MSG_CLEAR_BREAKPOINT));
        fEditBreakpointButton->SetMessage(
                new BMessage(MSG_SHOW_BREAKPOINT_EDIT_WINDOW));

        _UpdateButtons();
}


void
BreakpointsView::_UpdateButtons()
{
        AutoLocker<Team> teamLocker(fTeam);

        bool hasEnabled = false;
        bool hasDisabled = false;
        bool valid = false;

        for (int32 i = 0; i < fSelectedBreakpoints.CountItems(); i++) {
                BreakpointProxy* proxy = fSelectedBreakpoints.ItemAt(i);
                switch (proxy->Type()) {
                        case BREAKPOINT_PROXY_TYPE_BREAKPOINT:
                        {
                                UserBreakpoint* breakpoint = proxy->GetBreakpoint();
                                if (breakpoint->IsValid()) {
                                        valid = true;
                                        if (breakpoint->IsEnabled())
                                                hasEnabled = true;
                                        else
                                                hasDisabled = true;

                                }
                                break;
                        }
                        case BREAKPOINT_PROXY_TYPE_WATCHPOINT:
                        {
                                Watchpoint* watchpoint = proxy->GetWatchpoint();
                                valid = true;
                                if (watchpoint->IsEnabled())
                                        hasEnabled = true;
                                else
                                        hasDisabled = true;
                                break;
                        }
                        default:
                                break;
                }
        }

        if (valid) {
                // only allow condition editing if we have a single
                // actual breakpoint selected.
                // TODO: allow using this to modify watchpoints as
                // well.
                if (fSelectedBreakpoints.CountItems() == 1
                        && fSelectedBreakpoints.ItemAt(0)->Type()
                                == BREAKPOINT_PROXY_TYPE_BREAKPOINT) {
                        fEditBreakpointButton->SetEnabled(true);
                } else
                        fEditBreakpointButton->SetEnabled(false);

                // if we have at least one disabled breakpoint in the
                // selection, we leave the button as an Enable button
                if (hasEnabled && !hasDisabled) {
                        fToggleBreakpointButton->SetLabel("Disable");
                        fToggleBreakpointButton->SetMessage(
                                new BMessage(MSG_DISABLE_BREAKPOINT));
                } else {
                        fToggleBreakpointButton->SetLabel("Enable");
                        fToggleBreakpointButton->SetMessage(
                                new BMessage(MSG_ENABLE_BREAKPOINT));
                }

                fToggleBreakpointButton->SetEnabled(true);
                fRemoveBreakpointButton->SetEnabled(true);
        } else {
                fToggleBreakpointButton->SetLabel("Enable");
                fToggleBreakpointButton->SetEnabled(false);
                fEditBreakpointButton->SetEnabled(false);
                fRemoveBreakpointButton->SetEnabled(false);
        }
}


void
BreakpointsView::_SetSelection(BreakpointProxyList& proxies)
{
        for (int32 i = 0; i < fSelectedBreakpoints.CountItems(); i++)
                fSelectedBreakpoints.ItemAt(i)->ReleaseReference();

        fSelectedBreakpoints.MakeEmpty();

        for (int32 i = 0; i < proxies.CountItems(); i++) {
                BreakpointProxy* proxy = proxies.ItemAt(i);
                if (!fSelectedBreakpoints.AddItem(proxy))
                        return;
                proxy->AcquireReference();
        }

        _UpdateButtons();
}


void
BreakpointsView::_HandleBreakpointAction(uint32 action)
{
        if (fListener == NULL)
                return;

        for (int32 i = 0; i < fSelectedBreakpoints.CountItems(); i++) {
                BreakpointProxy* proxy = fSelectedBreakpoints.ItemAt(i);
                if (proxy->Type() == BREAKPOINT_PROXY_TYPE_BREAKPOINT) {
                        UserBreakpoint* breakpoint = proxy->GetBreakpoint();
                        if (action == MSG_ENABLE_BREAKPOINT && !breakpoint->IsEnabled())
                                fListener->SetBreakpointEnabledRequested(breakpoint, true);
                        else if (action == MSG_DISABLE_BREAKPOINT
                                && breakpoint->IsEnabled()) {
                                fListener->SetBreakpointEnabledRequested(breakpoint, false);
                        } else if (action == MSG_CLEAR_BREAKPOINT)
                                fListener->ClearBreakpointRequested(breakpoint);
                } else {
                        Watchpoint* watchpoint = proxy->GetWatchpoint();
                        if (action == MSG_ENABLE_BREAKPOINT && !watchpoint->IsEnabled())
                                fListener->SetWatchpointEnabledRequested(watchpoint, true);
                        else if (action == MSG_DISABLE_BREAKPOINT
                                && watchpoint->IsEnabled()) {
                                fListener->SetWatchpointEnabledRequested(watchpoint, false);
                        } else if (action == MSG_CLEAR_BREAKPOINT)
                                fListener->ClearWatchpointRequested(watchpoint);
                }
        }
}


// #pragma mark - Listener


BreakpointsView::Listener::~Listener()
{
}