//===-- SBProcess.cpp -------------------------------------------*- C++ -*-===//
//
//                     The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//

#include "lldb/API/SBProcess.h"

#include "lldb/lldb-defines.h"
#include "lldb/lldb-types.h"

#include "lldb/Core/Args.h"
#include "lldb/Core/DataBufferHeap.h"
#include "lldb/Core/DataExtractor.h"
#include "lldb/Core/State.h"
#include "lldb/Core/Stream.h"
#include "lldb/Core/StreamFile.h"
#include "lldb/Target/Process.h"
#include "lldb/Target/Thread.h"
#include "lldb/Target/RegisterContext.h"

// Project includes

#include "lldb/API/SBBroadcaster.h"
#include "lldb/API/SBDebugger.h"
#include "lldb/API/SBCommandReturnObject.h"
#include "lldb/API/SBEvent.h"
#include "lldb/API/SBThread.h"
#include "lldb/API/SBStringList.h"

using namespace lldb;
using namespace lldb_private;



SBProcess::SBProcess () :
    m_lldb_object_sp()
{
}


//----------------------------------------------------------------------
// SBProcess constructor
//----------------------------------------------------------------------

SBProcess::SBProcess (const SBProcess& rhs) :
    m_lldb_object_sp (rhs.m_lldb_object_sp)
{
}


SBProcess::SBProcess (const lldb::ProcessSP &process_sp) :
    m_lldb_object_sp (process_sp)
{
}

//----------------------------------------------------------------------
// Destructor
//----------------------------------------------------------------------
SBProcess::~SBProcess()
{
}

void
SBProcess::SetProcess (const ProcessSP &process_sp)
{
    m_lldb_object_sp = process_sp;
}

void
SBProcess::Clear ()
{
    m_lldb_object_sp.reset();
}


bool
SBProcess::IsValid() const
{
    return m_lldb_object_sp.get() != NULL;
}


uint32_t
SBProcess::GetNumThreads ()
{
    if (m_lldb_object_sp)
    {
        const bool can_update = true;
        return m_lldb_object_sp->GetThreadList().GetSize(can_update);
    }
    return 0;
}

SBThread
SBProcess::GetCurrentThread () const
{
    SBThread sb_thread;
    if (m_lldb_object_sp)
        sb_thread.SetThread (m_lldb_object_sp->GetThreadList().GetCurrentThread());
    return sb_thread;
}

SBTarget
SBProcess::GetTarget() const
{
    SBTarget sb_target;
    if (m_lldb_object_sp)
        sb_target = SBDebugger::FindTargetWithLLDBProcess (m_lldb_object_sp);
    return sb_target;
}


size_t
SBProcess::PutSTDIN (const char *src, size_t src_len)
{
    if (m_lldb_object_sp != NULL)
    {
        Error error;
        return m_lldb_object_sp->PutSTDIN (src, src_len, error);
    }
    else
        return 0;
}

size_t
SBProcess::GetSTDOUT (char *dst, size_t dst_len) const
{
    if (m_lldb_object_sp != NULL)
    {
        Error error;
        return m_lldb_object_sp->GetSTDOUT (dst, dst_len, error);
    }
    else
        return 0;
}

size_t
SBProcess::GetSTDERR (char *dst, size_t dst_len) const
{
    if (m_lldb_object_sp != NULL)
    {
        Error error;
        return m_lldb_object_sp->GetSTDERR (dst, dst_len, error);
    }
    else
        return 0;
}

void
SBProcess::ReportCurrentState (const SBEvent &event, FILE *out) const
{
    if (out == NULL)
        return;

    if (m_lldb_object_sp != NULL)
    {
        const StateType event_state = SBProcess::GetStateFromEvent (event);
        char message[1024];
        int message_len = ::snprintf (message,
                                      sizeof (message),
                                      "Process %d %s\n",
                                      m_lldb_object_sp->GetID(),
                                      SBDebugger::StateAsCString (event_state));

        if (message_len > 0)
            ::fwrite (message, 1, message_len, out);
    }
}

void
SBProcess::AppendCurrentStateReport (const SBEvent &event, SBCommandReturnObject &result)
{
    if (m_lldb_object_sp != NULL)
    {
        const StateType event_state = SBProcess::GetStateFromEvent (event);
        char message[1024];
        ::snprintf (message,
                    sizeof (message),
                    "Process %d %s\n",
                    m_lldb_object_sp->GetID(),
                    SBDebugger::StateAsCString (event_state));

        result.AppendMessage (message);
    }
}

bool
SBProcess::SetCurrentThread (const SBThread &thread)
{
    if (m_lldb_object_sp != NULL)
        return m_lldb_object_sp->GetThreadList().SetCurrentThreadByID (thread.GetThreadID());
    return false;
}

bool
SBProcess::SetCurrentThreadByID (uint32_t tid)
{
    if (m_lldb_object_sp != NULL)
        return m_lldb_object_sp->GetThreadList().SetCurrentThreadByID (tid);
    return false;
}

SBThread
SBProcess::GetThreadAtIndex (size_t index)
{
    SBThread thread;
    if (m_lldb_object_sp)
        thread.SetThread (m_lldb_object_sp->GetThreadList().GetThreadAtIndex(index));
    return thread;
}

StateType
SBProcess::GetState ()
{
    if (m_lldb_object_sp != NULL)
        return m_lldb_object_sp->GetState();
    else
        return eStateInvalid;
}


int
SBProcess::GetExitStatus ()
{
    if (m_lldb_object_sp != NULL)
        return m_lldb_object_sp->GetExitStatus ();
    else
        return 0;
}

const char *
SBProcess::GetExitDescription ()
{
    if (m_lldb_object_sp != NULL)
        return m_lldb_object_sp->GetExitDescription ();
    else
        return NULL;
}

lldb::pid_t
SBProcess::GetProcessID ()
{
    if (m_lldb_object_sp)
        return m_lldb_object_sp->GetID();
    else
        return LLDB_INVALID_PROCESS_ID;
}

uint32_t
SBProcess::GetAddressByteSize () const
{
    if (m_lldb_object_sp)
        return m_lldb_object_sp->GetAddressByteSize();
    else
        return 0;
}


void
SBProcess::DisplayThreadsInfo (FILE *out, FILE *err, bool only_threads_with_stop_reason)
{
    if (m_lldb_object_sp != NULL)
    {
        size_t num_thread_infos_dumped = 0;
        size_t num_threads = GetNumThreads();

        if (out == NULL)
            out = SBDebugger::GetOutputFileHandle();

        if (err == NULL)
            err = SBDebugger::GetErrorFileHandle();

        if ((out == NULL) ||(err == NULL))
            return;

        if (num_threads > 0)
        {
            Thread::StopInfo thread_stop_info;
            SBThread curr_thread (m_lldb_object_sp->GetThreadList().GetCurrentThread());
            for (int i = 0; i < num_threads; ++i)
            {
                SBThread thread (m_lldb_object_sp->GetThreadList().GetThreadAtIndex(i));
                if (thread.IsValid())
                {
                    bool is_current_thread = false;
                    StreamFile str (out);
                    if (thread == curr_thread)
                        is_current_thread = true;
                    StopReason thread_stop_reason = eStopReasonNone;
                    if (thread->GetStopInfo (&thread_stop_info))
                    {
                        thread_stop_reason = thread_stop_info.GetStopReason();
                        if (thread_stop_reason == eStopReasonNone)
                        {
                            if (only_threads_with_stop_reason && !is_current_thread)
                                continue;
                        }
                    }
                    ++num_thread_infos_dumped;
                    fprintf (out, "  %c thread #%u: tid = 0x%4.4x, pc = 0x%16.16llx",
                             (is_current_thread ? '*' : ' '),
                             thread->GetIndexID(), thread->GetID(), thread->GetRegisterContext()->GetPC());

                    StackFrameSP frame_sp(thread->GetStackFrameAtIndex (0));
                    if (frame_sp)
                    {
                        SymbolContext sc (frame_sp->GetSymbolContext (eSymbolContextEverything));
                        fprintf (out, ", where = ");
                        sc.DumpStopContext (&str, m_lldb_object_sp.get(), frame_sp->GetPC ());
                    }

                    if (thread_stop_reason != eStopReasonNone)
                    {
                        fprintf (out, ", stop reason = ");
                        thread_stop_info.Dump (&str);
                    }

                    const char *thread_name = thread->GetName();
                    if (thread_name && thread_name[0])
                        fprintf (out, ", thread_name = '%s'", thread_name);

                    fprintf (out, "\n");

                    SBThread sb_thread (thread);
                    sb_thread.DisplayFramesForCurrentContext (out, err, 0, 1, false, 1);
                }
            }
        }
    }
}
bool
SBProcess::WaitUntilProcessHasStopped (SBCommandReturnObject &result)
{
    bool state_changed = false;

    if (IsValid())
    {
        EventSP event_sp;
        StateType state = m_lldb_object_sp->WaitForStateChangedEvents (NULL, event_sp);

        while (StateIsStoppedState (state))
        {
            state = m_lldb_object_sp->WaitForStateChangedEvents (NULL, event_sp);
            SBEvent event (event_sp);
            AppendCurrentStateReport (event, result);
            state_changed = true;
        }
    }
    return state_changed;
}

SBError
SBProcess::Continue ()
{
    SBError sb_error;
    if (IsValid())
        sb_error.SetError(m_lldb_object_sp->Resume());
    else
        sb_error.SetErrorString ("SBProcess is invalid");

    return sb_error;
}


SBError
SBProcess::Destroy ()
{
    SBError sb_error;
    if (m_lldb_object_sp)
        sb_error.SetError(m_lldb_object_sp->Destroy());
    else
        sb_error.SetErrorString ("SBProcess is invalid");

    return sb_error;
}


SBError
SBProcess::Stop ()
{
    SBError sb_error;
    if (IsValid())
        sb_error.SetError (m_lldb_object_sp->Halt());
    else
        sb_error.SetErrorString ("SBProcess is invalid");
    return sb_error;
}

SBError
SBProcess::Kill ()
{
    SBError sb_error;
    if (m_lldb_object_sp)
        sb_error.SetError (m_lldb_object_sp->Destroy());
    else
        sb_error.SetErrorString ("SBProcess is invalid");
    return sb_error;
}


SBError
SBProcess::AttachByName (const char *name, bool wait_for_launch)
{
    SBError sb_error;
    if (m_lldb_object_sp)
        sb_error.SetError (m_lldb_object_sp->Attach (name, wait_for_launch));
    else
        sb_error.SetErrorString ("SBProcess is invalid");
    return sb_error;
}

lldb::pid_t
SBProcess::AttachByPID (lldb::pid_t attach_pid)  // DEPRECATED: will be removed in a few builds in favor of SBError AttachByPID(pid_t)
{
    Attach (attach_pid);
    return GetProcessID();
}

    
SBError
SBProcess::Attach (lldb::pid_t attach_pid)
{
    SBError sb_error;
    if (m_lldb_object_sp)
        sb_error.SetError  (m_lldb_object_sp->Attach (attach_pid));
    else
        sb_error.SetErrorString ("SBProcess is invalid");
    return sb_error;
}

SBError
SBProcess::Detach ()
{
    SBError sb_error;
    if (m_lldb_object_sp)
        sb_error.SetError (m_lldb_object_sp->Detach());
    else
        sb_error.SetErrorString ("SBProcess is invalid");    

    return sb_error;
}

SBError
SBProcess::Signal (int signal)
{
    SBError sb_error;
    if (m_lldb_object_sp)
        sb_error.SetError (m_lldb_object_sp->Signal (signal));
    else
        sb_error.SetErrorString ("SBProcess is invalid");    
    return sb_error;
}

void
SBProcess::ListThreads ()
{    
    FILE *out = SBDebugger::GetOutputFileHandle();
    if (out == NULL)
        return;

    if (m_lldb_object_sp)
    {
        size_t num_threads = GetNumThreads ();
        if (num_threads > 0)
        {
            Thread *cur_thread = m_lldb_object_sp->GetThreadList().GetCurrentThread().get();
            for (int i = 0; i < num_threads; ++i)
            {
                Thread *thread = m_lldb_object_sp->GetThreadList().GetThreadAtIndex(i).get();
                if (thread)
                {
                    bool is_current_thread = false;
                    if (thread == cur_thread)
                        is_current_thread = true;
                    fprintf (out, "  [%u] %c tid = 0x%4.4x, pc = 0x%16.16llx",
                             i,
                             (is_current_thread ? '*' : ' '),
                             thread->GetID(),
                             thread->GetRegisterContext()->GetPC());
                    const char *thread_name = thread->GetName();
                    if (thread_name && thread_name[0])
                        fprintf (out, ", name = %s", thread_name);
                    const char *queue_name = thread->GetQueueName();
                    if (queue_name && queue_name[0])
                        fprintf (out, ", queue = %s", queue_name);
                    fprintf (out, "\n");
                }
            }
        }
    }
}

SBThread
SBProcess::GetThreadByID (tid_t sb_thread_id)
{
    SBThread thread;
    if (m_lldb_object_sp)
        thread.SetThread (m_lldb_object_sp->GetThreadList().FindThreadByID ((tid_t) sb_thread_id));
    return thread;
}

void
SBProcess::Backtrace (bool all_threads, uint32_t num_frames)
{
    if (m_lldb_object_sp)
    {
        if (!all_threads)
        {
            SBDebugger::UpdateCurrentThread (*this);
            SBThread cur_thread = GetCurrentThread();
            if (cur_thread.IsValid())
              cur_thread.Backtrace (num_frames);
        }
        else
        {
            int num_threads = GetNumThreads ();
            for (int i = 0; i < num_threads; ++i)
            {
                SBThread sb_thread = GetThreadAtIndex (i);
                sb_thread.Backtrace (num_frames);
            }
        }
    }
}

StateType
SBProcess::GetStateFromEvent (const SBEvent &event)
{
    return Process::ProcessEventData::GetStateFromEvent (event.GetLLDBObjectPtr());
}


bool
SBProcess::GetRestartedFromEvent (const SBEvent &event)
{
    return Process::ProcessEventData::GetRestartedFromEvent (event.GetLLDBObjectPtr());
}

SBProcess
SBProcess::GetProcessFromEvent (const SBEvent &event)
{
    SBProcess process(Process::ProcessEventData::GetProcessFromEvent (event.GetLLDBObjectPtr()));
    return process;
}


SBBroadcaster
SBProcess::GetBroadcaster () const
{
    SBBroadcaster broadcaster(m_lldb_object_sp.get(), false);
    return broadcaster;
}

lldb_private::Process *
SBProcess::operator->() const
{
    return m_lldb_object_sp.get();
}

size_t
SBProcess::ReadMemory (addr_t addr, void *dst, size_t dst_len, SBError &sb_error)
{
    size_t bytes_read = 0;

    if (IsValid())
    {
        Error error;
        bytes_read = m_lldb_object_sp->ReadMemory (addr, dst, dst_len, error);
        sb_error.SetError (error);
    }
    else
    {
        sb_error.SetErrorString ("SBProcess is invalid");
    }

    return bytes_read;
}

size_t
SBProcess::WriteMemory (addr_t addr, const void *src, size_t src_len, SBError &sb_error)
{
    size_t bytes_written = 0;

    if (IsValid())
    {
        Error error;
        bytes_written = m_lldb_object_sp->WriteMemory (addr, src, src_len, error);
        sb_error.SetError (error);
    }

    return bytes_written;
}

// Mimic shared pointer...
lldb_private::Process *
SBProcess::get() const
{
    return m_lldb_object_sp.get();
}