package haxe.ui.macros;

#if macro
import haxe.macro.Context;
import haxe.ui.core.ComponentClassMap;
import haxe.ui.core.LayoutClassMap;
import haxe.ui.macros.helpers.ClassBuilder;
import haxe.ui.macros.helpers.CodeBuilder;
import haxe.ui.parsers.modules.Module;
import haxe.ui.parsers.modules.ModuleParser;
import sys.FileSystem;
import sys.io.File;
#end

class ModuleMacros {

    #if macro
    private static var _modules:Array<Module> = [];
    private static var _modulesProcessed:Bool;
    private static var _resourceIds:Array<String> = [];
    #end

    macro public static function processModules() {
        if (_modulesProcessed == true) {
            return macro null;
        }

        loadModules();

        var preloadAll:Bool = false;
        var builder = new CodeBuilder();
        for (m in _modules) {
            if (m.preloadList == "all") {
                preloadAll = true;
            }

            // add resources as haxe resources (plus prefix)
            for (r in m.resourceEntries) {
                if (r.path != null) {
                    var resolvedPath = null;
                    try {
                        resolvedPath = Context.resolvePath(r.path);
                    } catch (e:Dynamic) {
                        resolvedPath = haxe.io.Path.join([Sys.getCwd(), r.path]);
                    }
                    if (FileSystem.isDirectory(resolvedPath) && FileSystem.exists(resolvedPath)) {
                        addResources(resolvedPath, resolvedPath, r.prefix);
                    } else {
                        trace("WARNING: Could not find path " + resolvedPath);
                    }
                }
            }

            for (s in m.scriptletEntries) {
                var types:Array<haxe.macro.Type> = MacroHelpers.typesFromClassOrPackage(s.className, s.classPackage);
                if (types != null) {
                    for (t in types) {
                        var scriptType = new ClassBuilder(t);
                        if (scriptType.isPrivate == true) {
                            continue;
                        }

                        var skipRest = false;
                        var resolvedClass:String = scriptType.fullPath;
                        var classAlias:String = s.classAlias;
                        if (classAlias == null) {
                            classAlias = scriptType.name;
                        } else {
                            skipRest = true; // as we have an alias defined lets skip any other types (assumes the first class is the one to alias)
                        }
                        if (StringTools.startsWith(resolvedClass, ".")) {
                            continue;
                        }

                        builder.add(macro
                            haxe.ui.scripting.ScriptInterp.addClassAlias($v{classAlias}, $v{resolvedClass})
                        );

                        if (s.staticClass == true || s.keep == true) {
                            builder.add(macro
                                haxe.ui.scripting.ScriptInterp.addStaticClass($v{classAlias}, $p{resolvedClass.split(".")})
                            );
                        }

                        if (skipRest == true) {
                            break;
                        }
                    }
                }
            }

            // setup themes
            for (t in m.themeEntries) {
                if (t.parent != null) {
                    builder.add(macro
                        haxe.ui.themes.ThemeManager.instance.getTheme($v{t.name}).parent = $v{t.parent}
                    );
                }
                for (r in t.styles) {
                    builder.add(macro
                        haxe.ui.themes.ThemeManager.instance.addStyleResource($v{t.name}, $v{r.resource}, $v{r.priority})
                    );
                }
            }

            // handle plugins
            /* TODO: is this still relevant??? Check haxeui-kha
            for (p in m.plugins) {
                switch (p.type) {
                    case "asset":
                        code += 'var assetPlugin:${p.className} = new ${p.className}();\n';
                        for (propName in p.config.keys()) {
                            var propValue = p.config.get(propName);
                            code += 'assetPlugin.setProperty("${propName}", "${propValue}");\n';
                        }
                        code += 'ToolkitAssets.instance.addPlugin(assetPlugin);\n';
                    default:
                        trace("WARNING: unknown plugin type: " + p.type);
                }
            }
            */

            // set toolkit properties
            for (p in m.properties) {
                builder.add(macro
                    haxe.ui.Toolkit.properties.set($v{p.name}, $v{p.value})
                );
            }

            for (p in m.preload) {
                builder.add(macro
                    haxe.ui.ToolkitAssets.instance.preloadList.push({type: $v{p.type}, resourceId: $v{p.id}})
                );
            }
        }

        if (preloadAll) {
            for (r in _resourceIds) {
                if (StringTools.endsWith(r, ".png")) {
                    builder.add(macro
                        haxe.ui.ToolkitAssets.instance.preloadList.push({type: "image", resourceId: $v{r}})
                    );
                }
            }
        }

        populateClassMap();

        for (alias in ComponentClassMap.list()) {
            builder.add(macro
                haxe.ui.core.ComponentClassMap.register($v{alias}, $v{ComponentClassMap.get(alias)})
            );
        }

        for (alias in LayoutClassMap.list()) {
            builder.add(macro
                haxe.ui.core.LayoutClassMap.register($v{alias}, $v{LayoutClassMap.get(alias)})
            );
        }

        _modulesProcessed = true;
        return builder.expr;
    }

    #if macro
    private static var _classMapPopulated:Bool = false;
    public static function populateClassMap() {
        if (_classMapPopulated == true) {
            return;
        }

        var modules:Array<Module> = ModuleMacros.loadModules();
        for (m in modules) {
            // load component classes from all modules
            for (c in m.componentEntries) {
                var types:Array<haxe.macro.Type> = MacroHelpers.typesFromClassOrPackage(c.className, c.classPackage);
                if (types != null) {
                    for (t in types) {
                        var builder = new ClassBuilder(t);
                        if (builder.isPrivate == true) {
                            continue;
                        }

                        if (builder.hasSuperClass("haxe.ui.core.Component") == true) {
                            var resolvedClass:String = builder.fullPath;
                            if (c.className != null && resolvedClass != c.className) {
                                continue;
                            }

                            var resolvedClassName = builder.name;
                            var classAlias:String = c.classAlias;
                            if (classAlias == null) {
                                classAlias = resolvedClassName;
                            }
                            classAlias = classAlias.toLowerCase();

                            if (builder.hasInterface("haxe.ui.core.IDirectionalComponent")) {
                                var pkg = MacroHelpers.getPackage(resolvedClass);
                                if (StringTools.startsWith(resolvedClassName, "Horizontal")) { // alias HorizontalComponent with hcomponent
                                    ComponentClassMap.register("h" + StringTools.replace(resolvedClassName, "Horizontal", "").toLowerCase(), resolvedClass);
                                } else if (StringTools.startsWith(resolvedClassName, "Vertical")) { // alias VerticalComponent with vcomponent
                                    ComponentClassMap.register("v" + StringTools.replace(resolvedClassName, "Vertical", "").toLowerCase(), resolvedClass);
                                }
                            }

                            ComponentClassMap.register(classAlias, resolvedClass);
                        }
                    }
                }
            }

            // load layout classes from all modules
            for (c in m.layoutEntries) {
                var types:Array<haxe.macro.Type> = MacroHelpers.typesFromClassOrPackage(c.className, c.classPackage);
                if (types != null) {
                    for (t in types) {
                        var builder = new ClassBuilder(t);
                        if (builder.isPrivate == true) {
                            continue;
                        }

                        if (builder.hasSuperClass("haxe.ui.layouts.Layout") == true) {
                            var resolvedClass:String = builder.fullPath;
                            if (c.className != null && resolvedClass != c.className) {
                                continue;
                            }

                            var resolvedClassName = builder.name;
                            var classAlias:String = c.classAlias;
                            if (classAlias == null) {
                                classAlias = resolvedClassName;
                            }
                            classAlias = classAlias.toLowerCase();

                            LayoutClassMap.register(classAlias, resolvedClass);
                        }
                    }
                }
            }
        }

        _classMapPopulated = true;
    }

    private static var _modulesLoaded:Bool = false;
    public static function loadModules():Array<Module> {
        if (_modulesLoaded == true) {
            return _modules;
        }

        MacroHelpers.scanClassPath(function(filePath:String) {
            var moduleParser = ModuleParser.get(MacroHelpers.extension(filePath));
            if (moduleParser != null) {
                try {
                    var module:Module = moduleParser.parse(File.getContent(filePath), Context.getDefines(), filePath);
                    module.validate();
                    _modules.push(module);
                    return true;
                } catch (e:Dynamic) {
                    trace('WARNING: Problem parsing module ${MacroHelpers.extension(filePath)} (${filePath}) - ${e} (skipping file)');
                }
            }
            return false;
        }, ["module."]);

        _modulesLoaded = true;
        return _modules;
    }

    private static function addResources(path:String, base:String, prefix:String) {
        if (prefix == null) {
            prefix = "";
        }
        var contents:Array<String> = sys.FileSystem.readDirectory(path);
        for (f in contents) {
            var file = path + "/" + f;
            if (sys.FileSystem.isDirectory(file)) {
                addResources(file, base, prefix);
            } else {
                var relativePath = prefix + StringTools.replace(file, base, "");
                var resourceName:String = relativePath;
                if (StringTools.startsWith(resourceName, "/")) {
                    resourceName = resourceName.substr(1, resourceName.length);
                }
                _resourceIds.push(resourceName);
                Context.addResource(resourceName, File.getBytes(file));
            }
        }
    }
    #end
}