/*
 * Copyright (C) 2017 The Android Open Source Project
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package art;

import java.util.concurrent.CountDownLatch;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

public class Test923 {
  public static void run() throws Exception {
    doTest();
  }

  private static void doTest() throws Exception {
    // Start a watchdog, to make sure on deadlocks etc the test dies.
    startWatchdog();

    sharedId = createRawMonitor();

    output = new ArrayList<String>(100);

    simpleTests(sharedId);

    for (String s : output) {
      System.out.println(s);
    }
    output.clear();

    threadTests(sharedId);

    destroyRawMonitor(sharedId);
  }

  private static void simpleTests(long id) {
    unlock(id);  // Should fail.

    lock(id);
    unlock(id);
    unlock(id);  // Should fail.

    lock(id);
    lock(id);
    unlock(id);
    unlock(id);
    unlock(id);  // Should fail.

    rawWait(id, 0);   // Should fail.
    rawWait(id, -1);  // Should fail.
    rawWait(id, 1);   // Should fail.

    lock(id);
    rawWait(id, 50);
    unlock(id);
    unlock(id);  // Should fail.

    rawNotify(id);  // Should fail.
    lock(id);
    rawNotify(id);
    unlock(id);
    unlock(id);  // Should fail.

    rawNotifyAll(id);  // Should fail.
    lock(id);
    rawNotifyAll(id);
    unlock(id);
    unlock(id);  // Should fail.
  }

  private static void threadTests(final long id) throws Exception {
    final int N = 10;

    final CountDownLatch waitLatch = new CountDownLatch(N);
    final CountDownLatch wait2Latch = new CountDownLatch(1);

    Runnable r = new Runnable() {
      @Override
      public void run() {
        lock(id);
        waitLatch.countDown();
        rawWait(id, 0);
        firstAwakened = Thread.currentThread();
        appendToLog("Awakened");
        unlock(id);
        wait2Latch.countDown();
      }
    };

    List<Thread> threads = new ArrayList<Thread>();
    for (int i = 0; i < N; i++) {
      Thread t = new Thread(r);
      threads.add(t);
      t.start();
    }

    // Wait till all threads have been started.
    waitLatch.await();

    // Hopefully enough time for all the threads to progress into wait.
    Thread.yield();
    Thread.sleep(500);

    // Wake up one.
    lock(id);
    rawNotify(id);
    unlock(id);

    wait2Latch.await();

    // Wait a little bit more to see stragglers. This is flaky - spurious wakeups could
    // make the test fail.
    Thread.yield();
    Thread.sleep(500);
    if (firstAwakened != null) {
      firstAwakened.join();
    }

    // Wake up everyone else.
    lock(id);
    rawNotifyAll(id);
    unlock(id);

    // Wait for everyone to die.
    for (Thread t : threads) {
      t.join();
    }

    // Check threaded output.
    Iterator<String> it = output.iterator();
    // 1) Start with N locks and Waits.
    {
      int locks = 0;
      int waits = 0;
      for (int i = 0; i < 2*N; i++) {
        String s = it.next();
        if (s.equals("Lock")) {
          locks++;
        } else if (s.equals("Wait")) {
          if (locks <= waits) {
            System.out.println(output);
            throw new RuntimeException("Wait before Lock");
          }
          waits++;
        } else {
          System.out.println(output);
          throw new RuntimeException("Unexpected operation: " + s);
        }
      }
    }

    // 2) Expect Lock + Notify + Unlock.
    expect("Lock", it, output);
    expect("Notify", it, output);
    expect("Unlock", it, output);

    // 3) A single thread wakes up, runs, and dies.
    expect("Awakened", it, output);
    expect("Unlock", it, output);

    // 4) Expect Lock + NotifyAll + Unlock.
    expect("Lock", it, output);
    expect("NotifyAll", it, output);
    expect("Unlock", it, output);

    // 5) N-1 threads wake up, run, and die.
    {
      int expectedUnlocks = 0;
      int ops = 2 * (N-1);
      for (int i = 0; i < ops; i++) {
        String s = it.next();
        if (s.equals("Awakened")) {
          expectedUnlocks++;
        } else if (s.equals("Unlock")) {
          expectedUnlocks--;
          if (expectedUnlocks < 0) {
            System.out.println(output);
            throw new RuntimeException("Unexpected unlock");
          }
        }
      }
    }

    // 6) That should be it.
    if (it.hasNext()) {
      System.out.println(output);
      throw new RuntimeException("Unexpected trailing output, starting with " + it.next());
    }

    output.clear();
    System.out.println("Done");
  }

  private static void expect(String s, Iterator<String> it, List<String> output) {
    String t = it.next();
    if (!s.equals(t)) {
      System.out.println(output);
      throw new RuntimeException("Expected " + s + " but got " + t);
    }
  }

  private static void lock(long id) {
    appendToLog("Lock");
    rawMonitorEnter(id);
  }

  private static void unlock(long id) {
    appendToLog("Unlock");
    try {
      rawMonitorExit(id);
    } catch (RuntimeException e) {
      appendToLog(e.getMessage());
    }
  }

  private static void rawWait(long id, long millis) {
    appendToLog("Wait");
    try {
      rawMonitorWait(id, millis);
    } catch (RuntimeException e) {
      appendToLog(e.getMessage());
    }
  }

  private static void rawNotify(long id) {
    appendToLog("Notify");
    try {
      rawMonitorNotify(id);
    } catch (RuntimeException e) {
      appendToLog(e.getMessage());
    }
  }

  private static void rawNotifyAll(long id) {
    appendToLog("NotifyAll");
    try {
      rawMonitorNotifyAll(id);
    } catch (RuntimeException e) {
      appendToLog(e.getMessage());
    }
  }

  private static synchronized void appendToLog(String s) {
    output.add(s);
  }

  private static void startWatchdog() {
    Runnable r = new Runnable() {
      @Override
      public void run() {
        long start = System.currentTimeMillis();
        // Give it a minute.
        long end = 60 * 1000 + start;
        for (;;) {
          long delta = end - System.currentTimeMillis();
          if (delta <= 0) {
            break;
          }

          try {
            Thread.currentThread().sleep(delta);
          } catch (Exception e) {
          }
        }
        System.out.println("TIMEOUT!");
        System.exit(1);
      }
    };
    Thread t = new Thread(r);
    t.setDaemon(true);
    t.start();
  }

  static volatile long sharedId;
  static List<String> output;
  static Thread firstAwakened;

  private static native long createRawMonitor();
  private static native void destroyRawMonitor(long id);
  private static native void rawMonitorEnter(long id);
  private static native void rawMonitorExit(long id);
  private static native void rawMonitorWait(long id, long millis);
  private static native void rawMonitorNotify(long id);
  private static native void rawMonitorNotifyAll(long id);
}