package hscript;

import hscript.Expr;

using StringTools;

class Tools {

public static function iter( e : Expr, f : Expr -> Void ):Void {

switch( expr(e) ) {

case EConst(_), EIdent(_):

case EImport(c): f(e);

case EClass(_, e, _, _): for( a in e ) f(a);

case EVar(_, _, e): if( e != null ) f(e);

case EParent(e): f(e);

case EBlock(el): for( e in el ) f(e);

case EField(e, _): f(e);

case EBinop(_, e1, e2): f(e1); f(e2);

case EUnop(_, _, e): f(e);

case ECall(e, args): f(e); for( a in args ) f(a);

case EIf(c, e1, e2): f(c); f(e1); if( e2 != null ) f(e2);

case EWhile(c, e): f(c); f(e);

case EDoWhile(c, e): f(c); f(e);

case EFor(_, it, e): f(it); f(e);

case EBreak,EContinue:

case EFunction(_, e, _, _): f(e);

case EReturn(e): if( e != null ) f(e);

case EArray(e, i): f(e); f(i);

case EArrayDecl(el): for( e in el ) f(e);

case ENew(_,el): for( e in el ) f(e);

case EThrow(e): f(e);

case ETry(e, _, _, c): f(e); f(c);

case EObject(fl): for( fi in fl ) f(fi.e);

case ETernary(c, e1, e2): f(c); f(e1); f(e2);

case ESwitch(e, cases, def):

f(e);

for( c in cases ) {

for( v in c.values ) f(v);

f(c.expr);

}

if( def != null ) f(def);

case EMeta(name, args, e): if( args != null ) for( a in args ) f(a); f(e);

case ECheckType(e,_): f(e);

default:

}

}

public static function map( e : Expr, f : Expr -> Expr ):Expr {

var edef = switch( expr(e) ) {

case EConst(_), EIdent(_), EBreak, EContinue: expr(e);

case EVar(n, t, e, isPublic, isStatic, isPrivate): EVar(n, t, if( e != null ) f(e) else null, isPublic, isStatic, isPrivate);

case EParent(e): EParent(f(e));

case EBlock(el): EBlock([for( e in el ) f(e)]);

case EField(e, fi): EField(f(e),fi);

case EBinop(op, e1, e2): EBinop(op, f(e1), f(e2));

case EUnop(op, pre, e): EUnop(op, pre, f(e));

case ECall(e, args): ECall(f(e),[for( a in args ) f(a)]);

case EIf(c, e1, e2): EIf(f(c),f(e1),if( e2 != null ) f(e2) else null);

case EWhile(c, e): EWhile(f(c),f(e));

case EDoWhile(c, e): EDoWhile(f(c),f(e));

case EFor(v, it, e): EFor(v, f(it), f(e));

case EFunction(args, e, name, t, isPublic, isStatic, isOverride, isPrivate): EFunction(args, f(e), name, t, isPublic, isStatic, isOverride, isPrivate);

case EReturn(e): EReturn(if( e != null ) f(e) else null);

case EArray(e, i): EArray(f(e),f(i));

case EArrayDecl(el): EArrayDecl([for( e in el ) f(e)]);

case ENew(cl,el): ENew(cl,[for( e in el ) f(e)]);

case EThrow(e): EThrow(f(e));

case ETry(e, v, t, c): ETry(f(e), v, t, f(c));

case EObject(fl): EObject([for( fi in fl ) { name : fi.name, e : f(fi.e) }]);

case ETernary(c, e1, e2): ETernary(f(c), f(e1), f(e2));

case ESwitch(e, cases, def): ESwitch(f(e), [for( c in cases ) { values : [for( v in c.values ) f(v)], expr : f(c.expr) } ], def == null ? null : f(def));

case EMeta(name, args, e): EMeta(name, args == null ? null : [for( a in args ) f(a)], f(e));

case ECheckType(e,t): ECheckType(f(e), t);

case EImport(c): EImport(c);

case EClass(name, el, extend, interfaces): EClass(name, [for( e in el ) f(e)], extend, interfaces);

default: #if hscriptPos e.e #else e #end;

}

return mk(edef, e);

}

public static inline function expr( e : Expr ) : ExprDef {

#if hscriptPos

return e.e;

#else

return e;

#end

}

public static inline function mk( e : ExprDef, p : Expr ):Expr {

#if hscriptPos

return { e : e, pmin : p.pmin, pmax : p.pmax, origin : p.origin, line : p.line };

#else

return e;

#end

}

@:access(hscript.Interp)

public static function clearClasses() {

#if CUSTOM_CLASSES

Interp._customClasses.clear();

Interp._customClassAliases.clear();

#end

}

public static function removeInnerClass(name: String): String {

var ll = name.lastIndexOf(".");

if (name.indexOf(".") != ll) { // checks if there are 2 or more dots

// wtf did i make -neo

// this is awesome -crow

return name.substr(0, name.lastIndexOf(".", ll - 1)) + "." + name.substr(ll + 1);

}

// only one dot or no dots (will work since -1 + 1 = 0)

return name.substr(ll + 1);

}

// TODO: maybe use this function for import since also check for innerclasses

public static function getClass(name: String): Dynamic {

var splitClassName = [for (e in name.split(".")) e.trim()];

var realClassName = splitClassName.join(".");

var c: Dynamic = Type.resolveClass(realClassName);

if (c == null) // try importing as enum

try

c = Type.resolveEnum(name);

if (c == null) {

// lastly try removing any inner class from it

// this allows you to import stuff like

// flixel.text.FlxText.FlxTextBorderStyle

// without the script crashing immediately

var className = removeInnerClass(realClassName);

if (className != name) {

c = Type.resolveClass(className);

if (c == null)

c = Type.resolveEnum(className);

}

}

return c;

}

public static function isIterable(v: Dynamic): Bool {

// TODO: test for php and lua, they might have issues with this check

return v != null && v.iterator != null;

}

/**

public static function argCount(func: haxe.Constraints.Function): Int {

#if cpp

return untyped __cpp__("{0}->__ArgCount()", func);

#elseif js

return untyped js.Syntax.code("{0}.length", func);

#else

return -1;

#end

}

public static function getClassDeclFields(classDecl:hscript.Expr.ClassDecl, onlyStatic:Bool = false):Array<FieldDecl> {

var fields = classDecl.fields.filter(function(field:FieldDecl) {

var isStatic = field.access.contains(AStatic);

return onlyStatic ? isStatic : !isStatic;

});

return fields;

}

}

class EnumValue {

public var enumName: String;

public var name: String;

public var index: Int;

public var args: Array<Dynamic>;

public var enumParent:Dynamic;

public function new(enumName: String, name: String, index: Int, enumParent:Dynamic, ?args: Array<Dynamic>) {

this.enumName = enumName;

this.name = name;

this.index = index;

this.enumParent = enumParent;

this.args = args;

}

public function toString(): String {

if (args == null)

return enumName + "." + name;

return enumName + "." + name + "(" + [for (arg in args) arg].join(", ") + ")";

}

public inline function getEnumName(): String

return this.enumName;

public inline function getConstructorArgs(): Array<Dynamic>

return this.args != null ? this.args : [];

public function compare(other: EnumValue): Bool {

if (enumName != other.enumName || name != other.name)

return false;

if (args == null && other.args == null)

return true;

if (args == null || other.args == null)

return false;

if (args.length != other.args.length)

return false;

for (i in 0...args.length) {

// TODO: allow deep comparison, like arrays

if (args[i] != other.args[i])

return false;

}

return true;

}

}

class HScriptEnum implements IHScriptCustomBehaviour {

public var enumValues(default, null) = {};

public function new() {}

public function setEnum(name:String, enumValue:Dynamic) {

Reflect.setField(enumValues, name, enumValue);

}

public function getEnumValue(name:String):Null<Dynamic> {

if(Reflect.hasField(enumValues, name)) return Reflect.field(enumValues, name);

return null;

}

public function hget(name:String):Dynamic {

return getEnumValue(name);

}

public function hset(name:String, val:Dynamic):Dynamic {

return null;

}

}