package org.webslinger.util;

 import java.io.IOException;

 import java.lang.management.ManagementFactory;

 import java.util.Iterator;

 import java.util.concurrent.Callable;

 import java.util.concurrent.ConcurrentHashMap;

 import java.util.concurrent.ExecutionException;

 import java.util.concurrent.CompletionService;

 import java.util.concurrent.Delayed;

 import java.util.concurrent.DelayQueue;

 import java.util.concurrent.Future;

 import java.util.concurrent.FutureTask;

 import java.util.concurrent.ScheduledExecutorService;

 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.lang.ExecutionPool;

 import org.webslinger.lang.ObjectWrapper;

 import org.webslinger.io.IOUtil;

 public abstract class TTLObject<T> implements ObjectWrapper<T> {

     static {

         int workerCount = ManagementFactory.getOperatingSystemMXBean().getAvailableProcessors();

         for (int i = 0; i < workerCount; i++) {

             Thread t = new Thread() {

                 public void run() {

                     try {

                         while (true) {

                             delayQueue.take().run();

                         }

                     } catch (InterruptedException e) {

                         e.printStackTrace();

                     }

                 }

             };

             t.setDaemon(true);

             t.setName("TTLObject(" + i + ") pulse");

             t.start();

         }

     }

     private static final ScheduledExecutorService updateExecutor = ExecutionPool.getNewOptimalExecutor("TTLObject(async-update)");

     private static final DelayQueue<Pulse> delayQueue = new DelayQueue<Pulse>();

     private static final ConcurrentHashMap<String, Long> ttls = new ConcurrentHashMap<String, Long>();

     public static void setDefaultTTLForClass(Class c, long ttl) {

         ttls.putIfAbsent(c.getName(), ttl);

     }

     public static void setTTLForClass(Class c, long ttl) {

         ttls.put(c.getName(), ttl);

     }

     public static long getTTLForClass(Class c) {

         Class ptr = c;

         Long ttl = null;

         while (ttl == null && ptr != null) {

             ttl = ttls.get(ptr.getName());

             ptr = ptr.getSuperclass();

         }

         if (ttl != null) return ttl.longValue();

         throw new IllegalArgumentException("No TTL defined for " + c.getName());

     }

     private static final ConcurrentHashMap<String, Boolean> inForeground = new ConcurrentHashMap<String, Boolean>();

     private static final AtomicBoolean defaultForeground = new AtomicBoolean(true);

     public static boolean getDefaultForeground() {

         return defaultForeground.get();

     }

     public static void setDefaultForeground(boolean def) {

         defaultForeground.set(def);

     }

     public static void setDefaultForegroundForClass(Class c, boolean foreground) {

         inForeground.putIfAbsent(c.getName(), foreground);

     }

     public static void setForegroundForClass(Class c, boolean foreground) {

         inForeground.put(c.getName(), foreground);

     }

     public static boolean getForegroundForClass(Class c) {

         Class ptr = c;

         Boolean foreground = null;

         while (foreground == null && ptr != null) {

             foreground = inForeground.get(ptr.getName());

             ptr = ptr.getSuperclass();

         }

         if (foreground != null) return foreground.booleanValue();

         return defaultForeground.get();

     }

     public static void pulseAll() {

         Iterator<Pulse> it = delayQueue.iterator();

         while (it.hasNext()) {

             Pulse pulse = it.next();

             it.remove();

             pulse.run();

         }

     }

     private enum State { INVALID, REGEN, REGENERATING, GENERATE, GENERATING, VALID, ERROR }

     protected final AtomicReference<ValueAndState> object = new AtomicReference<ValueAndState>(new ValueAndState(null, null, State.INVALID, 0, null, null));

     protected final AtomicInteger serial = new AtomicInteger();

     private final class ValueAndState {

         protected final T value;

         protected final FutureTask<T> future;

         protected final State state;

         protected final int serial;

         protected final Throwable t;

         protected final Pulse pulse;

         protected ValueAndState(T value, FutureTask<T> future, State state, int serial, Throwable t, Pulse pulse) {

             this.value = value;

             this.future = future;

             this.state = state;

             this.serial = serial;

             this.t = t;

             this.pulse = pulse;

         }

         protected ValueAndState refresh(State nextState) {

             return new ValueAndState(value, future, nextState, serial, null, null);

         }

         protected ValueAndState valid(T value) {

             return new ValueAndState(value, null, State.VALID, TTLObject.this.serial.incrementAndGet(), null, new Pulse(TTLObject.this));

         }

         protected ValueAndState submit(final T oldValue, State state) {

             return new ValueAndState(value, createTask(oldValue), state, serial, null, null);

         }

         protected FutureTask<T> createTask(final T oldValue) {

             return new FutureTask<T>(new Callable<T>() {

                 public T call() throws Exception {

                     return load(oldValue, serial);

                 }

             });

         }

         protected ValueAndState error(Throwable t) {

             return new ValueAndState(null, null, State.ERROR, TTLObject.this.serial.incrementAndGet(), t, pulse);

         }

     }

     protected final static class Pulse implements Delayed, Runnable {

         protected final long expireTime;

         protected final TTLObject<?> ttlObject;

         protected Pulse(TTLObject<?> ttlObject) {

             this.ttlObject = ttlObject;

             expireTime = System.nanoTime() + TimeUnit.NANOSECONDS.convert(ttlObject.getTTL(), TimeUnit.MILLISECONDS);

         }

         public void run() {

             ttlObject.refresh();

         }

         public long getDelay(TimeUnit unit) {

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

         }

         public int compareTo(Delayed other) {

             long r = (expireTime - ((Pulse) other).expireTime);

             if (r < 0) return -1;

             if (r > 0) return 1;

             return 0;

         }

     }

     protected void refresh() {

         ValueAndState container;

         ValueAndState nextContainer = null;

         do {

             container = object.get();

             switch (container.state) {

                 case INVALID:

                     nextContainer = container.refresh(State.GENERATE);

                     break;

                 case REGENERATING:

                     nextContainer = container.refresh(State.REGEN);

                     break;

                 case GENERATING:

                     nextContainer = container.refresh(State.GENERATE);

                     break;

                 case VALID:

                     nextContainer = container.refresh(getForeground() ? State.GENERATE : State.REGEN);

                     break;

                 case ERROR:

                     nextContainer = container.refresh(State.GENERATE);

                     break;

                 case REGEN:

                     return;

                 case GENERATE:

                     return;

             }

         } while (!object.compareAndSet(container, nextContainer));

         cancelFuture(container);

     }

     public final int getSerial() {

         return object.get().serial;

     }

     public final boolean checkSerial(int serial) throws IOException {

         return object.get().serial != serial;

     }

     protected final void setObject(final T newObject) {

         ValueAndState container, nextContainer;

         State nextState;

         do {

             container = object.get();

             nextContainer = container.valid(newObject);

         } while (!object.compareAndSet(container, nextContainer));

         cancelFuture(container);

         delayQueue.put(nextContainer.pulse);

     }

     private void cancelFuture(ValueAndState container) {

         delayQueue.remove(container.pulse);

         switch (container.state) {

             case REGENERATING:

             case GENERATING:

                 container.future.cancel(false);

                 break;

         }

     }

     public final T getObject() throws IOException {

         do {

             try {

                 return getObjectInternal();

             } catch (Throwable e) {

                 return IOUtil.<T>checkException(e);

             }

         } while (true);

     }

     private final T getObjectInternal() throws Throwable {

         ValueAndState container;

         ValueAndState nextContainer = null;

         do {

             do {

                 container = object.get();

                 try {

                     try {

                         switch (container.state) {

                             case INVALID:

                                 nextContainer = container.submit(getInitial(), State.GENERATING);

                                 break;

                             case REGENERATING:

                                 if (!container.future.isDone()) {

                                     return container.value;

                                 }

                                 nextContainer = container.valid(container.future.get());

                                 break;

                             case GENERATING:

                                 nextContainer = container.valid(container.future.get());

                                 break;

                             case VALID:

                                 return container.value;

                             case ERROR:

                                 nextContainer = container.submit(container.value, State.GENERATING);

                                 break;

                             case REGEN:

                                 nextContainer = container.submit(container.value, State.REGENERATING);

                                 break;

                             case GENERATE:

                                 nextContainer = container.submit(container.value, State.GENERATING);

                                 break;

                         }

                     } catch (ExecutionException e) {

                         throw e.getCause();

                     }

                 } catch (Throwable t) {

                     nextContainer = container.error(t);

                 }

             } while (!object.compareAndSet(container, nextContainer));

             switch (nextContainer.state) {

                 case GENERATING:

                     nextContainer.future.run();

                     break;

                 case REGENERATING:

                     updateExecutor.submit(nextContainer.future);

                     break;

                 case VALID:

                     delayQueue.remove(container.pulse);

                     delayQueue.put(nextContainer.pulse);

                     break;

                 case ERROR:

                     throw nextContainer.t;

             }

         } while (true);

     }

     protected T getInitial() throws Exception {

         return null;

     }

     protected T load(T old) throws IOException {

         throw new AbstractMethodError();

     }

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

         return load(old);

     }

     protected boolean getForeground() {

         return getForegroundForClass(getClass());

     }

     protected long getTTL() {

         return getTTLForClass(getClass());

     }

 }