/*
 * Copyright 2012-2016, Rene Gollent, rene@gollent.com.
 * Distributed under the terms of the MIT License.
 */
#include "WatchPromptWindow.h"

#include <Alert.h>
#include <Button.h>
#include <LayoutBuilder.h>
#include <Menu.h>
#include <MenuField.h>
#include <MenuItem.h>
#include <String.h>
#include <TextControl.h>

#include "AutoLocker.h"

#include "AppMessageCodes.h"
#include "Architecture.h"
#include "CppLanguage.h"
#include "IntegerValue.h"
#include "MessageCodes.h"
#include "SyntheticPrimitiveType.h"
#include "UserInterface.h"
#include "Watchpoint.h"


WatchPromptWindow::WatchPromptWindow(Architecture* architecture,
        target_addr_t address, uint32 type, int32 length,
        UserInterfaceListener* listener)
        :
        BWindow(BRect(), "Edit Watchpoint", B_FLOATING_WINDOW,
                B_AUTO_UPDATE_SIZE_LIMITS | B_CLOSE_ON_ESCAPE),
        fInitialAddress(address),
        fInitialType(type),
        fInitialLength(length),
        fArchitecture(architecture),
        fRequestedAddress(0),
        fRequestedLength(0),
        fAddressInput(NULL),
        fLengthInput(NULL),
        fAddressExpressionInfo(NULL),
        fLengthExpressionInfo(NULL),
        fTypeField(NULL),
        fListener(listener),
        fLanguage(NULL)
{
        fArchitecture->AcquireReference();
}


WatchPromptWindow::~WatchPromptWindow()
{
        fArchitecture->ReleaseReference();

        if (fLanguage != NULL)
                fLanguage->ReleaseReference();

        if (fAddressExpressionInfo != NULL) {
                fAddressExpressionInfo->RemoveListener(this);
                fAddressExpressionInfo->ReleaseReference();
        }

        if (fLengthExpressionInfo != NULL) {
                fLengthExpressionInfo->RemoveListener(this);
                fLengthExpressionInfo->ReleaseReference();
        }
}


WatchPromptWindow*
WatchPromptWindow::Create(Architecture* architecture, target_addr_t address,
        uint32 type, int32 length, UserInterfaceListener* listener)
{
        WatchPromptWindow* self = new WatchPromptWindow(architecture, address,
                type, length, listener);

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

        return self;

}


void
WatchPromptWindow::_Init()
{
        fLanguage = new CppLanguage();

        BString text;
        text.SetToFormat("0x%" B_PRIx64, fInitialAddress);
        fAddressInput = new BTextControl("Address:", text, NULL);
        fAddressExpressionInfo = new ExpressionInfo(text);
        fAddressExpressionInfo->AddListener(this);

        text.SetToFormat("%" B_PRId32, fInitialLength);
        fLengthInput = new BTextControl("Length:", text, NULL);
        fLengthExpressionInfo = new ExpressionInfo(text);
        fLengthExpressionInfo->AddListener(this);

        int32 maxDebugRegisters = 0;
        int32 maxBytesPerRegister = 0;
        uint8 debugCapabilityFlags = 0;
        fArchitecture->GetWatchpointDebugCapabilities(maxDebugRegisters,
                maxBytesPerRegister, debugCapabilityFlags);

        BMenu* typeMenu = new BMenu("Watch type");

        BMenuItem* watchTypeItem = new BMenuItem("Read", NULL);
        watchTypeItem->SetEnabled(
                (debugCapabilityFlags & WATCHPOINT_CAPABILITY_FLAG_READ) != 0);
        typeMenu->AddItem(watchTypeItem);

        watchTypeItem = new BMenuItem("Write", NULL);
        watchTypeItem->SetEnabled(
                (debugCapabilityFlags & WATCHPOINT_CAPABILITY_FLAG_WRITE) != 0);
        typeMenu->AddItem(watchTypeItem);

        watchTypeItem = new BMenuItem("Read/Write", NULL);
        watchTypeItem->SetEnabled(
                (debugCapabilityFlags & WATCHPOINT_CAPABILITY_FLAG_READ_WRITE) != 0);
        typeMenu->AddItem(watchTypeItem);

        fTypeField = new BMenuField("Type:", typeMenu);
        BLayoutItem* labelItem = fTypeField->CreateLabelLayoutItem();
        labelItem->View()->SetViewUIColor(B_PANEL_BACKGROUND_COLOR);
        BLayoutBuilder::Group<>(this, B_VERTICAL)
                .SetInsets(B_USE_DEFAULT_SPACING)
                .AddGroup(B_HORIZONTAL, 4.0f)
                        .Add(fAddressInput)
                .End()
                .AddGroup(B_HORIZONTAL, 4.0f)
                        .Add(fLengthInput)
                        .Add(labelItem)
                        .Add(fTypeField->CreateMenuBarLayoutItem())
                .End()
                .AddGroup(B_HORIZONTAL, 4.0f)
                        .AddGlue()
                        .Add((fWatchButton = new BButton("Set",
                                        new BMessage(MSG_SET_WATCHPOINT))))
                        .Add((fCancelButton = new BButton("Cancel",
                                        new BMessage(B_QUIT_REQUESTED))))
                .End();

        fWatchButton->SetTarget(this);
        fCancelButton->SetTarget(this);

        fTypeField->Menu()->SetLabelFromMarked(true);
        fTypeField->Menu()->ItemAt(fInitialType)->SetMarked(true);
}


void
WatchPromptWindow::Show()
{
        CenterOnScreen();
        BWindow::Show();
}


void
WatchPromptWindow::ExpressionEvaluated(ExpressionInfo* info, status_t result,
        ExpressionResult* value)
{
        BMessage message(MSG_EXPRESSION_EVALUATED);
        message.AddInt32("result", result);
        message.AddPointer("info", info);
        BReference<ExpressionResult> reference;
        if (value != NULL) {
                reference.SetTo(value);
                message.AddPointer("value", value);
        }

        if (PostMessage(&message) == B_OK)
                reference.Detach();
}


void
WatchPromptWindow::MessageReceived(BMessage* message)
{
        switch (message->what) {
                case MSG_EXPRESSION_EVALUATED:
                {
                        BString errorMessage;
                        BReference<ExpressionResult> reference;
                        ExpressionResult* value = NULL;
                        ExpressionInfo* info = NULL;
                        if (message->FindPointer("info",
                                        reinterpret_cast<void**>(&info)) != B_OK) {
                                break;
                        }

                        if (message->FindPointer("value",
                                        reinterpret_cast<void**>(&value)) == B_OK) {
                                reference.SetTo(value, true);
                                if (value->Kind() == EXPRESSION_RESULT_KIND_PRIMITIVE) {
                                        Value* primitive = value->PrimitiveValue();
                                        if (dynamic_cast<IntegerValue*>(primitive) != NULL) {
                                                BVariant resultVariant;
                                                primitive->ToVariant(resultVariant);
                                                if (info == fAddressExpressionInfo) {
                                                        fRequestedAddress = resultVariant.ToUInt64();
                                                        break;
                                                } else
                                                        fRequestedLength = resultVariant.ToInt32();
                                        }
                                        else
                                                primitive->ToString(errorMessage);
                                } else
                                        errorMessage.SetTo("Unsupported expression result.");
                        } else {
                                status_t result = message->FindInt32("result");
                                errorMessage.SetToFormat("Failed to evaluate expression: %s",
                                        strerror(result));
                        }

                        if (fRequestedLength <= 0)
                                errorMessage = "Watchpoint length must be at least 1 byte.";

                        if (!errorMessage.IsEmpty()) {
                                BAlert* alert = new(std::nothrow) BAlert("Edit Watchpoint",
                                        errorMessage.String(), "Close");
                                if (alert != NULL)
                                        alert->Go();
                                break;
                        }

                        fListener->ClearWatchpointRequested(fInitialAddress);
                        fListener->SetWatchpointRequested(fRequestedAddress,
                                fTypeField->Menu()->IndexOf(fTypeField->Menu()->FindMarked()),
                                fRequestedLength, true);

                        PostMessage(B_QUIT_REQUESTED);
                        break;
                }

                case MSG_SET_WATCHPOINT:
                {
                        fRequestedAddress = 0;
                        fRequestedLength = 0;

                        fAddressExpressionInfo->SetTo(fAddressInput->Text());
                        fListener->ExpressionEvaluationRequested(fLanguage,
                                fAddressExpressionInfo);

                        fLengthExpressionInfo->SetTo(fLengthInput->Text());
                        fListener->ExpressionEvaluationRequested(fLanguage,
                                fLengthExpressionInfo);
                        break;
                }

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

}