/*
* Copyright (c) 2008 James Molloy, Jörg Pfähler, Matthew Iselin
*
* Permission to use, copy, modify, and distribute this software for any
* purpose with or without fee is hereby granted, provided that the above
* copyright notice and this permission notice appear in all copies.
*
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
* ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*/

#include <Log.h>
#include <Debugger.h>
#include <DebuggerIO.h>
#include <LocalIO.h>
#include <SerialIO.h>
#include <DisassembleCommand.h>
#include <QuitCommand.h>
#include <PanicCommand.h>
#include <BreakpointCommand.h>
#include <CpuInfoCommand.h>
#include <DumpCommand.h>
#include <LogViewer.h>
#include <Backtracer.h>
#include <AllocationCommand.h>
#include <SlamCommand.h>
#include <utilities/utility.h>
#include <StepCommand.h>
#include <TraceCommand.h>
#include <MemoryInspector.h>
#include <IoCommand.h>
#include <ThreadsCommand.h>
#include <DevicesCommand.h>
#include <LookupCommand.h>
#include <SyscallTracerCommand.h>
#include <LookupCommand.h>
#include <HelpCommand.h>
#include <LocksCommand.h>
#include <MappingCommand.h>
#include <process/Thread.h>
#include <process/initialiseMultitasking.h>
#include <machine/Machine.h>
#include <process/Scheduler.h>
#include <graphics/GraphicsService.h>

Debugger Debugger::m_Instance;

TraceCommand g_Trace;
/// Helper function. Returns the index of a command in pCommands that matches prefix. Starts searching
/// through pCommands at index start. Returns -1 if none found.
static int getCommandMatchingPrefix(char *prefix, DebuggerCommand **pCommands, size_t nCmds, size_t start)
{
    for (size_t i = start; i < nCmds; i++)
    {
        if (!strncmp(pCommands[i]->getString(), prefix, strlen(prefix)))
            return i;
    }
    return -1;
}

/// Helper function. Returns true if the string in pStr matches pCommand. If so, pStr is changed
/// so that on return, it contains the parameters to that command (everything after the first space).
static bool matchesCommand(char *pStr, DebuggerCommand *pCommand)
{
    if (!strncmp(pCommand->getString(), pStr, strlen(pCommand->getString())))
    {
        size_t n = strlen(pCommand->getString());
        memcpy(pStr, pStr+n+1, strlen(pStr)-n);
        return true;
    }
    else
    {
        return false;
    }
}

Debugger::Debugger() :
m_pTempState(0), m_nIoType(DEBUGGER)
{
}

Debugger::~Debugger()
{
}

void Debugger::initialise()
{
#ifndef ARM_COMMON /// \todo Figure out a way of getting similar functionality on ARM
  if (!InterruptManager::instance().registerInterruptHandlerDebugger(InterruptManager::instance().getBreakpointInterruptNumber(), this))
        ERROR_NOLOCK("Debugger: breakpoint interrupt registration failed!");
    if (!InterruptManager::instance().registerInterruptHandlerDebugger(InterruptManager::instance().getDebugInterruptNumber(), this))
        ERROR_NOLOCK("Debugger: debug interrupt registration failed!");
#endif
}

/// \todo OZMFGBARBIE, this needs major cleanup. Look at the state of it!! :O
void Debugger::start(InterruptState &state, LargeStaticString &description)
{
    Log::instance() << " << Flushing log content >>" << Flush;

    // Drop out of whatever graphics mode we were in
  GraphicsService::GraphicsProvider provider;
    memset(&provider, 0, sizeof(provider));
    provider.bTextModes = true;

    ServiceFeatures *pFeatures = ServiceManager::instance().enumerateOperations(String("graphics"));
    Service         *pService  = ServiceManager::instance().getService(String("graphics"));
    bool bSuccess = false;
    if(pFeatures->provides(ServiceFeatures::probe))
        if(pService)
            bSuccess = pService->serve(ServiceFeatures::probe, reinterpret_cast<void*>(&provider), sizeof(provider));

        if(bSuccess && !provider.bTextModes)
            provider.pDisplay->setScreenMode(0);

        // We take a copy of the interrupt state here so that we can replace it with another thread's interrupt state should we
  // decide to switch threads.
#ifdef MULTIPROCESSOR
        Machine::instance().stopAllOtherProcessors();
#endif
        // The current thread, in case we decide to switch.
#if defined(THREADS)
            Thread *pThread = Processor::information().getCurrentThread();
#endif

        bool debugState = Machine::instance().getKeyboard()->getDebugState();
        Machine::instance().getKeyboard()->setDebugState(true);

        DebuggerIO *pInterfaces[2] = {0};

#ifndef DONT_LOG_TO_SERIAL
        static SerialIO serialIO(Machine::instance().getSerial(0));
        serialIO.initialise();
#endif

        /*
        * I/O implementations.
        */
        int nInterfaces = 0;
        if(Machine::instance().getNumVga()) // Not all machines have "VGA", so handle that
  {
            static LocalIO localIO(Machine::instance().getVga(0), Machine::instance().getKeyboard());
#ifdef DONT_LOG_TO_SERIAL
            pInterfaces[0] = &localIO;
            nInterfaces = 1;
#else
                pInterfaces[0] = &localIO;
            pInterfaces[1] = &serialIO;
            nInterfaces = 2;
#endif
        }
#ifndef DONT_LOG_TO_SERIAL
        else
        {
            pInterfaces[0] = &serialIO;
            nInterfaces = 1;
        }
#endif

        if(!nInterfaces)
        {
            // Oops, system doesn't support any output mechanisms!
    ERROR_NOLOCK("This machine/CPU combination doesn't support any output methods for the debugger!");
        }

        // IO interface.
  DebuggerIO *pIo = 0;
        int nChosenInterface = -1;

        // Commands.
  static DisassembleCommand disassembler;
        static LogViewer logViewer;
        static Backtracer backtracer;
        static QuitCommand quit;
        static BreakpointCommand breakpoint;
        static DumpCommand dump;
        static StepCommand step;
        static MemoryInspector memory;
        static PanicCommand panic;
        static CpuInfoCommand cpuInfo;
        static IoCommand io;
        static DevicesCommand devices;
        static SyscallTracerCommand syscallTracer;
        static LookupCommand lookup;
        static HelpCommand help;
        static MappingCommand mapping;

#if defined(THREADS)
            static ThreadsCommand threads;

        threads.setPointers(&pThread, &state);
#endif

#if defined(THREADS)
            size_t nCommands = 21;
#else
            size_t nCommands = 20;
#endif
        DebuggerCommand *pCommands[] = {&syscallTracer,
            &disassembler,
            &logViewer,
            &backtracer,
            &quit,
            &breakpoint,
            &dump,
            &step,
            &memory,
            &g_Trace,
            &panic,
            &cpuInfo,
            &devices,
#if defined(THREADS)
                &threads,
#endif
                &io,
                &g_AllocationCommand,
                &g_SlamCommand,
                &lookup,
                &help,
                &g_LocksCommand,
                &mapping};

        // Are we going to jump directly into the tracer? In which case bypass device detection.
  int n = g_Trace.execTrace();
        if (n == -1)
        {
            // Write a "Press any key..." message to each device, then poll each device.
    // The first one with data waiting becomes the active device, all others are locked out.
    for (int i = 0; i < nInterfaces; i++)
            {
                pInterfaces[i]->disableCli();
                pInterfaces[i]->drawString("Press any key to enter the debugger...", 0, 0, DebuggerIO::LightBlue, DebuggerIO::Black);
                NormalStaticString str;
                str += description;
                pInterfaces[i]->drawString(str, 2, 0, DebuggerIO::LightBlue, DebuggerIO::Black);
            }
            // Poll each device.
    while (pIo == 0)
                for (int i = 0; i < nInterfaces; i++)
            {
                char c = pInterfaces[i]->getCharNonBlock();
                if ((c >= 32 && static_cast<unsigned char>(c) <= 127) || c == '\n' ||
                    c == 0x08 || c == '\r' || c == 0x09)
                {
                    pIo = pInterfaces[i];
                    nChosenInterface = i;
                    break;
                }
            }
        }
        else
        {
            pIo = pInterfaces[n];
            nChosenInterface = n;
        }
        pIo->readDimensions();

        // Say sorry to the losers...
  for (int i = 0; i < nInterfaces; i++)
        if (pIo != pInterfaces[i])
            pInterfaces[i]->drawString("Locked by another device.", 1, 0, DebuggerIO::LightRed, DebuggerIO::Black);

        pIo->setCliUpperLimit(1); // Give us room for a status bar on top.
  pIo->setCliLowerLimit(1); // And a status bar on the bottom.
  pIo->enableCli(); // Start CLI mode.

        description += "\n";
        pIo->writeCli(description, DebuggerIO::Yellow, DebuggerIO::Black);

        description.clear();
        description += "Kernel heap ends at ";
        description.append(reinterpret_cast<uintptr_t>(VirtualAddressSpace::getKernelAddressSpace().m_HeapEnd), 16);
        description += "\n";
        pIo->writeCli(description, DebuggerIO::Yellow, DebuggerIO::Black);

        // Main CLI loop.
  bool bKeepGoing = false;
        do
        {
            HugeStaticString command;
            HugeStaticString output;
            // Should we jump directly in to the tracer?
    if (g_Trace.execTrace() != -1)
            {
                bKeepGoing = g_Trace.execute(command, output, state, pIo);
                continue;
            }
            else
                g_Trace.setInterface(nChosenInterface);
            // Clear the top and bottom status lines.
    pIo->drawHorizontalLine(' ', 0, 0, pIo->getWidth()-1, DebuggerIO::White, DebuggerIO::Green);
            pIo->drawHorizontalLine(' ', pIo->getHeight()-1, 0, pIo->getWidth()-1, DebuggerIO::White, DebuggerIO::Green);
            // Write the correct text in the upper status line.
    pIo->drawString("Pedigree debugger", 0, 0, DebuggerIO::White, DebuggerIO::Green);

            bool matchedCommand = false;
            DebuggerCommand *pAutoComplete = 0;
            while(1)
            {
                // Try and get a character from the CLI, passing in a buffer to populate and an
      // autocomplete command for if the user presses TAB (if one is defined).
      if (pIo->readCli(command, pAutoComplete))
                    break; // Command complete, try and parse it.

                // The command wasn't complete - let's parse it and try and get an autocomplete string.
      HugeStaticString str;
                NormalStaticString str2;
                matchedCommand = false;
                for (size_t i = 0; i < nCommands; i++)
                {
                    // TODO: This cast is completly wrong. As I said, don't touch (as in 'write') StaticString's
        //       internal string. The const is not there because I don't like you :-), it is there
        //       because directly writing is not garantueed to work (and it actually will break our code).
        if (matchesCommand(const_cast<char*>(static_cast<const char*>(command)), pCommands[i]))
                    {
                        str2 = static_cast<const char *>(pCommands[i]->getString());
                        str2 += ' ';
                        pCommands[i]->autocomplete(command, str);
                        matchedCommand = true;
                        break;
                    }
                }

                pAutoComplete = 0;
                if (!matchedCommand)
                {
                    int i = -1;
                    while ( (i = getCommandMatchingPrefix(const_cast<char*>(static_cast<const char*>(command)), pCommands, nCommands, i+1)) != -1)
                    {
                        if (!pAutoComplete)
                            pAutoComplete = pCommands[i];
                        str += static_cast<const char*> (pCommands[i]->getString());
                        str += " ";
                    }
                }

                pIo->drawHorizontalLine(' ', pIo->getHeight()-1, 0, pIo->getWidth()-1, DebuggerIO::White, DebuggerIO::Green);
                pIo->drawString(str2, pIo->getHeight()-1, 0, DebuggerIO::Yellow, DebuggerIO::Green);
                pIo->drawString(str, pIo->getHeight()-1, str2.length(), DebuggerIO::White, DebuggerIO::Green);
            }

            // A command was entered.
    bool bValidCommand = false;
            for (size_t i = 0; i < nCommands; i++)
            {
                if (matchesCommand(const_cast<char*>(static_cast<const char*>(command)), pCommands[i]))
                {
                    bKeepGoing = pCommands[i]->execute(command, output, state, pIo);
                    pIo->writeCli(output, DebuggerIO::LightGrey, DebuggerIO::Black);
                    bValidCommand = true;
                }
            }

            if (!bValidCommand)
            {
                pIo->writeCli("Unrecognised command.\n", DebuggerIO::LightGrey, DebuggerIO::Black);
                bKeepGoing = true;
            }

        }
        while (bKeepGoing);
        if(Machine::instance().getNumVga())
            pInterfaces[0]->destroy(); // Causes rememberMode to be called twice.
#ifndef DONT_LOG_TO_SERIAL
        serialIO.destroy();
#endif

        Machine::instance().getKeyboard()->setDebugState(debugState);
    }

    void Debugger::interrupt(size_t interruptNumber, InterruptState &state)
    {
        LargeStaticString description;
        // We switch here on the interrupt number, and dispatch accordingly.
  if (interruptNumber == InterruptManager::instance().getBreakpointInterruptNumber())
        {
            // Here we check to see if the breakpoint was caused by an assertion, or a fatal error.
    if (state.getRegister(0) == ASSERT_FAILED_SENTINEL)
            {
                // As it's an assert or fatal, we assume state.getRegister(1) is a pointer to a descriptive string.
      const char *pDescription = reinterpret_cast<const char*> (state.getRegister(1));
                description += pDescription;
            }
            else
            {
                description += "Breakpoint exception.";
            }
            start(state, description);
        }
        else if (interruptNumber == InterruptManager::instance().getDebugInterruptNumber())
            {
                Processor::setSingleStep(false, state);
                description = "Debug/trap exception";
                start(state, description);
            }
        }