//////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////
//
// copyright            : (C) 2008 by Eran Ifrah
// file name            : dbgcmd.h
//
// -------------------------------------------------------------------------
// A
//              _____           _      _     _ _
//             /  __ \         | |    | |   (_) |
//             | /  \/ ___   __| | ___| |    _| |_ ___
//             | |    / _ \ / _  |/ _ \ |   | | __/ _ )
//             | \__/\ (_) | (_| |  __/ |___| | ||  __/
//              \____/\___/ \__,_|\___\_____/_|\__\___|
//
//                                                  F i l e
//
//    This program is free software; you can redistribute it and/or modify
//    it under the terms of the GNU General Public License as published by
//    the Free Software Foundation; either version 2 of the License, or
//    (at your option) any later version.
//
//////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////
#ifndef DBGCMD_H
#define DBGCMD_H

#include "wx/string.h"
#include "wx/event.h"
#include "debuggerobserver.h"
#include "debugger.h"

class IDebugger;
class DbgGdb;

#define GDB_NEXT_TOKEN()                              \
    {                                                 \
        type = gdb_result_lex();                      \
        currentToken = _U(gdb_result_string.c_str()); \
    }

#define GDB_ABORT(ch)     \
    if(type != (int)ch) { \
        break;            \
    }

class DbgCmdHandler
{
protected:
    IDebuggerObserver* m_observer;

public:
    DbgCmdHandler(IDebuggerObserver* observer)
        : m_observer(observer)
    {
    }
    virtual ~DbgCmdHandler() {}

    virtual bool WantsErrors() const { return false; }

    virtual bool ProcessOutput(const wxString& line) = 0;
};

/**
 * handles the
 * -file-list-exec-source-file command
 */
class DbgCmdHandlerGetLine : public DbgCmdHandler
{
    DbgGdb* m_gdb;

public:
    DbgCmdHandlerGetLine(IDebuggerObserver* observe, DbgGdb* gdbr)
        : DbgCmdHandler(observe)
        , m_gdb(gdbr)
    {
    }

    virtual ~DbgCmdHandlerGetLine() {}

    virtual bool ProcessOutput(const wxString& line);
};

class DbgCmdHandlerDisasseble : public DbgCmdHandler
{
    DbgGdb* m_gdb;

public:
    DbgCmdHandlerDisasseble(IDebuggerObserver* observe, DbgGdb* gdbr)
        : DbgCmdHandler(observe)
        , m_gdb(gdbr)
    {
    }

    virtual ~DbgCmdHandlerDisasseble() {}

    virtual bool ProcessOutput(const wxString& line);
};

class DbgCmdHandlerDisassebleCurLine : public DbgCmdHandler
{
    DbgGdb* m_gdb;

public:
    DbgCmdHandlerDisassebleCurLine(IDebuggerObserver* observe, DbgGdb* gdbr)
        : DbgCmdHandler(observe)
        , m_gdb(gdbr)
    {
    }

    virtual ~DbgCmdHandlerDisassebleCurLine() {}

    virtual bool ProcessOutput(const wxString& line);
};

/**
 * @class DbgCmdHandlerStackInfo
 * handles the -stack-info-frame command
 */
class DbgCmdHandlerStackDepth : public DbgCmdHandler
{
    DbgGdb* m_gdb;

public:
    DbgCmdHandlerStackDepth(IDebuggerObserver* observe, DbgGdb* gdbr)
        : DbgCmdHandler(observe)
        , m_gdb(gdbr)
    {
    }

    virtual ~DbgCmdHandlerStackDepth() {}

    virtual bool ProcessOutput(const wxString& line);
};

/**
 * this handler, handles the following commands:
 * -exec-run
 * -exec-continue
 * -exec-step
 * -exec-next
 * -exec-finish
 */
class DbgCmdHandlerAsyncCmd : public DbgCmdHandler
{
protected:
    DbgGdb* m_gdb;

public:
    DbgCmdHandlerAsyncCmd(IDebuggerObserver* observer, DbgGdb* gdb)
        : DbgCmdHandler(observer)
        , m_gdb(gdb)
    {
    }
    virtual ~DbgCmdHandlerAsyncCmd() {}

    void UpdateGotControl(DebuggerReasons reason, const wxString& func);
    virtual bool ProcessOutput(const wxString& line);
};

class DbgCmdHandlerExecRun : public DbgCmdHandlerAsyncCmd
{
public:
    DbgCmdHandlerExecRun(IDebuggerObserver* observer, DbgGdb* gdb)
        : DbgCmdHandlerAsyncCmd(observer, gdb)
    {
    }

    virtual ~DbgCmdHandlerExecRun() {}
    virtual bool ProcessOutput(const wxString& line);
    virtual bool WantsErrors() const { return true; }
};

class DbgCmdHandlerRemoteDebugging : public DbgCmdHandler
{
    IDebugger* m_debugger;

public:
    DbgCmdHandlerRemoteDebugging(IDebuggerObserver* observer, IDebugger* debugger)
        : DbgCmdHandler(observer)
        , m_debugger(debugger)
    {
    }

    virtual ~DbgCmdHandlerRemoteDebugging() {}

    virtual bool ProcessOutput(const wxString& line);
};

class DbgCmdHandlerBp : public DbgCmdHandler
{
    const BreakpointInfo m_bp;
    std::vector<BreakpointInfo>* m_bplist;
    int m_bpType; // BP_type_break by default
    DbgGdb* m_debugger;

public:
    DbgCmdHandlerBp(IDebuggerObserver* observer,
                    DbgGdb* debugger,
                    BreakpointInfo bp,
                    std::vector<BreakpointInfo>* bplist,
                    int bptype = BP_type_break)
        : DbgCmdHandler(observer)
        , m_bp(bp)
        , m_bplist(bplist)
        , m_bpType(bptype)
        , m_debugger(debugger)
    {
    }

    virtual ~DbgCmdHandlerBp() {}
    virtual bool ProcessOutput(const wxString& line);
    virtual bool WantsErrors() const { return true; }
};

class DbgCmdHandlerLocals : public DbgCmdHandler
{
public:
    DbgCmdHandlerLocals(IDebuggerObserver* observer)
        : DbgCmdHandler(observer)
    {
    }
    virtual ~DbgCmdHandlerLocals() {}
    virtual bool ProcessOutput(const wxString& line);
};

class DbgCmdHandlerFuncArgs : public DbgCmdHandler
{
public:
    DbgCmdHandlerFuncArgs(IDebuggerObserver* observer)
        : DbgCmdHandler(observer)
    {
    }
    virtual ~DbgCmdHandlerFuncArgs() {}
    virtual bool ProcessOutput(const wxString& line);
};

// A Void Handler, which is here simply to ignore a reply from the debugger
class DbgCmdHandlerVarCreator : public DbgCmdHandler
{
public:
    DbgCmdHandlerVarCreator(IDebuggerObserver* observer)
        : DbgCmdHandler(observer)
    {
    }
    virtual ~DbgCmdHandlerVarCreator() {}
    virtual bool ProcessOutput(const wxString& line);
};

class DbgCmdHandlerEvalExpr : public DbgCmdHandler
{
    wxString m_expression;

public:
    DbgCmdHandlerEvalExpr(IDebuggerObserver* observer, const wxString& expression)
        : DbgCmdHandler(observer)
        , m_expression(expression)
    {
    }

    virtual ~DbgCmdHandlerEvalExpr() {}
    virtual bool ProcessOutput(const wxString& line);
    virtual const wxString& GetExpression() const { return m_expression; }
};

// handler -list-stack-frames command
class DbgCmdStackList : public DbgCmdHandler
{
public:
    DbgCmdStackList(IDebuggerObserver* observer)
        : DbgCmdHandler(observer)
    {
    }
    virtual ~DbgCmdStackList() {}
    virtual bool ProcessOutput(const wxString& line);
};

// handler -list-stack-frames command
class DbgCmdSelectFrame : public DbgCmdHandler
{
public:
    DbgCmdSelectFrame(IDebuggerObserver* observer)
        : DbgCmdHandler(observer)
    {
    }
    virtual ~DbgCmdSelectFrame() {}
    virtual bool ProcessOutput(const wxString& line);
};

// Used for Ignore etc
class DbgCmdDisplayOutput : public DbgCmdHandler
{
public:
    DbgCmdDisplayOutput(IDebuggerObserver* observer)
        : DbgCmdHandler(observer)
    {
    }
    virtual ~DbgCmdDisplayOutput() {}
    virtual bool ProcessOutput(const wxString& line);
};

class DbgCmdResolveTypeHandler : public DbgCmdHandler
{
    DbgGdb* m_debugger;
    wxString m_expression;
    int m_userReason;

public:
    DbgCmdResolveTypeHandler(const wxString& expression, DbgGdb* debugger, int userReason);

    virtual ~DbgCmdResolveTypeHandler() {}
    virtual bool ProcessOutput(const wxString& line);
    virtual bool WantsErrors() const { return true; }
};

class DbgCmdCLIHandler : public DbgCmdHandler
{
    wxString m_output;
    wxString m_commandId;

public:
    DbgCmdCLIHandler(IDebuggerObserver* observer)
        : DbgCmdHandler(observer)
    {
    }

    virtual ~DbgCmdCLIHandler() {}
    virtual bool ProcessOutput(const wxString& line);

    const wxString& GetOutput() const { return m_output; }

    void SetCommandId(const wxString& commandId) { this->m_commandId = commandId; }

    const wxString& GetCommandId() const { return m_commandId; }

    void Append(const wxString& text) { m_output.Append(text + wxT("\n")); }
};

class DbgCmdGetTipHandler : public DbgCmdCLIHandler
{

    wxString m_expression;

public:
    DbgCmdGetTipHandler(IDebuggerObserver* observer, const wxString& expression)
        : DbgCmdCLIHandler(observer)
        , m_expression(expression)
    {
    }

    virtual ~DbgCmdGetTipHandler() {}
    virtual bool ProcessOutput(const wxString& line);
};

// Callback for handling 'set condition' command
class DbgCmdSetConditionHandler : public DbgCmdHandler
{
    BreakpointInfo m_bp;

public:
    DbgCmdSetConditionHandler(IDebuggerObserver* observer, const BreakpointInfo& bp)
        : DbgCmdHandler(observer)
        , m_bp(bp)
    {
    }
    virtual ~DbgCmdSetConditionHandler() {}

    virtual bool ProcessOutput(const wxString& line);
};

// Callback for handling parsing the -break-list output from
// the debugger
class DbgCmdBreakList : public DbgCmdHandler
{
public:
    DbgCmdBreakList(IDebuggerObserver* observer)
        : DbgCmdHandler(observer)
    {
    }
    virtual ~DbgCmdBreakList() {}

    virtual bool ProcessOutput(const wxString& line);
};

// Callback for handling threads info
// command
class DbgCmdListThreads : public DbgCmdHandler
{
public:
    DbgCmdListThreads(IDebuggerObserver* observer)
        : DbgCmdHandler(observer)
    {
    }
    virtual ~DbgCmdListThreads() {}

    virtual bool ProcessOutput(const wxString& line);
};

// Callback for handling the '-data-read-memory' command
class DbgCmdWatchMemory : public DbgCmdHandler
{
    wxString m_address;
    size_t m_count;
    size_t m_columns;

public:
    DbgCmdWatchMemory(IDebuggerObserver* observer, const wxString& address, size_t count, size_t columns)
        : DbgCmdHandler(observer)
        , m_address(address)
        , m_count(count)
        , m_columns(columns)
    {
    }
    virtual ~DbgCmdWatchMemory() {}
    virtual bool ProcessOutput(const wxString& line);
};

// Handle the 'CreateVariableObject' call
class DbgCmdCreateVarObj : public DbgCmdHandler
{
    wxString m_expression;
    int m_userReason;
    DbgGdb* m_debugger;

public:
    DbgCmdCreateVarObj(IDebuggerObserver* observer, DbgGdb* gdb, const wxString& expression, int userReason)
        : DbgCmdHandler(observer)
        , m_expression(expression)
        , m_userReason(userReason)
        , m_debugger(gdb)
    {
    }

    /**
     * @brief we want to handle error ourselves
     */
    virtual bool WantsErrors() const { return true; }

    virtual ~DbgCmdCreateVarObj() {}

    virtual bool ProcessOutput(const wxString& line);
};

// Handle the 'DbgCmdListChildren' call
class DbgCmdListChildren : public DbgCmdHandler
{
    wxString m_variable;
    int m_userReason;

public:
    DbgCmdListChildren(IDebuggerObserver* observer, const wxString& variable, int userReason)
        : DbgCmdHandler(observer)
        , m_variable(variable)
        , m_userReason(userReason)
    {
    }

    virtual ~DbgCmdListChildren() {}

    virtual bool ProcessOutput(const wxString& line);
};

class DbgCmdEvalVarObj : public DbgCmdHandler
{
    wxString m_variable;
    int m_userReason;

public:
    DbgCmdEvalVarObj(IDebuggerObserver* observer, const wxString& variable, int userReason)
        : DbgCmdHandler(observer)
        , m_variable(variable)
        , m_userReason(userReason)
    {
    }

    virtual ~DbgCmdEvalVarObj() {}

    virtual bool ProcessOutput(const wxString& line);
};

class DbgFindMainBreakpointIdHandler : public DbgCmdHandler
{
    DbgGdb* m_debugger;

public:
    DbgFindMainBreakpointIdHandler(IDebuggerObserver* observer, DbgGdb* debugger)
        : DbgCmdHandler(observer)
        , m_debugger(debugger)
    {
    }

    virtual ~DbgFindMainBreakpointIdHandler() {}

    virtual bool ProcessOutput(const wxString& line);
};

class DbgVarObjUpdate : public DbgCmdHandler
{
    wxString m_variableName;
    DbgGdb* m_debugger;
    int m_userReason;

public:
    DbgVarObjUpdate(IDebuggerObserver* observer, DbgGdb* debugger, const wxString& name, int userReason)
        : DbgCmdHandler(observer)
        , m_variableName(name)
        , m_debugger(debugger)
        , m_userReason(userReason)
    {
    }

    virtual ~DbgVarObjUpdate() {}

    virtual bool ProcessOutput(const wxString& line);
    virtual bool WantsErrors() { return true; }
};

// Callback for handling jump command questions
// command
class DbgCmdJumpHandler : public DbgCmdCLIHandler
{
public:
    DbgCmdJumpHandler(IDebuggerObserver* observer)
        : DbgCmdCLIHandler(observer)
    {
    }
    virtual ~DbgCmdJumpHandler() {}

    virtual bool ProcessOutput(const wxString& line);
};

class DbgCmdStopHandler : public DbgCmdHandler
{
public:
    DbgCmdStopHandler(IDebuggerObserver* observer)
        : DbgCmdHandler(observer)
    {
    }
    virtual ~DbgCmdStopHandler() {}

    virtual bool ProcessOutput(const wxString& line);
};

class DbgCmdRecordHandler : public DbgCmdHandler
{
    DbgGdb* m_gdb;

public:
    DbgCmdRecordHandler(IDebuggerObserver* observer, DbgGdb* gdb)
        : DbgCmdHandler(observer)
        , m_gdb(gdb)
    {
    }
    virtual ~DbgCmdRecordHandler() {}

    virtual bool ProcessOutput(const wxString& line);
};

// +++-----------------------------
// DbgCmdHandlerRegisterNames
// +++-----------------------------

class DbgCmdHandlerRegisterNames : public DbgCmdHandler
{
    DbgGdb* m_gdb;
    std::map<int, wxString> m_numberToName;

public:
    DbgCmdHandlerRegisterNames(IDebuggerObserver* observer, DbgGdb* gdbr)
        : DbgCmdHandler(observer)
        , m_gdb(gdbr)
    {
    }

    virtual ~DbgCmdHandlerRegisterNames() {}

    virtual bool ProcessOutput(const wxString& line);
};

// +++-----------------------------
// DbgCmdHandlerRegisterValues
// +++-----------------------------
class DbgCmdHandlerRegisterValues : public DbgCmdHandler
{
    DbgGdb* m_gdb;
    std::map<int, wxString> m_numberToName;

public:
    DbgCmdHandlerRegisterValues(IDebuggerObserver* observer, DbgGdb* gdbr, const std::map<int, wxString>& numberToName)
        : DbgCmdHandler(observer)
        , m_gdb(gdbr)
    {
        m_numberToName = numberToName;
    }

    virtual ~DbgCmdHandlerRegisterValues() {}

    virtual bool ProcessOutput(const wxString& line);
};
#endif // DBGCMD_H
