import { SceneTargetTransformer } from './SceneTargetTransformer';
import { MessageUtils } from '../../../module/message/MessageUtils';
import { PropertyMessage } from '../../../module/property/events/PropertyMessage';
import { Global } from '../../../utils/Global';
export enum PointType {
    TOP, BOTTOM, LEFT, RIGHT, LEFT_TOP, RIGHT_TOP, RIGHT_BOTTOM, LEFT_BOTTOM
}

export class Transformer extends egret.Sprite {
    private _selectlist: els.GameObject[];
    private maps: any;
    private parentContainer: egret.Sprite;
    private touchDown: boolean;
    private rect: egret.Rectangle;
    private oldTouchX: number;
    private oldTouchY: number;
    private _currentSelect: els.GameObject;
    private _selectTouchDown: boolean;
    private _selectTouchOffsetX: number;
    private _selectTouchOffsetY: number;
    private _selectOldTouchX: number;
    private _selectOldTouchY: number;
    onSelect: Function;
    constructor() {
        super();
        this._selectlist    = [];
        this.maps           = {};
        this.rect           = new egret.Rectangle();
        this.addEventListener(egret.Event.ADDED_TO_STAGE, (event) => { 
            this.stage.addEventListener(egret.TouchEvent.TOUCH_BEGIN, this.onTouchBegin, this);
        }, this);
    }

    register(list:els.GameObject[]) {
        if (!list) return;
        for (let i: number = 0, l: number = list.length; i < l; i++){
            let gameobject: els.GameObject = list[i];
            if (this.maps[gameobject.id] === undefined) {
                let transformer: SceneTargetTransformer = new SceneTargetTransformer();
                transformer.target  = gameobject;
                gameobject.onUpdate = () => {
                    transformer.update();
                }
                transformer.visible = false;
                this.addChild(transformer);     
                this.maps[gameobject.id] = { gameobject: gameobject, transformer: transformer };

                if (gameobject.rendererComponent && gameobject.rendererComponent.renderer) {
                    gameobject.rendererComponent.renderer.addEventListener(egret.TouchEvent.TOUCH_BEGIN, this.onGameObjectTouchEvent, this);
                    gameobject.rendererComponent.renderer.stage.addEventListener(egret.TouchEvent.TOUCH_MOVE, this.onGameObjectTouchEvent, this);
                    gameobject.rendererComponent.renderer.stage.addEventListener(egret.TouchEvent.TOUCH_END, this.onGameObjectTouchEvent, this);
                }
            }
        }
    }

    onTouchBegin(event: egret.TouchEvent) {
        if (this.canSelect(event.stageX, event.stageY)) return;
        this.touchDown  = true;
        this.oldTouchX  = this.rect.x = event.stageX;
        this.oldTouchY  = this.rect.y = event.stageY;
        this.stage.addEventListener(egret.TouchEvent.TOUCH_MOVE, this.onTouchMove, this);
        this.stage.addEventListener(egret.TouchEvent.TOUCH_END, this.onTouchEnd, this);
    }

    onTouchMove(event: egret.TouchEvent) {
        this.graphics.clear();
        this.graphics.lineStyle(1, 0x00debc);
        this.graphics.beginFill(0x00debc, 0.2);
        this.rect.width     = Math.abs(event.stageX - this.oldTouchX);
        this.rect.height    = Math.abs(event.stageY - this.oldTouchY);
        this.rect.x         = (event.stageX < this.oldTouchX) ? event.stageX : this.oldTouchX;
        this.rect.y         = (event.stageY < this.oldTouchY) ? event.stageY : this.oldTouchY;
        this.graphics.drawRect(this.rect.x, this.rect.y, this.rect.width, this.rect.height);
        this.graphics.endFill();
    }

    onTouchEnd(event: egret.TouchEvent) {
        this.touchDown = false;
        this.graphics.clear();
        this.stage.removeEventListener(egret.TouchEvent.TOUCH_MOVE, this.onTouchMove, this);
        this.stage.removeEventListener(egret.TouchEvent.TOUCH_END, this.onTouchEnd, this);

        //检测有多少对象需要选择
        let scene: els.Scene                = Global.currentProject.currentScene;
        let _intersects: els.GameObject[]   = [];
        for (let i: number = 0, l: number   = scene.children.length; i < l; i++){
            let gameobject: els.GameObject  = scene.children[i];
            let bounds: egret.Rectangle     = gameobject.getTransformedBounds(this.stage);
            if (bounds && this.rect.intersects(bounds)) {
                _intersects.push(gameobject);
            }
        } 
        this.rect.setEmpty();
        this.selectlist = _intersects;
        if (_intersects.length > 0) {
            if (this.onSelect)
                this.onSelect(_intersects[0]);    
        }
    }

    private canSelect(stageX: number, stageY: number): boolean {
        //检测变换点是否被按下
        for (let id in this.maps) {
            if (this.maps[id].transformer.isTouchDown)
                return true;    
        }
        let scene: els.Scene                = Global.currentProject.currentScene;
        let _intersects: els.GameObject[]   = [];
        for (let i: number = 0, l: number   = scene.children.length; i < l; i++){
            let gameobject: els.GameObject  = scene.children[i];
            let bounds: egret.Rectangle     = gameobject.getTransformedBounds(this.stage);
            if (bounds && bounds.contains(stageX, stageY)) {
                return true;
            }
        } 
        return false;
    }

    private onGameObjectTouchEvent(event: egret.TouchEvent) {
        switch (event.type) {
            case egret.TouchEvent.TOUCH_BEGIN:
                this._selectTouchDown       = true;    
                this._currentSelect         = (event.currentTarget as els.Component).gameobject as els.GameObject;
                this._selectTouchOffsetX    = event.stageX - this._currentSelect.x;
                this._selectTouchOffsetY    = event.stageY - this._currentSelect.y;
                if (!this.isSelect(this._currentSelect)) {
                    this.selectlist         = [this._currentSelect];
                }
                this.addChild(this.maps[this._currentSelect.id].transformer);
                this._selectOldTouchX       = this._currentSelect.x;
                this._selectOldTouchY       = this._currentSelect.y;
                MessageUtils.send(PropertyMessage.SHOW_GAMEOBJECT_PROPERTY, this._currentSelect);
                break;
                
            case egret.TouchEvent.TOUCH_MOVE:
                if (this._selectTouchDown) {
                    this._currentSelect.x = event.stageX - this._selectTouchOffsetX;
                    this._currentSelect.y = event.stageY - this._selectTouchOffsetY;
                    let dx: number = this._currentSelect.x - this._selectOldTouchX;
                    let dy: number = this._currentSelect.y - this._selectOldTouchY;
                    //其它选择对象
                    for (let i: number = 0, l: number = this._selectlist.length; i < l; i++){
                        var _select: els.GameObject = this._selectlist[i];
                        if (_select != this._currentSelect) {
                            _select.x += dx;
                            _select.y += dy;
                        }
                    }
                    this._selectOldTouchX = this._currentSelect.x;
                    this._selectOldTouchY = this._currentSelect.y;
                    MessageUtils.send(PropertyMessage.UPDATE_TRANSFORM_PROPERTY, { target: this._currentSelect, propertys: { x: this._currentSelect.x, y: this._currentSelect.y } });
                }
                break;

            case egret.TouchEvent.TOUCH_END:
                this._selectTouchDown = false;
                break;
        }
    }

    get selectlist() {
        return this._selectlist;
    }

    /**
     * 检测当前对象是否选择
     */
    isSelect(gameobject: els.GameObject): boolean{
        if (!gameobject) return false;
        for (let i: number = 0, l: number = this._selectlist.length; i < l; i++){
            if (this._selectlist[i].id === gameobject.id)
                return true;    
        }
        return false;
    }

    set selectlist(value: els.GameObject[]) {
        if (this._selectlist) {
            for (let i: number = 0, l: number = this._selectlist.length; i < l; i++){
                let gameobject: els.GameObject = this._selectlist[i];
                if(this.maps[gameobject.id])
                    this.maps[gameobject.id].transformer.visible = false;
            }
        }
        if (this._selectlist != value) {
            this._selectlist = value;
            for (let i: number = 0, l: number = value.length; i < l; i++) {
                let gameobject: els.GameObject = value[i];
                if(this.maps[gameobject.id])
                    this.maps[gameobject.id].transformer.visible = true;
            }
        }
    }

    add(value: els.GameObject) {
        if (!value || !this._selectlist) return;
        let index: number = this._selectlist.indexOf(value);
        if (index === -1) {
            this._selectlist.push(value);
        }
    }

    remove(value: els.GameObject) {
        if (!value || !this._selectlist) return;
        let index: number = this._selectlist.indexOf(value);
        if (index !== -1) {
            this._selectlist.splice(index, 1);
        }
    }

    removeAll() {
        this._selectlist.length = 0;
        this.maps = {};
    }

    removeAt(index: number) {
        let gameobject: els.GameObject = this._selectlist[index];
        this._selectlist.splice(index, 1);
    }
}