package luan.modules;

import java.io.Closeable;
import java.util.Map;
import java.util.LinkedHashMap;
import java.util.concurrent.Executor;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.ScheduledFuture;
import java.util.concurrent.TimeUnit;
import luan.Luan;
import luan.LuanState;
import luan.LuanFunction;
import luan.LuanTable;
import luan.LuanException;
import luan.LuanCloner;


public final class ThreadLuan {
	private static final Executor exec = Executors.newCachedThreadPool();
	private static final ScheduledExecutorService scheduler = Executors.newSingleThreadScheduledExecutor();

	public static void fork(LuanState luan,LuanFunction fn,Object... args) {
		LuanCloner cloner = new LuanCloner(LuanCloner.Type.COMPLETE);
		final LuanState newLuan = (LuanState)cloner.clone(luan);
		final LuanFunction newFn = (LuanFunction)cloner.get(fn);
		final Object[] newArgs = cloner.clone(args);
		exec.execute(new Runnable(){public void run() {
			try {
				newFn.call(newLuan,newArgs);
			} catch(LuanException e) {
				e.printStackTrace();
			}
		}});
	}
/*
	public static LuanFunction synchronized_(final LuanState luan,final LuanFunction fn) throws LuanException {
		Utils.checkNotNull(fn);
		return new LuanFunction() {
			@Override public Object call(LuanState ingored,Object[] args) throws LuanException {
				synchronized(luan) {
					return fn.call(luan,args);
				}
			}
		};
	}
*/
	public static void schedule(LuanState luan,long delay,boolean repeat,LuanFunction fn,Object... args) {
		LuanCloner cloner = new LuanCloner(LuanCloner.Type.COMPLETE);
		final LuanState newLuan = (LuanState)cloner.clone(luan);
		final LuanFunction newFn = (LuanFunction)cloner.get(fn);
		final Object[] newArgs = cloner.clone(args);
		Runnable r = new Runnable(){public void run() {
			try {
				newFn.call(newLuan,newArgs);
			} catch(LuanException e) {
				e.printStackTrace();
			}
		}};
		final ScheduledFuture sf;
		if( repeat ) {
			sf = scheduler.scheduleWithFixedDelay(r,delay,delay,TimeUnit.MILLISECONDS);
		} else {
			sf = scheduler.schedule(r,delay,TimeUnit.MILLISECONDS);
		}
		final Closeable c = new Closeable(){public void close(){
			boolean b = sf.cancel(false);
		}};
		luan.registry().put(c,c);  // prevent gc
		luan.onClose(c);
	}


	public static class GlobalMap {

		private static class Value {
			final long time = System.currentTimeMillis();
			final Object v;

			Value(Object v) {
				this.v = v;
			}
		}

		public long timeout = 60000L;  // one minute
		private Map<String,Value> map = new LinkedHashMap<String,Value>() {
			protected boolean removeEldestEntry(Map.Entry<String,Value> eldest) {
				return eldest.getValue().time < System.currentTimeMillis() - timeout;
			}
		};

		public synchronized Object get(String key) {
			Value val = map.get(key);
			return val==null ? null : val.v;
		}

		public synchronized Object put(String key,Object v) throws LuanException {
			Value val;
			if( v == null ) {
				val = map.remove(key);
			} else {
				if( !(v instanceof String || v instanceof Boolean || v instanceof Number) )
					throw new LuanException("can't assign type "+Luan.type(v)+" to Thread.global");
				val = map.put(key,new Value(v));
			}
			return val==null ? null : val.v;
		}
	}
}