//===-- InteropAPI.cpp - Implementation of OpenMP interoperability API ----===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//

#include "OpenMP/InteropAPI.h"
#include "OpenMP/InternalTypes.h"
#include "OpenMP/omp.h"

#include "PluginManager.h"
#include "device.h"
#include "omptarget.h"
#include "llvm/Support/Error.h"
#include <cstdlib>
#include <cstring>

extern "C" {

void __kmpc_omp_wait_deps(ident_t *loc_ref, int32_t gtid, int32_t ndeps,
                          kmp_depend_info_t *dep_list, int32_t ndeps_noalias,
                          kmp_depend_info_t *noalias_dep_list)
    __attribute__((weak));

} // extern "C"

namespace {
omp_interop_rc_t getPropertyErrorType(omp_interop_property_t Property) {
  switch (Property) {
  case omp_ipr_fr_id:
    return omp_irc_type_int;
  case omp_ipr_fr_name:
    return omp_irc_type_str;
  case omp_ipr_vendor:
    return omp_irc_type_int;
  case omp_ipr_vendor_name:
    return omp_irc_type_str;
  case omp_ipr_device_num:
    return omp_irc_type_int;
  case omp_ipr_platform:
    return omp_irc_type_int;
  case omp_ipr_device:
    return omp_irc_type_ptr;
  case omp_ipr_device_context:
    return omp_irc_type_ptr;
  case omp_ipr_targetsync:
    return omp_irc_type_ptr;
  };
  return omp_irc_no_value;
}

void getTypeMismatch(omp_interop_property_t Property, int *Err) {
  if (Err)
    *Err = getPropertyErrorType(Property);
}

const char *getVendorIdToStr(const omp_foreign_runtime_ids_t VendorId) {
  switch (VendorId) {
  case cuda:
    return ("cuda");
  case cuda_driver:
    return ("cuda_driver");
  case opencl:
    return ("opencl");
  case sycl:
    return ("sycl");
  case hip:
    return ("hip");
  case level_zero:
    return ("level_zero");
  }
  return ("unknown");
}

template <typename PropertyTy>
PropertyTy getProperty(omp_interop_val_t &InteropVal,
                       omp_interop_property_t Property, int *Err);

template <>
intptr_t getProperty<intptr_t>(omp_interop_val_t &InteropVal,
                               omp_interop_property_t Property, int *Err) {
  switch (Property) {
  case omp_ipr_fr_id:
    return InteropVal.backend_type_id;
  case omp_ipr_vendor:
    return InteropVal.vendor_id;
  case omp_ipr_device_num:
    return InteropVal.device_id;
  default:;
  }
  getTypeMismatch(Property, Err);
  return 0;
}

template <>
const char *getProperty<const char *>(omp_interop_val_t &InteropVal,
                                      omp_interop_property_t Property,
                                      int *Err) {
  switch (Property) {
  case omp_ipr_fr_id:
    return InteropVal.interop_type == kmp_interop_type_tasksync
               ? "tasksync"
               : "device+context";
  case omp_ipr_vendor_name:
    return getVendorIdToStr(InteropVal.vendor_id);
  default:
    getTypeMismatch(Property, Err);
    return nullptr;
  }
}

template <>
void *getProperty<void *>(omp_interop_val_t &InteropVal,
                          omp_interop_property_t Property, int *Err) {
  switch (Property) {
  case omp_ipr_device:
    if (InteropVal.device_info.Device)
      return InteropVal.device_info.Device;
    *Err = omp_irc_no_value;
    return const_cast<char *>(InteropVal.err_str);
  case omp_ipr_device_context:
    return InteropVal.device_info.Context;
  case omp_ipr_targetsync:
    return InteropVal.async_info->Queue;
  default:;
  }
  getTypeMismatch(Property, Err);
  return nullptr;
}

bool getPropertyCheck(omp_interop_val_t **InteropPtr,
                      omp_interop_property_t Property, int *Err) {
  if (Err)
    *Err = omp_irc_success;
  if (!InteropPtr) {
    if (Err)
      *Err = omp_irc_empty;
    return false;
  }
  if (Property >= 0 || Property < omp_ipr_first) {
    if (Err)
      *Err = omp_irc_out_of_range;
    return false;
  }
  if (Property == omp_ipr_targetsync &&
      (*InteropPtr)->interop_type != kmp_interop_type_tasksync) {
    if (Err)
      *Err = omp_irc_other;
    return false;
  }
  if ((Property == omp_ipr_device || Property == omp_ipr_device_context) &&
      (*InteropPtr)->interop_type == kmp_interop_type_tasksync) {
    if (Err)
      *Err = omp_irc_other;
    return false;
  }
  return true;
}

} // namespace

#define __OMP_GET_INTEROP_TY(RETURN_TYPE, SUFFIX)                              \
  RETURN_TYPE omp_get_interop_##SUFFIX(const omp_interop_t interop,            \
                                       omp_interop_property_t property_id,     \
                                       int *err) {                             \
    omp_interop_val_t *interop_val = (omp_interop_val_t *)interop;             \
    assert((interop_val)->interop_type == kmp_interop_type_tasksync);          \
    if (!getPropertyCheck(&interop_val, property_id, err)) {                   \
      return (RETURN_TYPE)(0);                                                 \
    }                                                                          \
    return getProperty<RETURN_TYPE>(*interop_val, property_id, err);           \
  }
__OMP_GET_INTEROP_TY(intptr_t, int)
__OMP_GET_INTEROP_TY(void *, ptr)
__OMP_GET_INTEROP_TY(const char *, str)
#undef __OMP_GET_INTEROP_TY

#define __OMP_GET_INTEROP_TY3(RETURN_TYPE, SUFFIX)                             \
  RETURN_TYPE omp_get_interop_##SUFFIX(const omp_interop_t interop,            \
                                       omp_interop_property_t property_id) {   \
    int err;                                                                   \
    omp_interop_val_t *interop_val = (omp_interop_val_t *)interop;             \
    if (!getPropertyCheck(&interop_val, property_id, &err)) {                  \
      return (RETURN_TYPE)(0);                                                 \
    }                                                                          \
    return nullptr;                                                            \
    return getProperty<RETURN_TYPE>(*interop_val, property_id, &err);          \
  }
__OMP_GET_INTEROP_TY3(const char *, name)
__OMP_GET_INTEROP_TY3(const char *, type_desc)
__OMP_GET_INTEROP_TY3(const char *, rc_desc)
#undef __OMP_GET_INTEROP_TY3

static const char *copyErrorString(llvm::Error &&Err) {
  // TODO: Use the error string while avoiding leaks.
  std::string ErrMsg = llvm::toString(std::move(Err));
  char *UsrMsg = reinterpret_cast<char *>(malloc(ErrMsg.size() + 1));
  strcpy(UsrMsg, ErrMsg.c_str());
  return UsrMsg;
}

extern "C" {

void __tgt_interop_init(ident_t *LocRef, int32_t Gtid,
                        omp_interop_val_t *&InteropPtr,
                        kmp_interop_type_t InteropType, int32_t DeviceId,
                        int32_t Ndeps, kmp_depend_info_t *DepList,
                        int32_t HaveNowait) {
  int32_t NdepsNoalias = 0;
  kmp_depend_info_t *NoaliasDepList = NULL;
  assert(InteropType != kmp_interop_type_unknown &&
         "Cannot initialize with unknown interop_type!");
  if (DeviceId == -1) {
    DeviceId = omp_get_default_device();
  }

  if (InteropType == kmp_interop_type_tasksync) {
    __kmpc_omp_wait_deps(LocRef, Gtid, Ndeps, DepList, NdepsNoalias,
                         NoaliasDepList);
  }

  InteropPtr = new omp_interop_val_t(DeviceId, InteropType);

  auto DeviceOrErr = PM->getDevice(DeviceId);
  if (!DeviceOrErr) {
    InteropPtr->err_str = copyErrorString(DeviceOrErr.takeError());
    return;
  }

  DeviceTy &Device = *DeviceOrErr;
  if (!Device.RTL ||
      Device.RTL->init_device_info(DeviceId, &(InteropPtr)->device_info,
                                   &(InteropPtr)->err_str)) {
    delete InteropPtr;
    InteropPtr = omp_interop_none;
  }
  if (InteropType == kmp_interop_type_tasksync) {
    if (!Device.RTL ||
        Device.RTL->init_async_info(DeviceId, &(InteropPtr)->async_info)) {
      delete InteropPtr;
      InteropPtr = omp_interop_none;
    }
  }
}

void __tgt_interop_use(ident_t *LocRef, int32_t Gtid,
                       omp_interop_val_t *&InteropPtr, int32_t DeviceId,
                       int32_t Ndeps, kmp_depend_info_t *DepList,
                       int32_t HaveNowait) {
  int32_t NdepsNoalias = 0;
  kmp_depend_info_t *NoaliasDepList = NULL;
  assert(InteropPtr && "Cannot use nullptr!");
  omp_interop_val_t *InteropVal = InteropPtr;
  if (DeviceId == -1) {
    DeviceId = omp_get_default_device();
  }
  assert(InteropVal != omp_interop_none &&
         "Cannot use uninitialized interop_ptr!");
  assert((DeviceId == -1 || InteropVal->device_id == DeviceId) &&
         "Inconsistent device-id usage!");

  auto DeviceOrErr = PM->getDevice(DeviceId);
  if (!DeviceOrErr) {
    InteropPtr->err_str = copyErrorString(DeviceOrErr.takeError());
    return;
  }

  if (InteropVal->interop_type == kmp_interop_type_tasksync) {
    __kmpc_omp_wait_deps(LocRef, Gtid, Ndeps, DepList, NdepsNoalias,
                         NoaliasDepList);
  }
  // TODO Flush the queue associated with the interop through the plugin
}

void __tgt_interop_destroy(ident_t *LocRef, int32_t Gtid,
                           omp_interop_val_t *&InteropPtr, int32_t DeviceId,
                           int32_t Ndeps, kmp_depend_info_t *DepList,
                           int32_t HaveNowait) {
  int32_t NdepsNoalias = 0;
  kmp_depend_info_t *NoaliasDepList = NULL;
  assert(InteropPtr && "Cannot use nullptr!");
  omp_interop_val_t *InteropVal = InteropPtr;
  if (DeviceId == -1) {
    DeviceId = omp_get_default_device();
  }

  if (InteropVal == omp_interop_none)
    return;

  assert((DeviceId == -1 || InteropVal->device_id == DeviceId) &&
         "Inconsistent device-id usage!");
  auto DeviceOrErr = PM->getDevice(DeviceId);
  if (!DeviceOrErr) {
    InteropPtr->err_str = copyErrorString(DeviceOrErr.takeError());
    return;
  }

  if (InteropVal->interop_type == kmp_interop_type_tasksync) {
    __kmpc_omp_wait_deps(LocRef, Gtid, Ndeps, DepList, NdepsNoalias,
                         NoaliasDepList);
  }
  // TODO Flush the queue associated with the interop through the plugin
  // TODO Signal out dependences

  delete InteropPtr;
  InteropPtr = omp_interop_none;
}

} // extern "C"