// Copyright 2018 The Fuchsia Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#include "src/developer/debug/zxdb/client/process_impl.h"

#include <gtest/gtest.h>

#include "src/developer/debug/zxdb/client/mock_remote_api.h"
#include "src/developer/debug/zxdb/client/remote_api_test.h"
#include "src/developer/debug/zxdb/client/session.h"
#include "src/developer/debug/zxdb/client/target_impl.h"
#include "src/developer/debug/zxdb/symbols/elf_symbol.h"
#include "src/developer/debug/zxdb/symbols/mock_module_symbols.h"

namespace zxdb {

namespace {

class ProcessSink : public MockRemoteAPI {
 public:
  ProcessSink() = default;
  ~ProcessSink() = default;

  const debug_ipc::ResumeRequest& resume_request() const { return resume_request_; }
  int resume_count() const { return resume_count_; }

  void Resume(const debug_ipc::ResumeRequest& request,
              fit::callback<void(const Err&, debug_ipc::ResumeReply)> cb) override {
    resume_count_++;
    resume_request_ = request;
    debug_ipc::MessageLoop::Current()->PostTask(
        FROM_HERE, [cb = std::move(cb)]() mutable { cb(Err(), debug_ipc::ResumeReply()); });
  }

  // No-op.
  void Threads(const debug_ipc::ThreadsRequest& request,
               fit::callback<void(const Err&, debug_ipc::ThreadsReply)> cb) override {
    thread_request_made_ = true;
  }

  bool thread_request_made() const { return thread_request_made_; }

 private:
  debug_ipc::ResumeRequest resume_request_;
  int resume_count_ = 0;

  bool thread_request_made_ = false;
};

class ProcessImplTest : public RemoteAPITest {
 public:
  ProcessImplTest() = default;
  ~ProcessImplTest() override = default;

  ProcessSink* sink() { return sink_; }

 private:
  std::unique_ptr<RemoteAPI> GetRemoteAPIImpl() override {
    auto sink = std::make_unique<ProcessSink>();
    sink_ = sink.get();
    return sink;
  }

 private:
  ProcessSink* sink_;  // Owned by the session.
};

}  // namespace

// Tests that the correct threads are resumed after the modules are loaded.
TEST_F(ProcessImplTest, OnModules) {
  constexpr uint64_t kProcessKoid = 1234;
  Process* process = InjectProcess(kProcessKoid);
  ASSERT_TRUE(process);

  EXPECT_FALSE(sink()->thread_request_made());

  debug_ipc::NotifyModules notify;
  notify.process_koid = kProcessKoid;
  notify.modules.resize(1);
  notify.modules[0].name = "comctl32.dll";
  notify.modules[0].base = 0x7685348234;

  constexpr uint64_t kThread1Koid = 237645;
  constexpr uint64_t kThread2Koid = 809712;
  notify.stopped_thread_koids.push_back(kThread1Koid);
  notify.stopped_thread_koids.push_back(kThread2Koid);

  session().DispatchNotifyModules(notify);

  EXPECT_TRUE(sink()->thread_request_made());

  // Should have resumed both of those threads.
  ASSERT_EQ(1, sink()->resume_count());
  const debug_ipc::ResumeRequest& resume = sink()->resume_request();
  EXPECT_EQ(kProcessKoid, resume.process_koid);
  EXPECT_EQ(debug_ipc::ResumeRequest::How::kResolveAndContinue, resume.how);
  EXPECT_EQ(notify.stopped_thread_koids, resume.thread_koids);
}

TEST_F(ProcessImplTest, GetTLSHelpers) {
  constexpr uint64_t kProcessKoid = 1234;
  constexpr uint64_t kThreadKoid = 5678;
  constexpr char kBuildId[] = "abcd";
  constexpr uint64_t kModuleBase = 0x1000;
  Process* process = InjectProcess(kProcessKoid);
  ASSERT_TRUE(process);
  Thread* thread = InjectThread(kProcessKoid, kThreadKoid);
  ASSERT_TRUE(thread);
  SymbolContext symbol_context(kModuleBase);

  auto module_symbols = fxl::MakeRefCounted<MockModuleSymbols>("libc.so");
  session().system().GetSymbols()->InjectModuleForTesting(kBuildId, module_symbols.get());

  std::vector<debug_ipc::Module> modules;
  debug_ipc::Module module;
  module.name = "libc";
  module.base = kModuleBase;
  module.build_id = kBuildId;
  modules.push_back(module);

  TargetImpl* target = session().system().GetTargetImpls()[0];
  target->process()->OnModules(modules, std::vector<uint64_t>());

  constexpr uint64_t kThrdTAddr = 0x1000;
  constexpr uint64_t kLinkMapTlsModIdAddr = 0x2000;
  constexpr uint64_t kTlsBaseAddr = 0x3000;
  constexpr uint64_t kSymSize = 4;

  ElfSymbolRecord thrd_t_record(ElfSymbolType::kNormal, kThrdTAddr, kSymSize, "zxdb.thrd_t");
  ElfSymbolRecord link_map_tls_modid_record(ElfSymbolType::kNormal, kLinkMapTlsModIdAddr, kSymSize,
                                            "zxdb.link_map_tls_modid");
  ElfSymbolRecord tlsbase_record(ElfSymbolType::kNormal, kTlsBaseAddr, kSymSize, "zxdb.tlsbase");

  auto thrd_t_sym = fxl::MakeRefCounted<ElfSymbol>(module_symbols->GetWeakPtr(), thrd_t_record);
  auto link_map_tls_modid_sym =
      fxl::MakeRefCounted<ElfSymbol>(module_symbols->GetWeakPtr(), link_map_tls_modid_record);
  auto tlsbase_sym = fxl::MakeRefCounted<ElfSymbol>(module_symbols->GetWeakPtr(), tlsbase_record);

  module_symbols->AddSymbolLocations(
      Identifier(IdentifierComponent(SpecialIdentifier::kElf, "zxdb.thrd_t")),
      {Location(kThrdTAddr + kModuleBase, FileLine(), 0, symbol_context, thrd_t_sym)});
  module_symbols->AddSymbolLocations(
      Identifier(IdentifierComponent(SpecialIdentifier::kElf, "zxdb.link_map_tls_modid")),
      {Location(kLinkMapTlsModIdAddr + kModuleBase, FileLine(), 0, symbol_context,
                link_map_tls_modid_sym)});
  module_symbols->AddSymbolLocations(
      Identifier(IdentifierComponent(SpecialIdentifier::kElf, "zxdb.tlsbase")),
      {Location(kTlsBaseAddr + kModuleBase, FileLine(), 0, symbol_context, tlsbase_sym)});

  sink()->AddMemory(kThrdTAddr + kModuleBase, {0x1, 0x2, 0x3, 0x4});
  sink()->AddMemory(kLinkMapTlsModIdAddr + kModuleBase, {0x5, 0x6, 0x7, 0x8});
  sink()->AddMemory(kTlsBaseAddr + kModuleBase, {0x9, 0xa, 0xb, 0xc});

  bool called = false;
  bool called_2 = false;
  Process::TLSHelpers helpers;
  Process::TLSHelpers helpers_2;
  Err err;
  Err err_2;
  process->GetTLSHelpers([&called, &helpers, &err](ErrOr<const Process::TLSHelpers*> got) {
    called = true;

    if (got.has_error()) {
      err = got.err();
    } else {
      helpers = *got.value();
    }
  });

  process->GetTLSHelpers([&called_2, &helpers_2, &err_2](ErrOr<const Process::TLSHelpers*> got) {
    called_2 = true;

    if (got.has_error()) {
      err_2 = got.err();
    } else {
      helpers_2 = *got.value();
    }
  });

  EXPECT_FALSE(called);
  EXPECT_FALSE(called_2);
  loop().RunUntilNoTasks();
  EXPECT_TRUE(called);
  EXPECT_TRUE(called_2);
  ASSERT_FALSE(err.has_error()) << err.msg();
  EXPECT_FALSE(err_2.has_error());

  ASSERT_EQ(helpers.thrd_t.size(), kSymSize);
  ASSERT_EQ(helpers.link_map_tls_modid.size(), kSymSize);
  ASSERT_EQ(helpers.tlsbase.size(), kSymSize);

  EXPECT_EQ(0x1, helpers.thrd_t[0]);
  EXPECT_EQ(0x2, helpers.thrd_t[1]);
  EXPECT_EQ(0x3, helpers.thrd_t[2]);
  EXPECT_EQ(0x4, helpers.thrd_t[3]);

  EXPECT_EQ(0x5, helpers.link_map_tls_modid[0]);
  EXPECT_EQ(0x6, helpers.link_map_tls_modid[1]);
  EXPECT_EQ(0x7, helpers.link_map_tls_modid[2]);
  EXPECT_EQ(0x8, helpers.link_map_tls_modid[3]);

  EXPECT_EQ(0x9, helpers.tlsbase[0]);
  EXPECT_EQ(0xa, helpers.tlsbase[1]);
  EXPECT_EQ(0xb, helpers.tlsbase[2]);
  EXPECT_EQ(0xc, helpers.tlsbase[3]);

  EXPECT_EQ(0x1, helpers_2.thrd_t[0]);
  EXPECT_EQ(0x2, helpers_2.thrd_t[1]);
  EXPECT_EQ(0x3, helpers_2.thrd_t[2]);
  EXPECT_EQ(0x4, helpers_2.thrd_t[3]);

  EXPECT_EQ(0x5, helpers_2.link_map_tls_modid[0]);
  EXPECT_EQ(0x6, helpers_2.link_map_tls_modid[1]);
  EXPECT_EQ(0x7, helpers_2.link_map_tls_modid[2]);
  EXPECT_EQ(0x8, helpers_2.link_map_tls_modid[3]);

  EXPECT_EQ(0x9, helpers_2.tlsbase[0]);
  EXPECT_EQ(0xa, helpers_2.tlsbase[1]);
  EXPECT_EQ(0xb, helpers_2.tlsbase[2]);
  EXPECT_EQ(0xc, helpers_2.tlsbase[3]);

  called = false;
  process->GetTLSHelpers([&called, &helpers, &err](ErrOr<const Process::TLSHelpers*> got) {
    called = true;

    if (got.has_error()) {
      err = got.err();
    } else {
      helpers = *got.value();
    }
  });

  EXPECT_TRUE(called);
  ASSERT_FALSE(err.has_error()) << err.msg();

  ASSERT_EQ(helpers.thrd_t.size(), kSymSize);
  ASSERT_EQ(helpers.link_map_tls_modid.size(), kSymSize);
  ASSERT_EQ(helpers.tlsbase.size(), kSymSize);

  EXPECT_EQ(0x1, helpers.thrd_t[0]);
  EXPECT_EQ(0x2, helpers.thrd_t[1]);
  EXPECT_EQ(0x3, helpers.thrd_t[2]);
  EXPECT_EQ(0x4, helpers.thrd_t[3]);

  EXPECT_EQ(0x5, helpers.link_map_tls_modid[0]);
  EXPECT_EQ(0x6, helpers.link_map_tls_modid[1]);
  EXPECT_EQ(0x7, helpers.link_map_tls_modid[2]);
  EXPECT_EQ(0x8, helpers.link_map_tls_modid[3]);

  EXPECT_EQ(0x9, helpers.tlsbase[0]);
  EXPECT_EQ(0xa, helpers.tlsbase[1]);
  EXPECT_EQ(0xb, helpers.tlsbase[2]);
  EXPECT_EQ(0xc, helpers.tlsbase[3]);
}

}  // namespace zxdb