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

#include "TestCase.h"
#include "Results.h"
#include "Xcode.h"

using namespace lldb_perf;

TestCase::TestCase()
    : m_debugger(), m_target(), m_process(), m_thread(), m_listener(),
      m_verbose(false), m_step(0) {
  SBDebugger::Initialize();
  SBHostOS::ThreadCreated("<lldb-tester.app.main>");
  m_debugger = SBDebugger::Create(false);
  m_listener = m_debugger.GetListener();
  m_listener.StartListeningForEventClass(
      m_debugger, SBProcess::GetBroadcasterClass(),
      SBProcess::eBroadcastBitStateChanged | SBProcess::eBroadcastBitInterrupt);
}

static std::string GetShortOptionString(struct option *long_options) {
  std::string option_string;
  for (int i = 0; long_options[i].name != NULL; ++i) {
    if (long_options[i].flag == NULL) {
      option_string.push_back((char)long_options[i].val);
      switch (long_options[i].has_arg) {
      default:
      case no_argument:
        break;
      case required_argument:
        option_string.push_back(':');
        break;
      case optional_argument:
        option_string.append(2, ':');
        break;
      }
    }
  }
  return option_string;
}

bool TestCase::Setup(int &argc, const char **&argv) {
  bool done = false;

  struct option *long_options = GetLongOptions();

  if (long_options) {
    std::string short_option_string(GetShortOptionString(long_options));

#if __GLIBC__
    optind = 0;
#else
    optreset = 1;
    optind = 1;
#endif
    while (!done) {
      int long_options_index = -1;
      const int short_option = ::getopt_long_only(
          argc, const_cast<char **>(argv), short_option_string.c_str(),
          long_options, &long_options_index);

      switch (short_option) {
      case 0:
        // Already handled
        break;

      case -1:
        done = true;
        break;

      default:
        done = !ParseOption(short_option, optarg);
        break;
      }
    }
    argc -= optind;
    argv += optind;
  }

  return false;
}

bool TestCase::Launch(lldb::SBLaunchInfo &launch_info) {
  lldb::SBError error;
  m_process = m_target.Launch(launch_info, error);
  if (!error.Success())
    fprintf(stderr, "error: %s\n", error.GetCString());
  if (m_process.IsValid())
    return true;
  return false;
}

bool TestCase::Launch(std::initializer_list<const char *> args) {
  std::vector<const char *> args_vect(args);
  args_vect.push_back(NULL);
  lldb::SBLaunchInfo launch_info((const char **)&args_vect[0]);
  return Launch(launch_info);
}

void TestCase::SetVerbose(bool b) { m_verbose = b; }

bool TestCase::GetVerbose() { return m_verbose; }

void TestCase::Loop() {
  while (true) {
    bool call_test_step = false;
    if (m_process.IsValid()) {
      SBEvent evt;
      m_listener.WaitForEvent(UINT32_MAX, evt);
      StateType state = SBProcess::GetStateFromEvent(evt);
      if (m_verbose)
        printf("event = %s\n", SBDebugger::StateAsCString(state));
      if (SBProcess::GetRestartedFromEvent(evt)) {
        if (m_verbose) {
          const uint32_t num_threads = m_process.GetNumThreads();
          for (auto thread_index = 0; thread_index < num_threads;
               thread_index++) {
            SBThread thread(m_process.GetThreadAtIndex(thread_index));
            SBFrame frame(thread.GetFrameAtIndex(0));
            SBStream strm;
            strm.RedirectToFileHandle(stdout, false);
            frame.GetDescription(strm);
          }
          puts("restarted");
        }
        call_test_step = false;
      } else {
        switch (state) {
        case eStateInvalid:
        case eStateDetached:
        case eStateCrashed:
        case eStateUnloaded:
          break;
        case eStateExited:
          return;
        case eStateConnected:
        case eStateAttaching:
        case eStateLaunching:
        case eStateRunning:
        case eStateStepping:
          call_test_step = false;
          break;

        case eStateStopped:
        case eStateSuspended: {
          call_test_step = true;
          bool fatal = false;
          bool selected_thread = false;
          const uint32_t num_threads = m_process.GetNumThreads();
          for (auto thread_index = 0; thread_index < num_threads;
               thread_index++) {
            SBThread thread(m_process.GetThreadAtIndex(thread_index));
            SBFrame frame(thread.GetFrameAtIndex(0));
            SBStream strm;
            strm.RedirectToFileHandle(stdout, false);
            frame.GetDescription(strm);
            bool select_thread = false;
            StopReason stop_reason = thread.GetStopReason();
            if (m_verbose)
              printf("tid = 0x%llx pc = 0x%llx ", thread.GetThreadID(),
                     frame.GetPC());
            switch (stop_reason) {
            case eStopReasonNone:
              if (m_verbose)
                printf("none\n");
              break;

            case eStopReasonTrace:
              select_thread = true;
              if (m_verbose)
                printf("trace\n");
              break;

            case eStopReasonPlanComplete:
              select_thread = true;
              if (m_verbose)
                printf("plan complete\n");
              break;
            case eStopReasonThreadExiting:
              if (m_verbose)
                printf("thread exiting\n");
              break;
            case eStopReasonExec:
              if (m_verbose)
                printf("exec\n");
              break;
            case eStopReasonInvalid:
              if (m_verbose)
                printf("invalid\n");
              break;
            case eStopReasonException:
              select_thread = true;
              if (m_verbose)
                printf("exception\n");
              fatal = true;
              break;
            case eStopReasonBreakpoint:
              select_thread = true;
              if (m_verbose)
                printf("breakpoint id = %lld.%lld\n",
                       thread.GetStopReasonDataAtIndex(0),
                       thread.GetStopReasonDataAtIndex(1));
              break;
            case eStopReasonWatchpoint:
              select_thread = true;
              if (m_verbose)
                printf("watchpoint id = %lld\n",
                       thread.GetStopReasonDataAtIndex(0));
              break;
            case eStopReasonSignal:
              select_thread = true;
              if (m_verbose)
                printf("signal %d\n", (int)thread.GetStopReasonDataAtIndex(0));
              break;
            }
            if (select_thread && !selected_thread) {
              m_thread = thread;
              selected_thread = m_process.SetSelectedThread(thread);
            }
          }
          if (fatal) {
            if (m_verbose)
              Xcode::RunCommand(m_debugger, "bt all", true);
            exit(1);
          }
        } break;
        }
      }
    } else {
      call_test_step = true;
    }

    if (call_test_step) {
    do_the_call:
      if (m_verbose)
        printf("RUNNING STEP %d\n", m_step);
      ActionWanted action;
      TestStep(m_step, action);
      m_step++;
      SBError err;
      switch (action.type) {
      case ActionWanted::Type::eNone:
        // Just exit and wait for the next event
        break;
      case ActionWanted::Type::eContinue:
        err = m_process.Continue();
        break;
      case ActionWanted::Type::eStepOut:
        if (action.thread.IsValid() == false) {
          if (m_verbose) {
            Xcode::RunCommand(m_debugger, "bt all", true);
            printf("error: invalid thread for step out on step %d\n", m_step);
          }
          exit(501);
        }
        m_process.SetSelectedThread(action.thread);
        action.thread.StepOut();
        break;
      case ActionWanted::Type::eStepOver:
        if (action.thread.IsValid() == false) {
          if (m_verbose) {
            Xcode::RunCommand(m_debugger, "bt all", true);
            printf("error: invalid thread for step over %d\n", m_step);
          }
          exit(500);
        }
        m_process.SetSelectedThread(action.thread);
        action.thread.StepOver();
        break;
      case ActionWanted::Type::eRelaunch:
        if (m_process.IsValid()) {
          m_process.Kill();
          m_process.Clear();
        }
        Launch(action.launch_info);
        break;
      case ActionWanted::Type::eKill:
        if (m_verbose)
          printf("kill\n");
        m_process.Kill();
        return;
      case ActionWanted::Type::eCallNext:
        goto do_the_call;
        break;
      }
    }
  }

  if (GetVerbose())
    printf("I am gonna die at step %d\n", m_step);
}

int TestCase::Run(TestCase &test, int argc, const char **argv) {
  if (test.Setup(argc, argv)) {
    test.Loop();
    Results results;
    test.WriteResults(results);
    return RUN_SUCCESS;
  } else
    return RUN_SETUP_ERROR;
}