import { BaseWorkder } from '../BaseWorker';
import { MessageUtils, Message } from '../message/MessageUtils';
import { ProjectMessage } from './events/ProjectMessage';
import * as ReactDOM from 'react-dom';
import { Paths } from '../../utils/Paths';
import { Project } from './data/Project';
import { CreateProjectWindow } from './CreateProjectWindow';
import * as React from 'react';
import { Global } from '../../utils/Global';
import { ProjectUtls } from '../../utils/ProjectUtls';
import { FileUtils } from '../../utils/FileUtils';
import { message } from 'antd';
import { GameUIScene } from './data/GameUIScene';
import { GameUIObject } from './data/GameUIObject';
import { GameUIComponent } from './data/GameUIComponent';
import { SceneMessage } from '../../plugins/scene/events/SceneMessage';
import fs                   = require('fs');
import path                 = require('path');
const ipcRender             = require('electron').ipcRenderer;
export class ProjectWorker extends BaseWorkder {
    private _openUrl: string;
    private _createProjectWindow: CreateProjectWindow;
    start(): void {
        MessageUtils.register(ProjectMessage.OPEN_NEW_PROJECT_WINDOW, this.onMessage, this);
        MessageUtils.register(ProjectMessage.OPEN_PROJECT, this.onMessage, this);
        MessageUtils.register(ProjectMessage.NEW_PROJECT, this.onMessage, this);
        MessageUtils.register(ProjectMessage.SAVE_PROJECT, this.onMessage, this);
        MessageUtils.register(ProjectMessage.SAVE_AS_PROJECT, this.onMessage, this);
        MessageUtils.register(ProjectMessage.OPEN_RECENT_PROJECT, this.onMessage, this);
        MessageUtils.register(ProjectMessage.RELOAD, this.onMessage, this);
        MessageUtils.register(ProjectMessage.CLOSE_EDITOR, this.onMessage, this);
        MessageUtils.register(ProjectMessage.SWITCH_FULLSCREEN, this.onMessage, this);
        MessageUtils.register(ProjectMessage.SWITCH_DEVELOP_TOOLS, this.onMessage, this);
        MessageUtils.register(ProjectMessage.INSERT_COMPONENT, this.onMessage, this);
        MessageUtils.register(ProjectMessage.UPDATE_COMPONENTS, this.onMessage, this);
        
        ipcRender.on('on-project-open-project-opened', (event,paths) => { 
            if (paths && paths.length > 0) {
                this.onProjectOpend(paths[0]);
            }
        });
    }

    private onMessage(event: Message): void {
        switch (event.type) {
            case ProjectMessage.OPEN_NEW_PROJECT_WINDOW:
                this.onOpenNewProjectWindow();
                break;

            case ProjectMessage.OPEN_PROJECT:
                this.openProject(event);
                break;

            case ProjectMessage.NEW_PROJECT:
                this.onNewProject();
                break;

            case ProjectMessage.SAVE_PROJECT:
                this.onSaveProject();
                break;

            case ProjectMessage.SAVE_AS_PROJECT:

                break;

            case ProjectMessage.OPEN_RECENT_PROJECT:

                break;

            case ProjectMessage.RELOAD:

                break;

            case ProjectMessage.CLOSE_EDITOR:

                break;

            case ProjectMessage.SWITCH_FULLSCREEN:
                ipcRender.send('toggle-fullscreen');
                break;
            case ProjectMessage.SWITCH_DEVELOP_TOOLS:
                ipcRender.send('toggle-developer-tools');
                break;

            case ProjectMessage.INSERT_COMPONENT:
                this.onComponnetInsert(event);
                break;

            case ProjectMessage.UPDATE_COMPONENTS:
                this.onSceneSave();
                break;

        }
    }

    onComponnetInsert(event: ProjectMessage) {
        console.log('插入组件：', event);
        this.onSceneSave();
    }

    openProject(event: ProjectMessage): void {
        
        
        // let project: Project    = new Project();
        // project.basePath        = Paths.PATH_BASE_DOC + "examples/game/";
        // project.nativePath      = project.basePath + "project.json";
        // let file: FileVo        = Paths.getDirectoryListing(project.basePath);
        // Global.currentProject = project;
        // //加载项目配置
        // this.onProjectConfigLoad(project.nativePath);


        ////////////////打开项目//////////////////
        ipcRender.send('project-open-project');
    }

    onNewProject(): void{
        this.onSaveProject(true);
    }

    onProjectOpend(url: string): void {
        fs.readFile(url, (err, data) => { 
            if (err) throw err;
            let jsonData: Object        = JSON.parse(new Buffer(data).toString());
            let project: Project        = ProjectUtls.deSerialize(jsonData, () => { 
                
                project.basePath        = path.dirname(url);
                project.name            = path.basename(project.basePath);
                Global.currentProject = project;
                
                
                MessageUtils.send(ProjectMessage.INIT_PROJECT_TREE, FileUtils.parentUrl(url));

                egret.setTimeout(() => { 
                    MessageUtils.send(SceneMessage.SCENE_INITIALIZE);
                }, this, 1000);
            }, this);
        });
    }

    /**保存当前场景，通过编辑器ui来操作 */
    onSceneSave() {
        let project: Project            = Global.currentProject;
        let uiScene: GameUIScene        = project.getGameUIScene(project.currentSceneName);
        let scenedata: any              = { name: project.currentSceneName,gameobjects: [] };
        if (!uiScene || !uiScene.children) return;
        //更新游戏对象transfrom对象
        let scene: els.Scene = project.currentScene;
        for (let i: number = 0, l: number = scene.children.length; i < l; i++){
            let gameobject: els.GameObject = scene.children[i];
            let uiGameObject: GameUIObject = uiScene.getGameObjectByUID(gameobject.UID);
            if (uiGameObject) {
                for (let key in uiGameObject.transform) {
                    uiGameObject.transform[key] = gameobject[key];
                }
            }
        }
        
        for (let i: number = 0, l: number = uiScene.children.length; i < l; i++){
            let uiGameObject: GameUIObject = uiScene.children[i];
            let gameobjectdata: any = { name: uiGameObject.name, UID: uiGameObject.UID, components: [], transform: {} };
            //保存当前变换坐标
            if (uiGameObject) {
                for (let propkey in uiGameObject.transform) {
                    gameobjectdata.transform[propkey]    = uiGameObject.transform[propkey];
                }
            }

            if (!uiGameObject.components) continue;            
            //保存组件
            for (let j: number = 0, jl: number = uiGameObject.components.length; j < jl; j++){
                let uiComponent: GameUIComponent = uiGameObject.components[j];
                let componentdata: any = { name: uiComponent.name, propertys: (uiComponent) ? uiComponent.propertys : {} };
                gameobjectdata.components[j]        = componentdata;
            }
            scenedata.gameobjects[i]                = gameobjectdata;
        }

        let scenestr: string            = JSON.stringify(scenedata);
        let sceneUrl: string            = Paths.getSceneDirectory(project.currentSceneName);
        FileUtils.save(sceneUrl, scenestr, (result: boolean) => {
            message.success('游戏场景'+project.currentSceneName+'保存成功！');
        });
    }

    /**保存当前场景 */
    onSceneSave2() {
        //保存组件
        let project: Project            = Global.currentProject;
        let uiScene: GameUIScene        = project.getGameUIScene(project.currentSceneName);
        let currentScene: els.Scene     = project.currentScene;
        let scenedata: any              = { name: currentScene.name,gameobjects: [] };
        if (currentScene && currentScene.children) {
            for (let i: number = 0, l: number = currentScene.children.length; i < l; i++){
                let gameobject: els.GameObject          = currentScene.children[i];
                let uiGameObject: GameUIObject          = uiScene.getGameObjectByUID(gameobject.UID);
                let gameobjectdata: any                 = { name: gameobject.name, components: [], transform: {} };
                //保存当前变换坐标
                if (uiGameObject) {
                    for (let propkey in uiGameObject.transform) {
                        gameobjectdata.transform[propkey]    = uiGameObject.transform[propkey];
                    }
                }
                
                //保存组件属性
                for (let j: number = 0, jl: number = gameobject.components.length; j < jl; j++){
                    let component: els.Component = gameobject.components[j];
                    
                    let uiComponents: GameUIComponent[] = (uiGameObject) ? uiGameObject.getComponents(component.name) : null;
                    let uiComponent: GameUIComponent    = (uiComponents) ? uiComponents[0] : null;
                    
                    let componentdata: any              = { name: component.name, propertys: (uiComponent) ? uiComponent.propertys : {} };
                    gameobjectdata.components[j]        = componentdata;
                }
                scenedata.gameobjects[i]                = gameobjectdata;
            }
        }
        let scenestr: string            = JSON.stringify(scenedata);
        let sceneUrl: string            = Paths.getSceneDirectory(currentScene.name);
        FileUtils.save(sceneUrl, scenestr, (result: boolean) => {
            message.success('游戏场景'+currentScene.name+'保存成功！');
        });
    }

    //保存项目
    onSaveProject(isNew: boolean = false): void {
        //这里主要保存项目所需要加载的插件系统
        let project: Project            = Global.currentProject;
        if (project) {
            let serializeStr: string    = ProjectUtls.serialize(project);
            FileUtils.save(project.basePath + "\\project.lsp", serializeStr, (result: boolean) => {
                message.success('项目保存成功！');
            });

            //保存场景文件
            this.onSceneSave();

            //如果是初始化创建，那么，创建初始化文件            
            if (isNew) {
                //创建editor
                fs.mkdir(project.basePath + '\\editor', (err) => {
                    console.log('创建编辑器成功！！！');
                    
                });

                //创建运行层
                fs.mkdir(project.basePath + '\\runtime', (err) => {
                    console.log('创建运行层成功！！！');
                });
            }
        }
    }

    //加载项目配置
    onProjectConfigLoad(url: string): void {
        // fs.readFile(url, (err, data) => {
        //     if (err)
        //         throw err;
        //     let jsonObj = JSON.parse(data);
        //     this.onInitProjectInits(jsonObj);
        // }).bind(this);
    }

    //初始化项目配置
    onInitProjectInits(data: any): void {

    }

    private onOpenNewProjectWindow(): void {
        let project: Project = Global.currentProject;
        if (!project) {
            project = new Project();
            Global.currentProject = project;
        }

        if (this._createProjectWindow == null) {
            ReactDOM.render(<CreateProjectWindow ref={self => { this._createProjectWindow = self } } visible={true} />, document.getElementById('model'));
        } else {
            this._createProjectWindow.showModal();
        }
    }
}