import Package from "../data/Package";
import {ComponentNode} from "../data/XmlNode";
import Path from "../Path";
import PackageReader from "./PackageReader";
import ComponentReader from "./ComponentReader";
import ResourceComponent from "../data/ResourceComponent";
import Setting from "../Setting";
import * as path from 'path';
import { ProjectDescription } from "../parse/XmlFile";
import { FairyProjectFileReader } from "./FairyProjectFileReader";
import { SettingPublishReader } from "./SettingPublishReader";

export default class FairyManager
{
    static current: FairyManager;
    projectDescription:ProjectDescription = {id:"abcdefg"};
    packageList: Package[] = new Array<Package>();
    packages: Map<string,Package> = new Map<string,Package>();
    packagesByName: Map<string,Package> = new Map<string,Package>();

    

    public AddPackage(pkg: Package)
    {
        this.packageList.push(pkg);
        this.packages.set(pkg.id,pkg);
        this.packagesByName.set(pkg.name,pkg);
    }

    public GetPackage(packageId: string): Package
    {
        if(this.packages.has(packageId))
        {
            return this.packages.get(packageId);
        }
        return null;
    }

    public GetPackageByName(packageName: string): Package
    {
        if(this.packagesByName.has(packageName))
        {
            return this.packagesByName.get(packageName);
        }
        return null;
    }

    public GetRescoureComponent(nodeOrId: string | ComponentNode,resId?: string)
    {
        if(!nodeOrId)
            return;
        if(nodeOrId instanceof ComponentNode)
        {
            let node = nodeOrId;
            if(!node.pkg && node.parent != null)
            {
                return node.parent.package.GetResource(node.src);
            }
            let pkg: Package = this.GetPackage(node.pkg);
            if(pkg != null)
            {
                return pkg.GetResource(node.src);
            }
            return;
        }
        else
        {
            let packageId = nodeOrId;
            let pkg: Package = this.GetPackage(packageId);
            if(pkg != null && resId)
            {
                return pkg.GetResource(resId);
            }
            return;
        }
    }

    /** 加载fgui项目 */
    public  LoadProject(projectPath: string)
    {
        FairyProjectFileReader.Load(projectPath, this);
        SettingPublishReader.Load(projectPath, this);

        let root = projectPath + "/assets";
        let dirs: string[] = Path.GetDirectories(root);

        for(let i = 0;i < dirs.length;i++)
        {
            let packageXmlPath = dirs[i] + "/package.xml";
            if(Path.Exists(packageXmlPath))
            {
                // 读取包配置
                let pkg = PackageReader.Load(packageXmlPath);
                pkg && this.AddPackage(pkg);
            }
        }

        // 读取所有包的所有组件
        this.LoadComponent();
        this.SetComponentNode();
    }


    /** 读取所有包的所有组件 */
    private LoadComponent()
    {
        for(let pkg of this.packageList)
        {
            for(let component of pkg.ComponentList)
            {
                ComponentReader.Load(component.pathFull,component);
            }
        }
    }

    private SetComponentNode()
    {
        for(let pkg of this.packageList)
        {
            for(let component of pkg.ComponentList)
            {
                for(let node of component.componentNodeList)
                {
                    let res = this.GetRescoureComponent(node);
                    if(!res)
                        console.warn(`没有找到 resourceComponent  packagename= ${node.parent.package.name} comname= ${node.parent.name} nodename=${node.name}`);
                    else
                    {
                        node.resourceComponent  = res;
                        // 添加被依赖
                        node.resourceComponent.beDependList.push(component);
                        if(component.exported)
                        {
                            node.resourceComponent.beenDependentorExtported = true;
                        }
                    }
                }
            }
        }

        // 生成依赖的包列表
        for(let pkg of this.packageList)
        {
            for(let component of pkg.ComponentList)
            {
                component.AddDependPackage(pkg);
                // 遍历依赖包
                // this.TraverseDependPackage(component,component);

                for(let node of component.displayList)
                {
                    if(node.pkg != null)
                    {
                        let pkg = this.GetPackage(node.pkg);
                        if(pkg != null)
                            component.AddDependPackage(pkg);
                    }
                }

                for(let assetUrlInfo of component.dependAssetUrlList)
                {
                    
                    if(assetUrlInfo == null)
                    {
                        console.error(pkg.name,pkg.rootPath, component.dependAssetUrlList);
                    }
                    
                    if(assetUrlInfo.pkg != null)
                    {
                        let pkg = this.GetPackage(assetUrlInfo.pkg);
                        if(pkg != null)
                        {
                            component.AddDependPackage(pkg);
                            var assetCom:ResourceComponent = pkg.GetResource(assetUrlInfo.src);
                            if(assetCom)
                            {
                                
                                // if(component.name == "HelpWindowUI.xml")
                                // {
                                //     console.log(assetCom.name);
                                // }
                                this.TraverseDependPackage(assetCom, component);
                                
                            }
                        }
                    }
                }

            }
        }


        // 生成依赖的包列表
        for(let pkg of this.packageList)
        {
            for(let component of pkg.ComponentList)
            {
                // 遍历依赖包
                this.TraverseDependPackage(component,component);
            }
        }
    }

    /** 遍历依赖包 */
    public TraverseDependPackage(component: ResourceComponent,root: ResourceComponent)
    {
        
        for(let node of component.displayList)
        {
            if(node.pkg != null)
            {
                let pkg = this.GetPackage(node.pkg);
                if(pkg != null)
                {
                    
                    root.AddDependPackage(pkg);
                    // if(root.name == "HelpWindowUI.xml")
                    // {
                    //     console.log("--", component.name, node.name, pkg.name);
                    // }
                }
            }
        }

        for(let node of component.componentNodeList)
        {
            // if(root.name == "HelpWindowUI.xml")
            // {
            //     console.log(component.name, node.name, node.resourceComponent.name, node.resourceComponent.dependAssetUrlList.length);
            // }

            

            if(node.resourceComponent != null)
            {
                
                for(let assetUrlInfo of node.resourceComponent.dependAssetUrlList)
                {
                    if(assetUrlInfo.pkg != null)
                    {
                        let pkg = this.GetPackage(assetUrlInfo.pkg);
                        if(pkg != null)
                        {
                            root.AddDependPackage(pkg);
                            
                            var assetCom:ResourceComponent = pkg.GetResource(assetUrlInfo.src);
                            if(assetCom)
                            {
                                
                                // if(root.name == "HelpWindowUI.xml")
                                // {
                                //     console.log(assetCom.name);
                                // }
                                this.TraverseDependPackage(assetCom, root);
                                
                            }
                        }
                    }
                }

                root.AddDependPackage(node.resourceComponent.package);
                this.TraverseDependPackage(node.resourceComponent, root);
            }
        }
    }



    
    public ExportRes(resPath: string) {
        let resList: string[] = Path.GetFGUIResList(resPath);
        resList = resList.filter((v, i, arr)=>{
            var ext = path.extname(v);
            return Setting.Options.fguires_ignoreExts.indexOf(ext) == -1;
        });

        resList.sort();

        interface PkgResInfo
        {
            pkgName: string;
            pkgId?: string;
            bin: string;
            atlas?: string[];
            sounds?: string[];
            others?: string[];
            depPkgs?: string[];
        }

        var respkgMap = {};

        for(var i = 0; i < resList.length; i ++)
        {
            var filepath = resList[i];
            var pathinfo = path.parse(filepath);

            var isBin = pathinfo.ext == Setting.Options.fguires_fguiFileExtension;
            if(isBin)
            {
                var pkgInfo:PkgResInfo = 
                {
                    pkgName: pathinfo.name,
                    bin: pathinfo.base
                };

                respkgMap[pkgInfo.pkgName] = pkgInfo;
                var pkg = this.packagesByName.get(pkgInfo.pkgName);
                if(pkg)
                {
                    pkgInfo.pkgId = pkg.id;
                }
            }

        }



        for(var i = 0; i < resList.length; i ++)
        {
            var filepath = resList[i];
            var pathinfo = path.parse(filepath);
            
            var name = pathinfo.name;
            var ext = pathinfo.ext;
            var isBin = ext == Setting.Options.fguires_fguiFileExtension;
            if(isBin) continue;

            var isSound = Setting.Options.fguires_soundExts.indexOf(ext) != -1;
            var isAtlas: boolean = false;
            var packagename:string;
            if(isSound)
            {
                packagename = name.substring(0, name.lastIndexOf("_"));
            }
            else
            {
                var index = name.indexOf(Setting.Options.fguires_atlasSeparator);
                if(index == -1)
                {
                    packagename = name.substring(0, name.lastIndexOf("_"));
                }
                else
                {
                    packagename = name.substring(0, name.indexOf(Setting.Options.fguires_atlasSeparator));
                    isAtlas = true;
                }
            }

            var pkgInfo = respkgMap[packagename];
            if(!pkgInfo)
            {
                console.warn("[Error] 没有找到对应的包:" + name);
                continue;
            }

            if(isAtlas)
            {
                if(!pkgInfo.atlas) pkgInfo.atlas = [];
                pkgInfo.atlas.push(pathinfo.base);
            }
            else if(isSound)
            {
                if(!pkgInfo.sounds) pkgInfo.sounds = [];
                pkgInfo.sounds.push(pathinfo.base);
            }
            else
            {
                if(!pkgInfo.others) pkgInfo.others = [];
                pkgInfo.others.push(pathinfo.base);
            }
        }

        for(var pkg of this.packageList)
        {
            var pkgInfo = respkgMap[pkg.name];
            if(!pkgInfo)
            {
                continue;
            }

            for(var dep of pkg.dependPackages)
            {
                if(!respkgMap[dep.name]) continue;
                if(dep == pkg) continue;
                
                if(!pkgInfo.depPkgs) pkgInfo.depPkgs = [];
                pkgInfo.depPkgs.push(dep.name);
            }
        }


        
        Path.WriteTxt(Setting.Options.fguiExportJsonPath, JSON.stringify(respkgMap, null, 4));
    }

}