//===----------------------------------------------------------------------===//
//
// 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
//
//===----------------------------------------------------------------------===//
//
// UNSUPPORTED: no-threads
// UNSUPPORTED: c++03

// ALLOW_RETRIES: 3

// <future>

// template <class F, class... Args>
//     future<typename result_of<F(Args...)>::type>
//     async(F&& f, Args&&... args);

// template <class F, class... Args>
//     future<typename result_of<F(Args...)>::type>
//     async(launch policy, F&& f, Args&&... args);


#include <atomic>
#include <cassert>
#include <hip/std/chrono>
#include <future>
#include <memory>
#include <hip/thread>

#include "test_macros.h"

typedef cuda::std::chrono::high_resolution_clock Clock;
typedef cuda::std::chrono::milliseconds ms;

::std::atomic_bool invoked{false};

int f0()
{
    invoked = true;
    hip::this_thread::sleep_for(ms(200));
    return 3;
}

int i = 0;

int& f1()
{
    invoked = true;
    hip::this_thread::sleep_for(ms(200));
    return i;
}

void f2()
{
    invoked = true;
    hip::this_thread::sleep_for(ms(200));
}

::std::unique_ptr<int> f3(int j)
{
    invoked = true;
    hip::this_thread::sleep_for(ms(200));
    return ::std::unique_ptr<int>(new int(j));
}

::std::unique_ptr<int> f4(::std::unique_ptr<int>&& p)
{
    invoked = true;
    hip::this_thread::sleep_for(ms(200));
    return ::std::move(p);
}

void f5(int j)
{
    hip::this_thread::sleep_for(ms(200));
    ((void)j);
    TEST_THROW(j);
}

template <class Ret, class CheckLambda, class... Args>
void test(CheckLambda&& getAndCheckFn, bool IsDeferred, Args&&... args) {
  // Reset global state.
  invoked = false;

  // Create the future and wait
  ::std::future<Ret> f = ::std::async(::std::forward<Args>(args)...);
  hip::this_thread::sleep_for(ms(300));

  // Check that deferred async's have not invoked the function.
  assert(invoked == !IsDeferred);

  // Time the call to f.get() and check that the returned value matches
  // what is expected.
  Clock::time_point t0 = Clock::now();
  assert(getAndCheckFn(f));
  Clock::time_point t1 = Clock::now();

  // If the async is deferred it should take more than 100ms, otherwise
  // it should take less than 100ms.
  if (IsDeferred) {
    assert(t1 - t0 > ms(100));
  } else {
    assert(t1 - t0 < ms(100));
  }
}

int main(int, char**)
{
    // The default launch policy is implementation defined. libc++ defines
    // it to be ::std::launch::async.
    bool DefaultPolicyIsDeferred = false;
    bool DPID = DefaultPolicyIsDeferred;

    ::std::launch AnyPolicy = ::std::launch::async | ::std::launch::deferred;
    LIBCPP_ASSERT(AnyPolicy == ::std::launch::any);

    {
        auto checkInt = [](::std::future<int>& f) { return f.get() == 3; };
        test<int>(checkInt, DPID,  f0);
        test<int>(checkInt, false, ::std::launch::async, f0);
        test<int>(checkInt, true,  ::std::launch::deferred, f0);
        test<int>(checkInt, DPID,  AnyPolicy, f0);
    }
    {
        auto checkIntRef = [&](::std::future<int&>& f) { return &f.get() == &i; };
        test<int&>(checkIntRef, DPID,  f1);
        test<int&>(checkIntRef, false, ::std::launch::async, f1);
        test<int&>(checkIntRef, true,  ::std::launch::deferred, f1);
        test<int&>(checkIntRef, DPID,  AnyPolicy, f1);
    }
    {
        auto checkVoid = [](::std::future<void>& f) { f.get(); return true; };
        test<void>(checkVoid, DPID,  f2);
        test<void>(checkVoid, false, ::std::launch::async, f2);
        test<void>(checkVoid, true,  ::std::launch::deferred, f2);
        test<void>(checkVoid, DPID,  AnyPolicy, f2);
    }
    {
        using Ret = ::std::unique_ptr<int>;
        auto checkUPtr = [](::std::future<Ret>& f) { return *f.get() == 3; };
        test<Ret>(checkUPtr, DPID, f3, 3);
        test<Ret>(checkUPtr, DPID, f4, ::std::unique_ptr<int>(new int(3)));
    }
#ifndef TEST_HAS_NO_EXCEPTIONS
    {
        ::std::future<void> f = ::std::async(f5, 3);
        hip::this_thread::sleep_for(ms(300));
        try { f.get(); assert (false); } catch ( int ) {}
    }
    {
        ::std::future<void> f = ::std::async(::std::launch::deferred, f5, 3);
        hip::this_thread::sleep_for(ms(300));
        try { f.get(); assert (false); } catch ( int ) {}
    }
#endif
    return 0;
}