import { Project } from '../module/project/data/Project';
import { Global } from './Global';
import { Paths } from './Paths';
import { GameUIScene } from '../module/project/data/GameUIScene';
import { GameUIObject } from '../module/project/data/GameUIObject';
import { GameUIComponent } from '../module/project/data/GameUIComponent';
import fs   = require('fs');
import path = require('path');
export class ProjectUtls{
    //序列化项目
    static serialize(project: Project): string {
        if (project) {
            let projectData:any         = {};
            projectData.name            = project.name;
            projectData.screenWidth     = project.screenWidth;
            projectData.screenHeight    = project.screenHeight;
            projectData.fps             = project.fps;
            projectData.showfps         = project.showfps;
            projectData.version         = project.version;
            projectData.orientation     = project.orientation;
            projectData.renderMode      = project.renderMode;
            projectData.backgroundColor = project.backgroundColor;

            projectData.plugins = {};
            for (let key in project.plugins) {
                projectData.plugins[key] = project.plugins[key];
            }

            //场景
            projectData.scenes = [];
            for (let i: number = 0, l: number = project.uiScenes.length; i < l; i++){
                let scenedata: any = {};
                scenedata.name = project.uiScenes[i].name;
                projectData.scenes[i] = scenedata;
            }

            let projectStr: string = JSON.stringify(projectData);
            return projectStr;
        }
    }

    //反序列化项目
    static deSerialize(data: any, callback?: () => void, thisObject?: any): Project {
        let project: Project                = new Project();
        for (let key in data) {
            project[key]                    = data[key];
        }
        if (data.scenes) {
            project.uiScenes = [];
            let execNums: number = 0;
            for (let i: number = 0, l: number = data.scenes.length; i < l; i++){
                let scenedata: any                      = data.scenes[i];
                let sceneName: string                   = scenedata.name;
                let sceneUrl: string                    = path.normalize(Paths.getSceneDirectory(sceneName));
                fs.readFile(sceneUrl, ((err, scenedata) => {
                    if (err) throw err;
                    let jsondata: any                   = JSON.parse(new Buffer(scenedata).toString());
                    let sceneName: string               = jsondata.name;
                    let gameobjectsdata: any[]          = jsondata.gameobjects;
                    let scene: GameUIScene              = new GameUIScene();
                    scene.name                          = jsondata.name;
                    for (let j: number = 0, jl: number  = gameobjectsdata.length; j < jl; j++){
                        let gameobjectdata: any         = gameobjectsdata[j];
                        let transformdata: any          = gameobjectdata.transform;
                        let componentsdata: any[]       = gameobjectdata.components;

                        let gameobject: GameUIObject        = new GameUIObject();
                        this._serializeGameobject(gameobjectdata, gameobject);
                        scene.addChild(gameobject);
                    }
                    project.uiScenes[i]                       = scene;
                    execNums++;
                    if (execNums === data.scenes.length) {
                        if (callback)
                            callback.apply(thisObject, []);
                    }
                }));
            }
        }
        return project;
    }

    private static _serializeGameobject(gameobjectdata:any,gameuiobject:GameUIObject){
        let transformdata: any              = gameobjectdata.transform;
        let componentsdata: any[]           = gameobjectdata.components;

        gameuiobject.UID                    = gameobjectdata.UID;
        gameuiobject.name                   = gameobjectdata.name;
        
        //解析变换属性
        for (let transkey in transformdata) {
            gameuiobject.transform[transkey]  = transformdata[transkey];
        }
        
        //解析组件
        for (let k: number = 0, kl = componentsdata.length; k < kl; k++){
            let componentdata: any          = componentsdata[k];
            let component: GameUIComponent  = new GameUIComponent();
            component.name                  = componentdata.name;
            component.propertys             = {};
            if (componentdata.propertys) {
                for (let propkey in componentdata.propertys) {
                    component.propertys[propkey]    = componentdata.propertys[propkey];
                }
            }
            //存储用到的脚本名
            GameUIComponent.addScript(component.name);
            gameuiobject.addComponent(component);
        }

        //解析子的游戏对象
        let subGameobjectsData:any[]            = gameobjectdata.gameobjects;
        if (subGameobjectsData) {
            for (let i: number = 0, l: number = subGameobjectsData.length; i < l; i++){
                let subgameobjectdata: any          = subGameobjectsData[i];
                let subgameuiobject: GameUIObject   = new GameUIObject();
                gameuiobject.addChild(subgameuiobject);
                this._serializeGameobject(subgameobjectdata, subgameuiobject);
            }
        }
    }
}