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

// C Includes
#include <stdio.h>
#if HAVE_SYS_TYPES_H
#include <sys/types.h>
#endif

// C++ Includes
#include <cstdlib>
#include <memory>
#include <string>
#include <vector>

// Other libraries and framework includes
#include "llvm/ADT/StringMap.h"
#include "llvm/ADT/StringRef.h"

// Project includes
#include "GoUserExpression.h"

#include "lldb/Core/Module.h"
#include "lldb/Core/StreamFile.h"
#include "lldb/Core/ValueObjectConstResult.h"
#include "lldb/Core/ValueObjectRegister.h"
#include "lldb/Expression/DiagnosticManager.h"
#include "lldb/Expression/ExpressionVariable.h"
#include "lldb/Symbol/GoASTContext.h"
#include "lldb/Symbol/SymbolFile.h"
#include "lldb/Symbol/TypeList.h"
#include "lldb/Symbol/VariableList.h"
#include "lldb/Target/ExecutionContext.h"
#include "lldb/Target/Process.h"
#include "lldb/Target/RegisterContext.h"
#include "lldb/Target/StackFrame.h"
#include "lldb/Target/Target.h"
#include "lldb/Target/ThreadPlan.h"
#include "lldb/Target/ThreadPlanCallUserExpression.h"
#include "lldb/Utility/ConstString.h"
#include "lldb/Utility/DataBufferHeap.h"
#include "lldb/Utility/DataEncoder.h"
#include "lldb/Utility/DataExtractor.h"
#include "lldb/Utility/Log.h"
#include "lldb/Utility/StreamString.h"
#include "lldb/lldb-private.h"

#include "Plugins/ExpressionParser/Go/GoAST.h"
#include "Plugins/ExpressionParser/Go/GoParser.h"

using namespace lldb_private;
using namespace lldb;

class GoUserExpression::GoInterpreter {
public:
  GoInterpreter(ExecutionContext &exe_ctx, const char *expr)
      : m_exe_ctx(exe_ctx), m_frame(exe_ctx.GetFrameSP()), m_parser(expr) {
    if (m_frame) {
      const SymbolContext &ctx =
          m_frame->GetSymbolContext(eSymbolContextFunction);
      ConstString fname = ctx.GetFunctionName();
      if (fname.GetLength() > 0) {
        size_t dot = fname.GetStringRef().find('.');
        if (dot != llvm::StringRef::npos)
          m_package = llvm::StringRef(fname.AsCString(), dot);
      }
    }
  }

  void set_use_dynamic(DynamicValueType use_dynamic) {
    m_use_dynamic = use_dynamic;
  }

  bool Parse();
  lldb::ValueObjectSP Evaluate(ExecutionContext &exe_ctx);
  lldb::ValueObjectSP EvaluateStatement(const GoASTStmt *s);
  lldb::ValueObjectSP EvaluateExpr(const GoASTExpr *e);

  ValueObjectSP VisitBadExpr(const GoASTBadExpr *e) {
    m_parser.GetError(m_error);
    return nullptr;
  }

  ValueObjectSP VisitParenExpr(const GoASTParenExpr *e);
  ValueObjectSP VisitIdent(const GoASTIdent *e);
  ValueObjectSP VisitStarExpr(const GoASTStarExpr *e);
  ValueObjectSP VisitSelectorExpr(const GoASTSelectorExpr *e);
  ValueObjectSP VisitBasicLit(const GoASTBasicLit *e);
  ValueObjectSP VisitIndexExpr(const GoASTIndexExpr *e);
  ValueObjectSP VisitUnaryExpr(const GoASTUnaryExpr *e);
  ValueObjectSP VisitCallExpr(const GoASTCallExpr *e);

  ValueObjectSP VisitTypeAssertExpr(const GoASTTypeAssertExpr *e) {
    return NotImplemented(e);
  }

  ValueObjectSP VisitBinaryExpr(const GoASTBinaryExpr *e) {
    return NotImplemented(e);
  }

  ValueObjectSP VisitArrayType(const GoASTArrayType *e) {
    return NotImplemented(e);
  }

  ValueObjectSP VisitChanType(const GoASTChanType *e) {
    return NotImplemented(e);
  }

  ValueObjectSP VisitCompositeLit(const GoASTCompositeLit *e) {
    return NotImplemented(e);
  }

  ValueObjectSP VisitEllipsis(const GoASTEllipsis *e) {
    return NotImplemented(e);
  }

  ValueObjectSP VisitFuncType(const GoASTFuncType *e) {
    return NotImplemented(e);
  }

  ValueObjectSP VisitFuncLit(const GoASTFuncLit *e) {
    return NotImplemented(e);
  }

  ValueObjectSP VisitInterfaceType(const GoASTInterfaceType *e) {
    return NotImplemented(e);
  }

  ValueObjectSP VisitKeyValueExpr(const GoASTKeyValueExpr *e) {
    return NotImplemented(e);
  }

  ValueObjectSP VisitMapType(const GoASTMapType *e) {
    return NotImplemented(e);
  }

  ValueObjectSP VisitSliceExpr(const GoASTSliceExpr *e) {
    return NotImplemented(e);
  }

  ValueObjectSP VisitStructType(const GoASTStructType *e) {
    return NotImplemented(e);
  }

  CompilerType EvaluateType(const GoASTExpr *e);

  Status &error() { return m_error; }

private:
  std::nullptr_t NotImplemented(const GoASTExpr *e) {
    m_error.SetErrorStringWithFormat("%s node not implemented",
                                     e->GetKindName());
    return nullptr;
  }

  ExecutionContext m_exe_ctx;
  lldb::StackFrameSP m_frame;
  GoParser m_parser;
  DynamicValueType m_use_dynamic;
  Status m_error;
  llvm::StringRef m_package;
  std::vector<std::unique_ptr<GoASTStmt>> m_statements;
};

VariableSP FindGlobalVariable(TargetSP target, llvm::Twine name) {
  ConstString fullname(name.str());
  VariableList variable_list;
  if (!target) {
    return nullptr;
  }
  const uint32_t match_count =
      target->GetImages().FindGlobalVariables(fullname, 1, variable_list);
  if (match_count == 1) {
    return variable_list.GetVariableAtIndex(0);
  }
  return nullptr;
}

CompilerType LookupType(TargetSP target, ConstString name) {
  if (!target)
    return CompilerType();
  SymbolContext sc;
  TypeList type_list;
  llvm::DenseSet<SymbolFile *> searched_symbol_files;
  uint32_t num_matches = target->GetImages().FindTypes(
      sc, name, false, 2, searched_symbol_files, type_list);
  if (num_matches > 0) {
    return type_list.GetTypeAtIndex(0)->GetFullCompilerType();
  }
  return CompilerType();
}

GoUserExpression::GoUserExpression(ExecutionContextScope &exe_scope,
                                   llvm::StringRef expr, llvm::StringRef prefix,
                                   lldb::LanguageType language,
                                   ResultType desired_type,
                                   const EvaluateExpressionOptions &options)
    : UserExpression(exe_scope, expr, prefix, language, desired_type, options) {
}

bool GoUserExpression::Parse(DiagnosticManager &diagnostic_manager,
                             ExecutionContext &exe_ctx,
                             lldb_private::ExecutionPolicy execution_policy,
                             bool keep_result_in_memory,
                             bool generate_debug_info) {
  InstallContext(exe_ctx);
  m_interpreter.reset(new GoInterpreter(exe_ctx, GetUserText()));
  if (m_interpreter->Parse())
    return true;
  const char *error_cstr = m_interpreter->error().AsCString();
  if (error_cstr && error_cstr[0])
    diagnostic_manager.PutString(eDiagnosticSeverityError, error_cstr);
  else
    diagnostic_manager.Printf(eDiagnosticSeverityError,
                              "expression can't be interpreted or run");
  return false;
}

lldb::ExpressionResults
GoUserExpression::DoExecute(DiagnosticManager &diagnostic_manager,
                            ExecutionContext &exe_ctx,
                            const EvaluateExpressionOptions &options,
                            lldb::UserExpressionSP &shared_ptr_to_me,
                            lldb::ExpressionVariableSP &result) {
  Log *log(lldb_private::GetLogIfAnyCategoriesSet(LIBLLDB_LOG_EXPRESSIONS |
                                                  LIBLLDB_LOG_STEP));

  lldb_private::ExecutionPolicy execution_policy = options.GetExecutionPolicy();
  lldb::ExpressionResults execution_results = lldb::eExpressionSetupError;

  Process *process = exe_ctx.GetProcessPtr();
  Target *target = exe_ctx.GetTargetPtr();

  if (target == nullptr || process == nullptr ||
      process->GetState() != lldb::eStateStopped) {
    if (execution_policy == eExecutionPolicyAlways) {
      if (log)
        log->Printf("== [GoUserExpression::Evaluate] Expression may not run, "
                    "but is not constant ==");

      diagnostic_manager.PutString(eDiagnosticSeverityError,
                                   "expression needed to run but couldn't");

      return execution_results;
    }
  }

  m_interpreter->set_use_dynamic(options.GetUseDynamic());
  ValueObjectSP result_val_sp = m_interpreter->Evaluate(exe_ctx);
  Status err = m_interpreter->error();
  m_interpreter.reset();

  if (!result_val_sp) {
    const char *error_cstr = err.AsCString();
    if (error_cstr && error_cstr[0])
      diagnostic_manager.PutString(eDiagnosticSeverityError, error_cstr);
    else
      diagnostic_manager.PutString(eDiagnosticSeverityError,
                                   "expression can't be interpreted or run");
    return lldb::eExpressionDiscarded;
  }
  result.reset(new ExpressionVariable(ExpressionVariable::eKindGo));
  result->m_live_sp = result->m_frozen_sp = result_val_sp;
  result->m_flags |= ExpressionVariable::EVIsProgramReference;
  PersistentExpressionState *pv =
      target->GetPersistentExpressionStateForLanguage(eLanguageTypeGo);
  if (pv != nullptr) {
    result->SetName(pv->GetNextPersistentVariableName(
        *target, pv->GetPersistentVariablePrefix()));
    pv->AddVariable(result);
  }
  return lldb::eExpressionCompleted;
}

bool GoUserExpression::GoInterpreter::Parse() {
  for (std::unique_ptr<GoASTStmt> stmt(m_parser.Statement()); stmt;
       stmt.reset(m_parser.Statement())) {
    if (m_parser.Failed())
      break;
    m_statements.emplace_back(std::move(stmt));
  }
  if (m_parser.Failed() || !m_parser.AtEOF())
    m_parser.GetError(m_error);

  return m_error.Success();
}

ValueObjectSP
GoUserExpression::GoInterpreter::Evaluate(ExecutionContext &exe_ctx) {
  m_exe_ctx = exe_ctx;
  ValueObjectSP result;
  for (const std::unique_ptr<GoASTStmt> &stmt : m_statements) {
    result = EvaluateStatement(stmt.get());
    if (m_error.Fail())
      return nullptr;
  }
  return result;
}

ValueObjectSP GoUserExpression::GoInterpreter::EvaluateStatement(
    const lldb_private::GoASTStmt *stmt) {
  ValueObjectSP result;
  switch (stmt->GetKind()) {
  case GoASTNode::eBlockStmt: {
    const GoASTBlockStmt *block = llvm::cast<GoASTBlockStmt>(stmt);
    for (size_t i = 0; i < block->NumList(); ++i)
      result = EvaluateStatement(block->GetList(i));
    break;
  }
  case GoASTNode::eBadStmt:
    m_parser.GetError(m_error);
    break;
  case GoASTNode::eExprStmt: {
    const GoASTExprStmt *expr = llvm::cast<GoASTExprStmt>(stmt);
    return EvaluateExpr(expr->GetX());
  }
  default:
    m_error.SetErrorStringWithFormat("%s node not supported",
                                     stmt->GetKindName());
  }
  return result;
}

ValueObjectSP GoUserExpression::GoInterpreter::EvaluateExpr(
    const lldb_private::GoASTExpr *e) {
  if (e)
    return e->Visit<ValueObjectSP>(this);
  return ValueObjectSP();
}

ValueObjectSP GoUserExpression::GoInterpreter::VisitParenExpr(
    const lldb_private::GoASTParenExpr *e) {
  return EvaluateExpr(e->GetX());
}

ValueObjectSP GoUserExpression::GoInterpreter::VisitIdent(const GoASTIdent *e) {
  ValueObjectSP val;
  if (m_frame) {
    VariableSP var_sp;
    std::string varname = e->GetName().m_value.str();
    if (varname.size() > 1 && varname[0] == '$') {
      RegisterContextSP reg_ctx_sp = m_frame->GetRegisterContext();
      const RegisterInfo *reg =
          reg_ctx_sp->GetRegisterInfoByName(varname.c_str() + 1);
      if (reg) {
        std::string type;
        switch (reg->encoding) {
        case lldb::eEncodingSint:
          type.append("int");
          break;
        case lldb::eEncodingUint:
          type.append("uint");
          break;
        case lldb::eEncodingIEEE754:
          type.append("float");
          break;
        default:
          m_error.SetErrorString("Invalid register encoding");
          return nullptr;
        }
        switch (reg->byte_size) {
        case 8:
          type.append("64");
          break;
        case 4:
          type.append("32");
          break;
        case 2:
          type.append("16");
          break;
        case 1:
          type.append("8");
          break;
        default:
          m_error.SetErrorString("Invalid register size");
          return nullptr;
        }
        ValueObjectSP regVal = ValueObjectRegister::Create(
            m_frame.get(), reg_ctx_sp, reg->kinds[eRegisterKindLLDB]);
        CompilerType goType =
            LookupType(m_frame->CalculateTarget(), ConstString(type));
        if (regVal) {
          regVal = regVal->Cast(goType);
          return regVal;
        }
      }
      m_error.SetErrorString("Invalid register name");
      return nullptr;
    }
    VariableListSP var_list_sp(m_frame->GetInScopeVariableList(false));
    if (var_list_sp) {
      var_sp = var_list_sp->FindVariable(ConstString(varname));
      if (var_sp)
        val = m_frame->GetValueObjectForFrameVariable(var_sp, m_use_dynamic);
      else {
        // When a variable is on the heap instead of the stack, go records a
        // variable '&x' instead of 'x'.
        var_sp = var_list_sp->FindVariable(ConstString("&" + varname));
        if (var_sp) {
          val = m_frame->GetValueObjectForFrameVariable(var_sp, m_use_dynamic);
          if (val)
            val = val->Dereference(m_error);
          if (m_error.Fail())
            return nullptr;
        }
      }
    }
    if (!val) {
      m_error.Clear();
      TargetSP target = m_frame->CalculateTarget();
      if (!target) {
        m_error.SetErrorString("No target");
        return nullptr;
      }
      var_sp =
          FindGlobalVariable(target, m_package + "." + e->GetName().m_value);
      if (var_sp)
        return m_frame->TrackGlobalVariable(var_sp, m_use_dynamic);
    }
  }
  if (!val)
    m_error.SetErrorStringWithFormat("Unknown variable %s",
                                     e->GetName().m_value.str().c_str());
  return val;
}

ValueObjectSP
GoUserExpression::GoInterpreter::VisitStarExpr(const GoASTStarExpr *e) {
  ValueObjectSP target = EvaluateExpr(e->GetX());
  if (!target)
    return nullptr;
  return target->Dereference(m_error);
}

ValueObjectSP GoUserExpression::GoInterpreter::VisitSelectorExpr(
    const lldb_private::GoASTSelectorExpr *e) {
  ValueObjectSP target = EvaluateExpr(e->GetX());
  if (target) {
    if (target->GetCompilerType().IsPointerType()) {
      target = target->Dereference(m_error);
      if (m_error.Fail())
        return nullptr;
    }
    ConstString field(e->GetSel()->GetName().m_value);
    ValueObjectSP result = target->GetChildMemberWithName(field, true);
    if (!result)
      m_error.SetErrorStringWithFormat("Unknown child %s", field.AsCString());
    return result;
  }
  if (const GoASTIdent *package = llvm::dyn_cast<GoASTIdent>(e->GetX())) {
    if (VariableSP global = FindGlobalVariable(
            m_exe_ctx.GetTargetSP(), package->GetName().m_value + "." +
                                         e->GetSel()->GetName().m_value)) {
      if (m_frame) {
        m_error.Clear();
        return m_frame->GetValueObjectForFrameVariable(global, m_use_dynamic);
      }
    }
  }
  if (const GoASTBasicLit *packageLit =
          llvm::dyn_cast<GoASTBasicLit>(e->GetX())) {
    if (packageLit->GetValue().m_type == GoLexer::LIT_STRING) {
      std::string value = packageLit->GetValue().m_value.str();
      value = value.substr(1, value.size() - 2);
      if (VariableSP global = FindGlobalVariable(
              m_exe_ctx.GetTargetSP(),
              value + "." + e->GetSel()->GetName().m_value)) {
        if (m_frame) {
          m_error.Clear();
          return m_frame->TrackGlobalVariable(global, m_use_dynamic);
        }
      }
    }
  }
  // EvaluateExpr should have already set m_error.
  return target;
}

ValueObjectSP GoUserExpression::GoInterpreter::VisitBasicLit(
    const lldb_private::GoASTBasicLit *e) {
  std::string value = e->GetValue().m_value.str();
  if (e->GetValue().m_type != GoLexer::LIT_INTEGER) {
    m_error.SetErrorStringWithFormat("Unsupported literal %s", value.c_str());
    return nullptr;
  }
  errno = 0;
  int64_t intvalue = strtol(value.c_str(), nullptr, 0);
  if (errno != 0) {
    m_error.SetErrorToErrno();
    return nullptr;
  }
  DataBufferSP buf(new DataBufferHeap(sizeof(intvalue), 0));
  TargetSP target = m_exe_ctx.GetTargetSP();
  if (!target) {
    m_error.SetErrorString("No target");
    return nullptr;
  }
  ByteOrder order = target->GetArchitecture().GetByteOrder();
  uint8_t addr_size = target->GetArchitecture().GetAddressByteSize();
  DataEncoder enc(buf, order, addr_size);
  enc.PutU64(0, static_cast<uint64_t>(intvalue));
  DataExtractor data(buf, order, addr_size);

  CompilerType type = LookupType(target, ConstString("int64"));
  return ValueObject::CreateValueObjectFromData(llvm::StringRef(), data,
                                                m_exe_ctx, type);
}

ValueObjectSP GoUserExpression::GoInterpreter::VisitIndexExpr(
    const lldb_private::GoASTIndexExpr *e) {
  ValueObjectSP target = EvaluateExpr(e->GetX());
  if (!target)
    return nullptr;
  ValueObjectSP index = EvaluateExpr(e->GetIndex());
  if (!index)
    return nullptr;
  bool is_signed;
  if (!index->GetCompilerType().IsIntegerType(is_signed)) {
    m_error.SetErrorString("Unsupported index");
    return nullptr;
  }
  size_t idx;
  if (is_signed)
    idx = index->GetValueAsSigned(0);
  else
    idx = index->GetValueAsUnsigned(0);
  if (GoASTContext::IsGoSlice(target->GetCompilerType())) {
    target = target->GetStaticValue();
    ValueObjectSP cap =
        target->GetChildMemberWithName(ConstString("cap"), true);
    if (cap) {
      uint64_t capval = cap->GetValueAsUnsigned(0);
      if (idx >= capval) {
        m_error.SetErrorStringWithFormat("Invalid index %" PRIu64
                                         " , cap = %" PRIu64,
                                         uint64_t(idx), capval);
        return nullptr;
      }
    }
    target = target->GetChildMemberWithName(ConstString("array"), true);
    if (target && m_use_dynamic != eNoDynamicValues) {
      ValueObjectSP dynamic = target->GetDynamicValue(m_use_dynamic);
      if (dynamic)
        target = dynamic;
    }
    if (!target)
      return nullptr;
    return target->GetSyntheticArrayMember(idx, true);
  }
  return target->GetChildAtIndex(idx, true);
}

ValueObjectSP
GoUserExpression::GoInterpreter::VisitUnaryExpr(const GoASTUnaryExpr *e) {
  ValueObjectSP x = EvaluateExpr(e->GetX());
  if (!x)
    return nullptr;
  switch (e->GetOp()) {
  case GoLexer::OP_AMP: {
    CompilerType type = x->GetCompilerType().GetPointerType();
    uint64_t address = x->GetAddressOf();
    return ValueObject::CreateValueObjectFromAddress(llvm::StringRef(), address,
                                                     m_exe_ctx, type);
  }
  case GoLexer::OP_PLUS:
    return x;
  default:
    m_error.SetErrorStringWithFormat(
        "Operator %s not supported",
        GoLexer::LookupToken(e->GetOp()).str().c_str());
    return nullptr;
  }
}

CompilerType GoUserExpression::GoInterpreter::EvaluateType(const GoASTExpr *e) {
  TargetSP target = m_exe_ctx.GetTargetSP();
  if (auto *id = llvm::dyn_cast<GoASTIdent>(e)) {
    CompilerType result =
        LookupType(target, ConstString(id->GetName().m_value));
    if (result.IsValid())
      return result;
    std::string fullname = (m_package + "." + id->GetName().m_value).str();
    result = LookupType(target, ConstString(fullname));
    if (!result)
      m_error.SetErrorStringWithFormat("Unknown type %s", fullname.c_str());
    return result;
  }
  if (auto *sel = llvm::dyn_cast<GoASTSelectorExpr>(e)) {
    std::string package;
    if (auto *pkg_node = llvm::dyn_cast<GoASTIdent>(sel->GetX())) {
      package = pkg_node->GetName().m_value.str();
    } else if (auto *str_node = llvm::dyn_cast<GoASTBasicLit>(sel->GetX())) {
      if (str_node->GetValue().m_type == GoLexer::LIT_STRING) {
        package = str_node->GetValue().m_value.substr(1).str();
        package.resize(package.length() - 1);
      }
    }
    if (package.empty()) {
      m_error.SetErrorStringWithFormat("Invalid %s in type expression",
                                       sel->GetX()->GetKindName());
      return CompilerType();
    }
    std::string fullname =
        (package + "." + sel->GetSel()->GetName().m_value).str();
    CompilerType result = LookupType(target, ConstString(fullname));
    if (!result)
      m_error.SetErrorStringWithFormat("Unknown type %s", fullname.c_str());
    return result;
  }
  if (auto *star = llvm::dyn_cast<GoASTStarExpr>(e)) {
    CompilerType elem = EvaluateType(star->GetX());
    return elem.GetPointerType();
  }
  if (auto *paren = llvm::dyn_cast<GoASTParenExpr>(e))
    return EvaluateType(paren->GetX());
  if (auto *array = llvm::dyn_cast<GoASTArrayType>(e)) {
    CompilerType elem = EvaluateType(array->GetElt());
  }

  m_error.SetErrorStringWithFormat("Invalid %s in type expression",
                                   e->GetKindName());
  return CompilerType();
}

ValueObjectSP GoUserExpression::GoInterpreter::VisitCallExpr(
    const lldb_private::GoASTCallExpr *e) {
  ValueObjectSP x = EvaluateExpr(e->GetFun());
  if (x || e->NumArgs() != 1) {
    m_error.SetErrorStringWithFormat("Code execution not supported");
    return nullptr;
  }
  m_error.Clear();
  CompilerType type = EvaluateType(e->GetFun());
  if (!type) {
    return nullptr;
  }
  ValueObjectSP value = EvaluateExpr(e->GetArgs(0));
  if (!value)
    return nullptr;
  // TODO: Handle special conversions
  return value->Cast(type);
}

GoPersistentExpressionState::GoPersistentExpressionState()
    : PersistentExpressionState(eKindGo) {}

void GoPersistentExpressionState::RemovePersistentVariable(
    lldb::ExpressionVariableSP variable) {
  RemoveVariable(variable);

  const char *name = variable->GetName().AsCString();

  if (*(name++) != '$')
    return;
  if (*(name++) != 'g')
    return;
  if (*(name++) != 'o')
    return;

  if (strtoul(name, nullptr, 0) == m_next_persistent_variable_id - 1)
    m_next_persistent_variable_id--;
}