//
// Copyright 2012 Francisco Jerez
//
// Permission is hereby granted, free of charge, to any person obtaining a
// copy of this software and associated documentation files (the "Software"),
// to deal in the Software without restriction, including without limitation
// the rights to use, copy, modify, merge, publish, distribute, sublicense,
// and/or sell copies of the Software, and to permit persons to whom the
// Software is furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in
// all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
// THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
// OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
// ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
// OTHER DEALINGS IN THE SOFTWARE.
//

#include "api/util.hpp"
#include "core/event.hpp"

using namespace clover;

CLOVER_API cl_event
clCreateUserEvent(cl_context d_ctx, cl_int *r_errcode) try {
   auto &ctx = obj(d_ctx);

   ret_error(r_errcode, CL_SUCCESS);
   return desc(new soft_event(ctx, {}, false));

} catch (error &e) {
   ret_error(r_errcode, e);
   return NULL;
}

CLOVER_API cl_int
clSetUserEventStatus(cl_event d_ev, cl_int status) try {
   auto &sev = obj<soft_event>(d_ev);

   if (status > 0)
      return CL_INVALID_VALUE;

   if (sev.status() <= 0)
      return CL_INVALID_OPERATION;

   if (status)
      sev.abort(status);
   else
      sev.trigger();

   return CL_SUCCESS;

} catch (error &e) {
   return e.get();
}

CLOVER_API cl_int
clWaitForEvents(cl_uint num_evs, const cl_event *d_evs) try {
   auto evs = objs(d_evs, num_evs);

   for (auto &ev : evs) {
      if (ev.context() != evs.front().context())
         throw error(CL_INVALID_CONTEXT);

      if (ev.status() < 0)
         throw error(CL_EXEC_STATUS_ERROR_FOR_EVENTS_IN_WAIT_LIST);
   }

   // Create a temporary soft event that depends on all the events in
   // the wait list
   auto sev = create<soft_event>(evs.front().context(), evs, true);

   // ...and wait on it.
   sev().wait();

   return CL_SUCCESS;

} catch (error &e) {
   return e.get();
}

CLOVER_API cl_int
clGetEventInfo(cl_event d_ev, cl_event_info param,
               size_t size, void *r_buf, size_t *r_size) try {
   property_buffer buf { r_buf, size, r_size };
   auto &ev = obj(d_ev);

   switch (param) {
   case CL_EVENT_COMMAND_QUEUE:
      buf.as_scalar<cl_command_queue>() = desc(ev.queue());
      break;

   case CL_EVENT_CONTEXT:
      buf.as_scalar<cl_context>() = desc(ev.context());
      break;

   case CL_EVENT_COMMAND_TYPE:
      buf.as_scalar<cl_command_type>() = ev.command();
      break;

   case CL_EVENT_COMMAND_EXECUTION_STATUS:
      buf.as_scalar<cl_int>() = ev.status();
      break;

   case CL_EVENT_REFERENCE_COUNT:
      buf.as_scalar<cl_uint>() = ev.ref_count();
      break;

   default:
      throw error(CL_INVALID_VALUE);
   }

   return CL_SUCCESS;

} catch (error &e) {
   return e.get();
}

CLOVER_API cl_int
clSetEventCallback(cl_event d_ev, cl_int type,
                   void (CL_CALLBACK *pfn_notify)(cl_event, cl_int, void *),
                   void *user_data) try {
   auto &ev = obj(d_ev);

   if (!pfn_notify || type != CL_COMPLETE)
      throw error(CL_INVALID_VALUE);

   // Create a temporary soft event that depends on ev, with
   // pfn_notify as completion action.
   create<soft_event>(ev.context(), ref_vector<event> { ev }, true,
                      [=, &ev](event &) {
                         ev.wait();
                         pfn_notify(desc(ev), ev.status(), user_data);
                      });

   return CL_SUCCESS;

} catch (error &e) {
   return e.get();
}

CLOVER_API cl_int
clRetainEvent(cl_event d_ev) try {
   obj(d_ev).retain();
   return CL_SUCCESS;

} catch (error &e) {
   return e.get();
}

CLOVER_API cl_int
clReleaseEvent(cl_event d_ev) try {
   if (obj(d_ev).release())
      delete pobj(d_ev);

   return CL_SUCCESS;

} catch (error &e) {
   return e.get();
}

CLOVER_API cl_int
clEnqueueMarker(cl_command_queue d_q, cl_event *rd_ev) try {
   auto &q = obj(d_q);

   if (!rd_ev)
      throw error(CL_INVALID_VALUE);

   *rd_ev = desc(new hard_event(q, CL_COMMAND_MARKER, {}));

   return CL_SUCCESS;

} catch (error &e) {
   return e.get();
}

CLOVER_API cl_int
clEnqueueMarkerWithWaitList(cl_command_queue d_q, cl_uint num_deps,
                            const cl_event *d_deps, cl_event *rd_ev) try {
   auto &q = obj(d_q);
   auto deps = objs<wait_list_tag>(d_deps, num_deps);

   for (auto &ev : deps) {
      if (ev.context() != q.context())
         throw error(CL_INVALID_CONTEXT);
   }

   // Create a hard event that depends on the events in the wait list:
   // previous commands in the same queue are implicitly serialized
   // with respect to it -- hard events always are.
   auto hev = create<hard_event>(q, CL_COMMAND_MARKER, deps);

   ret_object(rd_ev, hev);
   return CL_SUCCESS;

} catch (error &e) {
   return e.get();
}

CLOVER_API cl_int
clEnqueueBarrier(cl_command_queue d_q) try {
   obj(d_q);

   // No need to do anything, q preserves data ordering strictly.

   return CL_SUCCESS;

} catch (error &e) {
   return e.get();
}

CLOVER_API cl_int
clEnqueueBarrierWithWaitList(cl_command_queue d_q, cl_uint num_deps,
                             const cl_event *d_deps, cl_event *rd_ev) try {
   auto &q = obj(d_q);
   auto deps = objs<wait_list_tag>(d_deps, num_deps);

   for (auto &ev : deps) {
      if (ev.context() != q.context())
         throw error(CL_INVALID_CONTEXT);
   }

   // Create a hard event that depends on the events in the wait list:
   // subsequent commands in the same queue will be implicitly
   // serialized with respect to it -- hard events always are.
   auto hev = create<hard_event>(q, CL_COMMAND_BARRIER, deps);

   ret_object(rd_ev, hev);
   return CL_SUCCESS;

} catch (error &e) {
   return e.get();
}

CLOVER_API cl_int
clEnqueueWaitForEvents(cl_command_queue d_q, cl_uint num_evs,
                       const cl_event *d_evs) try {
   // The wait list is mandatory for clEnqueueWaitForEvents().
   objs(d_evs, num_evs);

   return clEnqueueBarrierWithWaitList(d_q, num_evs, d_evs, NULL);

} catch (error &e) {
   return e.get();
}

CLOVER_API cl_int
clGetEventProfilingInfo(cl_event d_ev, cl_profiling_info param,
                        size_t size, void *r_buf, size_t *r_size) try {
   property_buffer buf { r_buf, size, r_size };
   hard_event &hev = dynamic_cast<hard_event &>(obj(d_ev));

   if (hev.status() != CL_COMPLETE)
      throw error(CL_PROFILING_INFO_NOT_AVAILABLE);

   switch (param) {
   case CL_PROFILING_COMMAND_QUEUED:
      buf.as_scalar<cl_ulong>() = hev.time_queued();
      break;

   case CL_PROFILING_COMMAND_SUBMIT:
      buf.as_scalar<cl_ulong>() = hev.time_submit();
      break;

   case CL_PROFILING_COMMAND_START:
      buf.as_scalar<cl_ulong>() = hev.time_start();
      break;

   case CL_PROFILING_COMMAND_END:
      buf.as_scalar<cl_ulong>() = hev.time_end();
      break;

   default:
      throw error(CL_INVALID_VALUE);
   }

   return CL_SUCCESS;

} catch (std::bad_cast &e) {
   return CL_PROFILING_INFO_NOT_AVAILABLE;

} catch (lazy<cl_ulong>::undefined_error &e) {
   return CL_PROFILING_INFO_NOT_AVAILABLE;

} catch (error &e) {
   return e.get();
}

CLOVER_API cl_int
clFinish(cl_command_queue d_q) try {
   auto &q = obj(d_q);

   // Create a temporary hard event -- it implicitly depends on all
   // the previously queued hard events.
   auto hev = create<hard_event>(q, 0, ref_vector<event> {});

   // And wait on it.
   hev().wait();

   return CL_SUCCESS;

} catch (error &e) {
   return e.get();
}
