/**
 ******************************************************************************
 * Xenia : Xbox 360 Emulator Research Project                                 *
 ******************************************************************************
 * Copyright 2013 Ben Vanik. All rights reserved.                             *
 * Released under the BSD license - see LICENSE in the root for more details. *
 ******************************************************************************
 */

#include "xenia/kernel/xmodule.h"

#include "xenia/base/byte_stream.h"
#include "xenia/base/logging.h"
#include "xenia/base/string.h"
#include "xenia/kernel/kernel_state.h"
#include "xenia/kernel/user_module.h"

namespace xe {
namespace kernel {

XModule::XModule(KernelState* kernel_state, ModuleType module_type)
    : XObject(kernel_state, kTypeModule),
      module_type_(module_type),
      processor_module_(nullptr),
      hmodule_ptr_(0) {
  // Loader data (HMODULE)
  hmodule_ptr_ = memory()->SystemHeapAlloc(sizeof(X_LDR_DATA_TABLE_ENTRY));

  // Hijack the checksum field to store our kernel object handle.
  auto ldr_data =
      memory()->TranslateVirtual<X_LDR_DATA_TABLE_ENTRY*>(hmodule_ptr_);
  ldr_data->checksum = handle();
}

XModule::~XModule() {
  kernel_state_->UnregisterModule(this);

  // Destroy the loader data.
  memory()->SystemHeapFree(hmodule_ptr_);
}

bool XModule::Matches(const std::string& name) const {
  if (strcasecmp(xe::find_name_from_path(path_).c_str(), name.c_str()) == 0) {
    return true;
  }
  if (strcasecmp(name_.c_str(), name.c_str()) == 0) {
    return true;
  }
  if (strcasecmp(path_.c_str(), name.c_str()) == 0) {
    return true;
  }
  return false;
}

void XModule::OnLoad() { kernel_state_->RegisterModule(this); }

void XModule::OnUnload() { kernel_state_->UnregisterModule(this); }

X_STATUS XModule::GetSection(const char* name, uint32_t* out_section_data,
                             uint32_t* out_section_size) {
  return X_STATUS_UNSUCCESSFUL;
}

object_ref<XModule> XModule::GetFromHModule(KernelState* kernel_state,
                                            void* hmodule) {
  // Grab the object from our stashed kernel handle
  return kernel_state->object_table()->LookupObject<XModule>(
      GetHandleFromHModule(hmodule));
}

uint32_t XModule::GetHandleFromHModule(void* hmodule) {
  auto ldr_data = reinterpret_cast<X_LDR_DATA_TABLE_ENTRY*>(hmodule);
  return ldr_data->checksum;
}

std::string XModule::NameFromPath(std::string path) {
  std::string name;
  auto last_slash = path.find_last_of('/');
  if (last_slash == path.npos) {
    last_slash = path.find_last_of('\\');
  }
  if (last_slash == path.npos) {
    name = path;
  } else {
    name = path.substr(last_slash + 1);
  }
  auto dot = name.find_last_of('.');
  if (dot != name.npos) {
    name = name.substr(0, dot);
  }

  return name;
}

bool XModule::Save(ByteStream* stream) {
  XELOGD("XModule %.8X (%s)", handle(), path_.c_str());

  stream->Write('XMOD');

  stream->Write(path_);
  stream->Write(hmodule_ptr_);

  if (!SaveObject(stream)) {
    return false;
  }

  return true;
}

object_ref<XModule> XModule::Restore(KernelState* kernel_state,
                                     ByteStream* stream) {
  if (stream->Read<uint32_t>() != 'XMOD') {
    return nullptr;
  }

  auto path = stream->Read<std::string>();
  auto hmodule_ptr = stream->Read<uint32_t>();

  // Can only save user modules at the moment, so just redirect.
  // TODO: Find a way to call RestoreObject here before UserModule::Restore.
  auto module = UserModule::Restore(kernel_state, stream, path);
  if (!module) {
    return nullptr;
  }

  XELOGD("XModule %.8X (%s)", module->handle(), module->path_.c_str());

  module->hmodule_ptr_ = hmodule_ptr;
  return module;
}

}  // namespace kernel
}  // namespace xe