package luan.modules;

import java.io.InputStreamReader;
import java.io.IOException;
import java.lang.reflect.Method;
import java.util.Iterator;
import java.util.Map;
import java.util.List;
import java.util.ArrayList;
import luan.Luan;
import luan.LuanState;
import luan.LuanTable;
import luan.LuanFunction;
import luan.LuanJavaFunction;
import luan.LuanException;
import luan.LuanSource;
import luan.LuanElement;
import luan.LuanMethod;
import luan.LuanMeta;
import luan.impl.LuanCompiler;


public final class BasicLuan {

	public static String type(Object obj) {
		return Luan.type(obj);
	}

	public static LuanFunction load(LuanState luan,String text,String sourceName,LuanTable env,Boolean allowExpr)
		throws LuanException
	{
		if( allowExpr==null )
			allowExpr = false;
		return LuanCompiler.compile(luan,new LuanSource(sourceName,text),env,allowExpr);
	}

	public static LuanFunction load_file(LuanState luan,String fileName,Boolean addExtension) throws LuanException {
		if( fileName == null )
			fileName = "stdin:";
		String src = PackageLuan.read(luan,fileName,addExtension);
		if( src == null )
			throw luan.exception( "file '"+fileName+"' not found" );
		return load(luan,src,fileName,null,false);
	}

	public static LuanFunction pairs(final LuanState luan,final LuanTable t) throws LuanException {
		Utils.checkNotNull(luan,t);
		return t.pairs(luan.JAVA);
	}

	public static LuanFunction ipairs(LuanState luan,final LuanTable t) throws LuanException {
		Utils.checkNotNull(luan,t);
		return new LuanFunction() {
			List<Object> list = t.asList();
			int i = 0;
			final int size = list.size();

			@Override public Object[] call(LuanState luan,Object[] args) {
				if( i >= size )
					return LuanFunction.NOTHING;
				Object val = list.get(i++);
				return new Object[]{i,val};
			}
		};
	}

	public static Object get_metatable(LuanState luan,LuanTable table) throws LuanException {
		Utils.checkNotNull(luan,table);
		LuanTable metatable = table.getMetatable();
		if( metatable == null )
			return null;
		Object obj = metatable.rawGet("__metatable");
		return obj!=null ? obj : metatable;
	}

	public static void set_metatable(LuanState luan,LuanTable table,LuanTable metatable) throws LuanException {
		Utils.checkNotNull(luan,table);
		if( table.getHandler("__metatable") != null )
			throw luan.exception("cannot change a protected metatable");
		table.setMetatable(metatable);
	}

	public static boolean raw_equal(Object v1,Object v2) {
		return v1 == v2 || v1 != null && v1.equals(v2);
	}

	public static Object raw_get(LuanTable table,Object index) {
		return table.rawGet(index);
	}

	public static void raw_set(LuanTable table,Object index,Object value) {
		table.rawPut(index,value);
	}

	public static int raw_len(LuanState luan,Object v) throws LuanException {
		if( v instanceof String ) {
			String s = (String)v;
			return s.length();
		}
		if( v instanceof LuanTable ) {
			LuanTable t = (LuanTable)v;
			return t.rawLength();
		}
		throw luan.exception( "bad argument #1 to 'raw_len' (table or string expected)" );
	}

	public static String to_string(LuanState luan,Object v) throws LuanException {
		return luan.JAVA.toString(v);
	}

	public static LuanTable new_error(LuanState luan,Object msg) throws LuanException {
		return luan.exception(msg).table();
	}

	public static String assert_string(LuanState luan,String v) throws LuanException {
		Utils.checkNotNull(luan,v);
		return v;
	}

	public static Number assert_number(LuanState luan,Number v) throws LuanException {
		Utils.checkNotNull(luan,v);
		return v;
	}

	public static LuanTable assert_table(LuanState luan,LuanTable v) throws LuanException {
		Utils.checkNotNull(luan,v);
		return v;
	}

	public static boolean assert_boolean(LuanState luan,boolean v) throws LuanException {
		return v;
	}

	public static int assert_integer(LuanState luan,int v) throws LuanException {
		return v;
	}

	public static long assert_long(LuanState luan,long v) throws LuanException {
		return v;
	}

	public static double assert_double(LuanState luan,double v) throws LuanException {
		return v;
	}

	@LuanMethod public static byte[] assert_binary(LuanState luan,byte[] v) throws LuanException {
		Utils.checkNotNull(luan,v);
		return v;
	}

	public static LuanFunction range(LuanState luan,final double from,final double to,Double stepV) throws LuanException {
		final double step = stepV==null ? 1.0 : stepV;
		if( step == 0.0 )
			throw luan.exception("bad argument #3 (step may not be zero)");
		return new LuanFunction() {
			double v = from;

			@Override public Object call(LuanState luan,Object[] args) {
				if( step > 0.0 && v > to || step < 0.0 && v < to )
					return LuanFunction.NOTHING;
				double rtn = v;
				v += step;
				return rtn;
			}
		};
	}

	public static LuanFunction values(final Object... args) throws LuanException {
		return new LuanFunction() {
			int i = 0;

			@Override public Object call(LuanState luan,Object[] unused) {
				if( i >= args.length )
					return LuanFunction.NOTHING;
				return args[i++];
			}
		};
	}

	private LuanFunction fn(Object obj) {
		return obj instanceof LuanFunction ? (LuanFunction)obj : null;
	}

	public static Object try_(LuanState luan,LuanTable blocks) throws LuanException {
		Utils.checkNotNull(luan,blocks);
		Object obj = blocks.get(luan.JAVA,1);
		if( obj == null )
			throw luan.exception("missing 'try' value");
		if( !(obj instanceof LuanFunction) )
			throw luan.exception("bad 'try' value (function expected, got "+Luan.type(obj)+")");
		LuanFunction tryFn = (LuanFunction)obj;
		LuanFunction catchFn = null;
		obj = blocks.get(luan.JAVA,"catch");
		if( obj != null ) {
			if( !(obj instanceof LuanFunction) )
				throw luan.exception("bad 'catch' value (function expected, got "+Luan.type(obj)+")");
			catchFn = (LuanFunction)obj;
		}
		LuanFunction finallyFn = null;
		obj = blocks.get(luan.JAVA,"finally");
		if( obj != null ) {
			if( !(obj instanceof LuanFunction) )
				throw luan.exception("bad 'finally' value (function expected, got "+Luan.type(obj)+")");
			finallyFn = (LuanFunction)obj;
		}
		try {
			return tryFn.call(luan);
		} catch(LuanException e) {
			if( catchFn == null )
				throw e;
			return catchFn.call(luan,new Object[]{e.table()});
		} finally {
			if( finallyFn != null )
				finallyFn.call(luan);
		}
	}

	@LuanMethod public static Object[] pcall(LuanState luan,LuanFunction f,Object... args) {
		try {
			Object[] r = Luan.array(f.call(luan,args));
			Object[] rtn = new Object[r.length+1];
			rtn[0] = true;
			for( int i=0; i<r.length; i++ ) {
				rtn[i+1] = r[i];
			}
			return rtn;
		} catch(LuanException e) {
			return new Object[]{false,e.table()};
		}
	}

	public static String number_type(LuanState luan,Number v) throws LuanException {
		Utils.checkNotNull(luan,v);
		return v.getClass().getSimpleName().toLowerCase();
	}

}