package org.webslinger.util.tests;

 import java.io.IOException;

 import java.util.concurrent.Delayed;

 import java.util.concurrent.DelayQueue;

 import java.util.concurrent.CountDownLatch;

 import java.util.concurrent.TimeUnit;

 import java.util.concurrent.atomic.AtomicBoolean;

 import java.util.concurrent.atomic.AtomicInteger;

 import java.util.concurrent.atomic.AtomicReference;

 import org.webslinger.httpunit.WebslingerTestCase;

 import org.webslinger.util.TTLObject;

 public class TestTTLObject extends WebslingerTestCase {

     static {

         TTLObject.setDefaultTTLForClass(TTLObjectTestTTLObject.class, 100);

     }

     protected final AtomicInteger doneCount = new AtomicInteger();

     protected final AtomicReference<Thread> lastLoadThread = new AtomicReference<Thread>();

     protected final AtomicBoolean callSetObject = new AtomicBoolean();

     protected final AtomicReference<Thrower> throwException = new AtomicReference<Thrower>();

     private final class TTLObjectTestTTLObject extends TTLObject<String> {

         protected boolean getForeground() {

             return false;

         }

         protected String load(String old, int serial) throws IOException {

             lastLoadThread.set(Thread.currentThread());

             try {

                 Thrower thrower = (Thrower) throwException.get();

                 if (thrower != null) {

                     throwException.compareAndSet(thrower, null);

                     thrower.throwException();

                 }

                 long end = System.nanoTime() + sleepTime * 1000000;

                 while (System.nanoTime() <= end) {

                     Thread.sleep(10);

                     if (checkSerial(serial)) break;

                 }

             } catch (InterruptedException e) {

                 throw (IOException) new IOException(e.getMessage()).initCause(e);

             } finally {

                 doneCount.incrementAndGet();

             }

             return loadData;

         }

         public void set(String value) throws IOException {

             setObject(value);

         }

     }

     protected final TTLObjectTestTTLObject object = new TTLObjectTestTTLObject();

     protected String loadData;

     protected long sleepTime;

     protected final DelayQueue<DelayedItem> setObjectQueue = new DelayQueue<DelayedItem>();

     protected volatile boolean quit = false;

     protected Thread thread;

     public TestTTLObject(String name) {

         super(name);

     }

     protected void setUp() throws InterruptedException {

         final CountDownLatch latch = new CountDownLatch(1);

         thread = new Thread() {

             public void run() {

                 latch.countDown();

                 while (!quit) {

                     try {

                         object.set(setObjectQueue.take().value);

                     } catch (InterruptedException e) {

                     } catch (IOException e) {

                     }

                 }

             }

         };

         thread.setDaemon(true);

         thread.start();

         latch.await();

     }

     protected void tearDown() throws InterruptedException {

         quit = true;

         thread.interrupt();

         thread.join();

         doneCount.set(0);

         lastLoadThread.set(null);

         callSetObject.set(false);

         throwException.set(null);

     }

     protected void assertGetObject(String label, String wantedData, int wantedLoadCount, int wantedDoneCount, long minTime, long maxTime) throws Exception {

         long t1 = System.nanoTime();

         assertEquals(label + ": data", wantedData, object.getObject());

         assertEquals(label + ": doneCount", wantedDoneCount, doneCount.get());

         long t2 = System.nanoTime();

         long time = t2 - t1;

         assertTrue(label + ": long enough(" + time + " >= " + minTime + ")", time >= minTime);

         assertTrue(label + ": quick enough(" + time + " <= " + maxTime + ")", time <= maxTime);

     }

     public void testGetTTL() throws Exception {

         try {

             new TTLObject() {

                 protected Object load(Object old) throws IOException {

                     return old;

                 }

             }.getObject();

             fail("Did not detect a missing default ttl");

         } catch (IllegalArgumentException e) {

             // ignore

         }

         try {

             new TTLObject() {

                 protected long getTTL() {

                     return 1000;

                 }

                 protected Object load(Object old) throws IOException {

                     return old;

                 }

             }.getObject();

         } catch (IllegalArgumentException e) {

             fail("Thought the ttl was missing");

             // ignore

         }

     }

     public void testGet() throws Exception {

         loadData = "1";

         sleepTime = 1000;

         // 

         assertGetObject("Fetch data first time, blocking", loadData, 1, 1, 950000000, 1200000000);

         loadData = "2";

         sleepTime = 0;

         assertGetObject("Not called all the time", "1", 1, 1, 0, 100000000);

         Thread.sleep(300);

         assertGetObject("Stale data, starting regen", "1", 1, 1, 0, 100000000);

         Thread.sleep(300);

         assertGetObject("Refreshed with old data", loadData, 2, 2, 0, 100000000);

         loadData = "3";

         sleepTime = 1000;

         Thread.sleep(200);

         assertGetObject("Load called, serve stale data", "2", 3, 2, 0, 100000000);

         Thread.sleep(200);

         assertGetObject("Load called, serve stale data", "2", 3, 2, 0, 100000000);

         Thread.sleep(200);

         assertGetObject("Load called, serve stale data", "2", 3, 2, 0, 100000000);

         Thread.sleep(800);

         assertGetObject("Serve new data", loadData, 3, 3, 0, 100000000);

         object.set("a");

         assertGetObject("Serve set data(a)", "a", 3, 3, 0, 100000000);

         Thread.sleep(500);

         object.set("b");

         assertGetObject("Serve set data(b)", "b", 3, 3, 0, 100000000);

     }

     public void testSet() throws Exception {

         object.set("set");

         assertEquals("data after set", "set", object.getObject());

         assertEquals("no dones", 0, doneCount.get());

         loadData = "1";

         Thread.sleep(200);

         assertGetObject("SET: stale, start load", "set", 1, 0, 0, 100000000);

         Thread.sleep(200);

         loadData = "2";

         sleepTime = 500;

         assertGetObject("SET: valid, process load, schedule pulse 1", "1", 1, 1, 0, 100000000);

         Thread.sleep(100);

         assertGetObject("SET: stale 1", "1", 1, 1, 0, 100000000);

         Thread.sleep(100);

         assertGetObject("SET: stale 2", "1", 1, 1, 0, 100000000);

         Thread.sleep(100);

         assertGetObject("SET: stale 3", "1", 1, 1, 0, 100000000);

         Thread.sleep(600);

         assertGetObject("SET: valid, process load, schedule pulse 2", "2", 2, 2, 0, 100000000);

     }

     public void testSetGetAbort() throws Exception {

         loadData = "1";

         sleepTime = 1000;

         // 

         setObjectQueue.offer(new DelayedItem(300, "override"));

         assertGetObject("Fetch data first time, blocking/setting", "override", 1, 1, 250000000, 400000000);

     }

     public void testThrowException() throws Exception {

         loadData = "1";

         sleepTime = 100;

         throwException.set(new Thrower() {

             public void throwException() throws IOException {

                 throw new IOException("exc1");

             }

         });

         try {

             assertGetObject("Fetch data first time, throw exception", "override", 1, 1, 0, 200000000);

             fail("No exception thrown");

         } catch (IOException e) {

             assertEquals("correct exception thrown", "exc1", e.getMessage());

         }

         loadData = "2";

         sleepTime = 100;

         assertGetObject("Fetch data after exception, blocked", loadData, 2, 2, 50000000, 200000000);

         loadData = "3";

         sleepTime = 500;

         throwException.set(new Thrower() {

             public void throwException() throws IOException {

                 throw new IOException("exc2");

             }

         });

         Thread.sleep(200);

         try {

             assertGetObject("Fetch data second time, stale, process pulse", "2", 3, 2, 0, 200000000);

         } catch (IOException e) {

             fail("Exception thrown");

         }

         Thread.sleep(400);

         try {

             assertGetObject("Fetch data second time, throw exception", "2", 3, 2, 0, 200000000);

             fail("No exception thrown");

         } catch (IOException e) {

             assertEquals("correct exception thrown", "exc2", e.getMessage());

         }

     }

     private static final class DelayedItem implements Delayed {

         protected final long when;

         protected final String value;

         protected DelayedItem(long milliseconds, String value) {

             when = System.nanoTime() + TimeUnit.NANOSECONDS.convert(milliseconds, TimeUnit.MILLISECONDS);

             this.value = value;

         }

         public long getDelay(TimeUnit unit) {

             return unit.convert(when - System.nanoTime(), TimeUnit.NANOSECONDS);

         }

         public int compareTo(Delayed other) {

             return compareTo((DelayedItem) other);

         }

         public int compareTo(DelayedItem other) {

             if (when < other.when) return -1;

             if (when > other.when) return 1;

             return value.compareTo(other.value);

         }

     }

     public interface Thrower {

         void throwException() throws InterruptedException, IOException;

     }

 }