var Common = require('Common');
var FocusInfo = require('FocusInfo');
//var AbstractTVFocus=require('AbstractTVFocus');

cc.Class({
    //name:"TVFocus",
    extends: cc.Component,
    //extends: cc.Node,  引擎团队的人不推荐这么做

    properties: {
        _cornerOuterRadius: 18,
        _cornerInnerRadius: 12,
        _screenWidth: Common.SCREEN_WIDTH,
        _screenHeight: Common.SCREEN_HEIGHT,
        _oScene: null,
        //_tvlink:null,
        //sprites:[],
        //nodes:[],
        //isShow:false
        /*
        {
            breath:[],
            cellTransform:[],  //move+scale
            containerTansfer[]
        }
        */
    },
    //由于addComponent时会新建Focus调用默认构造函数，其不支持参数输入，所以这个函数基本没用
    ctor: function (/*strName,oScene,fLeft,fTop,fObjectWidth,fObjectHeight,fScreenWidth,fScreenHeight,fCornerOuterRadius,fCornerInnerRadius*/) {
        //cc.log(this instanceof Sprite);    // true
        //参数处理
        let strName = arguments[0];
        let oScene = arguments[1];
        let fLeft = arguments[2];
        let fTop = arguments[3];
        let fObjectWidth = arguments[4];
        let fObjectHeight = arguments[5];
        let fScreenWidth = arguments[6];
        let fScreenHeight = arguments[7];
        let fCornerOuterRadius = arguments[8];
        let fCornerInnerRadius = arguments[9];
        this.name = (strName ? strName : "focusContainer");
        this._oScene = oScene;
        //this.width=fObjectWidth;
        //this.height=fObjectHeight;
        fLeft = (fLeft ? fLeft : 10);
        fTop = (fTop ? fTop : 10);
        fObjectWidth = (fObjectWidth ? fObjectWidth : 30);
        fObjectHeight = (fObjectHeight ? fObjectHeight : 30);
        this._screenWidth = (fScreenWidth ? fScreenWidth : Common.SCREEN_WIDTH);
        this._screenHeight = (fScreenHeight ? fScreenHeight : Common.SCREEN_HEIGHT);
        this._cornerOuterRadius = (fCornerOuterRadius ? fCornerOuterRadius : 18);
        this._cornerInnerRadius = (fCornerInnerRadius ? fCornerInnerRadius : 12);
        /*
        var oTransformedPosition=this.transformCoordinatesWeb2Cocos(fLeft,fTop,fObjectWidth,fObjectHeight);
        this.node.x=oTransformedPosition.x;
        this.node.y=oTransformedPosition.y;

        var urlFocus=null;
        var textureFocus = null;
        //1 2 3
        //4   6
        //7 8 9
        for (var i=1;i<=9;i++){
            this.node.children[i-1] = new cc.Node('focus_'+i);
            
            if (5==i){
                continue;
            }
            urlFocus = cc.url.raw('Texture/Focus/'+i+'.png');
            textureFocus = cc.textureCache.addImage(urlFocus);
            var spriteTemp = this.node.children[i-1].addComponent(cc.Sprite);
            spriteTemp.spriteFrame = new cc.SpriteFrame(textureFocus);
            //this.node.child[i-1].parent=this.node;
            this.node.children[i-1].x=i*20;

            if (2==i || 8==i){
                spriteTemp.fillType = cc.Sprite.FillType.HORIZONTAL;
            }else if (4==i || 6==i){
                spriteTemp.fillType = cc.Sprite.FillType.VERTICAL;
            }
        }
        //this.fly(fLeft,fTop,fObjectWidth,fObjectHeight,10,1.0);
        */
    },

    init: function (strName, oScene, fiCurrentFocus,//Left,fTop,fObjectWidth,fObjectHeight,
        fScreenWidth, fScreenHeight, fCornerOuterRadius, fCornerInnerRadius, fScaleFactor) {
        //TODO:这个函数里面是否要做onbeforeFocus和onAfterFocus的操作 --question from eva
        //cc.log(this instanceof Sprite);    // true
        if (strName) {
            this.name = strName;
        } else {
            cc.log('No Focus Name Specified');
            return;
        }
        if (oScene) {
            this._oScene = oScene;
        } else {
            cc.log('No Scene Specified for Focus');
        }
        fScaleFactor = fScaleFactor || fiCurrentFocus.getScaleFactor();
        //this.width=fObjectWidth;
        //this.height=fObjectHeight;
        var fLeft = fiCurrentFocus.getLeft();
        var fTop = fiCurrentFocus.getTop();
        var fObjectWidth = fiCurrentFocus.getWidth();
        var fObjectHeight = fiCurrentFocus.getHeight();
        if (fScreenWidth) {
            this._screenWidth = fScreenWidth;
        }
        if (fScreenHeight) {
            this._screenHeight = fScreenHeight;
        }
        if (fCornerOuterRadius) {
            this._cornerOuterRadius = fCornerOuterRadius;
        }
        if (fCornerInnerRadius) {
            this._cornerInnerRadius = fCornerInnerRadius;
        }
        var oTransformedPosition = this.transformCoordinatesWeb2Cocos(fLeft, fTop, fObjectWidth, fObjectHeight);
        this.node.x = oTransformedPosition.x;
        this.node.y = oTransformedPosition.y;
        var urlFocus = null;
        var textureFocus = null;
        //1 2 3
        //4   6
        //7 8 9
        for (var i = 1; i <= 9; i++) {
            //this.node.children[i-1] = new cc.Node('focus_'+i);
            this.node.addChild(new cc.Node('focus_' + i), 10);
            if (5 == i) {
                continue;
            }
            // urlFocus = cc.url.raw('resources/Texture/Focus/'+i+'.png');
            // textureFocus = cc.textureCache.addImage(urlFocus);
            var spriteTemp = this.node.getChildByName('focus_' + i).addComponent(cc.Sprite);
            // spriteTemp.spriteFrame = new cc.SpriteFrame(textureFocus);
            var ftaScaleTo = null
            if (2 == i || 8 == i) {
                //spriteTemp.sizeMode = cc.Sprite.SizeMode.CUSTOM;
                //spriteTemp.type= cc.Sprite.Type.FILLED;
                //spriteTemp.fillType = cc.Sprite.FillType.HORIZONTAL;
                //spriteTemp.width=fObjectWidth-2*fCornerInnerRadius;
                //this.node.children[i-1].width=fObjectWidth-2*fCornerInnerRadius;
                //this.node.children[i-1].height=fCornerOuterRadius;
                ftaScaleTo = cc.scaleTo(0, fScaleFactor * (fObjectWidth - 2 * fCornerInnerRadius), fScaleFactor * 1.0);
            } else if (4 == i || 6 == i) {
                //spriteTemp.sizeMode = cc.Sprite.SizeMode.CUSTOM;
                //spriteTemp.type= cc.Sprite.Type.FILLED;
                //spriteTemp.fillType = cc.Sprite.FillType.VERTICAL;
                //spriteTemp.height=fObjectHeight-2*fCornerInnerRadius;
                //this.node.children[i-1].setContentSize();
                //this.node.children[i-1].width=fCornerOuterRadius;
                //this.node.children[i-1].height=fObjectHeight-2*fCornerInnerRadius;
                ftaScaleTo = cc.scaleTo(0, fScaleFactor * 1.0, fScaleFactor * (fObjectHeight - 2 * fCornerInnerRadius));
            } else {
                ftaScaleTo = cc.scaleTo(0, fScaleFactor, fScaleFactor);
            }
            ftaScaleTo.setTag(Common.FOCUS_CELL_TRANSFER);
            this.node.children[i - 1].stopAllActions();
            this.node.children[i - 1].runAction(ftaScaleTo);
        }
        //TODO:2.0版本采用异步加载本地图片，在焦点初始完成后在批量处理图片
        //TODO:循环中焦点框不是连续的，而批量加载的图地址是连续的需特殊处理下
        var self = this;
        cc.loader.loadResDir("focus", cc.Texture2D, function (err, textures) {
            for (let i = 1; i < 10; i++) {
                if (i == 2 || i == 4 || i == 6 || i == 8) continue;  //暂时将焦点框一部分隐藏
                if (i >= 5) {
                    if (i == 5) continue;
                    self.node.getChildByName('focus_' + i).getComponent(cc.Sprite).spriteFrame = new cc.SpriteFrame(textures[i - 2]);
                } else {
                    self.node.getChildByName('focus_' + i).getComponent(cc.Sprite).spriteFrame = new cc.SpriteFrame(textures[i - 1]);
                }
            }
        });

        this.node.children[0].x = fScaleFactor * (-fObjectWidth / 2 - (fCornerOuterRadius / 2 - fCornerInnerRadius));
        this.node.children[0].y = fScaleFactor * (fObjectHeight / 2 + (fCornerOuterRadius / 2 - fCornerInnerRadius));
        this.node.children[1].x = 0;
        this.node.children[1].y = fScaleFactor * (fObjectHeight / 2 + (fCornerOuterRadius / 2 - fCornerInnerRadius));
        this.node.children[2].x = fScaleFactor * (fObjectWidth / 2 + (fCornerOuterRadius / 2 - fCornerInnerRadius));
        this.node.children[2].y = fScaleFactor * (fObjectHeight / 2 + (fCornerOuterRadius / 2 - fCornerInnerRadius));

        this.node.children[3].x = fScaleFactor * (-fObjectWidth / 2 - (fCornerOuterRadius / 2 - fCornerInnerRadius));
        this.node.children[3].y = 0;
        //this.node.children[4].x=0;
        //this.node.children[4].y=0;
        this.node.children[5].x = fScaleFactor * (fObjectWidth / 2 + (fCornerOuterRadius / 2 - fCornerInnerRadius));
        this.node.children[5].y = 0;

        this.node.children[6].x = fScaleFactor * (-fObjectWidth / 2 - (fCornerOuterRadius / 2 - fCornerInnerRadius));
        this.node.children[6].y = fScaleFactor * (-fObjectHeight / 2 - (fCornerOuterRadius / 2 - fCornerInnerRadius));
        this.node.children[7].x = 0;
        this.node.children[7].y = fScaleFactor * (-fObjectHeight / 2 - (fCornerOuterRadius / 2 - fCornerInnerRadius));
        this.node.children[8].x = fScaleFactor * (fObjectWidth / 2 + (fCornerOuterRadius / 2 - fCornerInnerRadius));
        this.node.children[8].y = fScaleFactor * (-fObjectHeight / 2 - (fCornerOuterRadius / 2 - fCornerInnerRadius));

        //放大 当前选中的Node
        var ftaScaleCurrentFocus = cc.scaleTo(0, fScaleFactor, fScaleFactor);
        ftaScaleCurrentFocus.setTag(Common.FEATURE_NODE_TRANSFER);

        //fiCurrentFocus.node.setLocalZOrder(40);

        //fiCurrentFocus.node.stopAllActions();
        //fiCurrentFocus.node.runAction(ftaScaleCurrentFocus);

        // fiCurrentFocus.node.setLocalZOrder(40);
        fiCurrentFocus.node.zIndex = 40;

        fiCurrentFocus.node.stopAllActions();
        fiCurrentFocus.node.runAction(ftaScaleCurrentFocus);

        //开始呼吸动画
        var aiFocusBreath = cc.repeatForever(cc.sequence(cc.fadeTo(1, 100), cc.fadeTo(1, 255), cc.fadeTo(2, 255)));
        aiFocusBreath.setTag(Common.FOCUS_CONTAINER_BREATH);
        this.node.stopAllActions();
        this.node.runAction(aiFocusBreath);

        this._oScene.setCurrentFocus(fiCurrentFocus);
    },

    // use this for initialization
    onLoad: function () {
        cc.log("Focus onLoad...");
    },
    /*
    test: function(){
        var imgUrl1 = cc.url.raw('Texture/Focus/1.png');
        var texture1 = cc.textureCache.addImage(imgUrl1);
        this.node.getChildByName('focus_'+i).getComponent(cc.Sprite).spriteFrame = new cc.SpriteFrame(texture1);
    },*/

    hide: function () {
        //this.node.opacity=0;
        this.node.children[0].opacity = 0;
        this.node.children[1].opacity = 0;
        this.node.children[2].opacity = 0;
        this.node.children[3].opacity = 0;
        this.node.children[4].opacity = 0;
        this.node.children[5].opacity = 0;
        this.node.children[6].opacity = 0;
        this.node.children[7].opacity = 0;
        this.node.children[8].opacity = 0;
    },
    show: function () {

        //this.node.opacity=255;
        this.node.children[0].opacity = 255;
        this.node.children[1].opacity = 255;
        this.node.children[2].opacity = 255;
        this.node.children[3].opacity = 255;
        this.node.children[4].opacity = 255;
        this.node.children[5].opacity = 255;
        this.node.children[6].opacity = 255;
        this.node.children[7].opacity = 255;
        this.node.children[8].opacity = 255;
    },

    //分别处理9块区域 输入坐标为左上角所需
    fly: function (fLeft, fTop, fObjectWidth, fObjectHeight, fDuration, fScaleFactor) {
        //1 2 3
        //4   6
        //7 8 9
        var oTransformedPosition = this.transformCoordinatesWeb2Cocos(fLeft, fTop, fObjectWidth, fObjectHeight);
        var ftaContainerMoveTo = cc.moveTo(fDuration, oTransformedPosition.x, oTransformedPosition.y);

        ftaContainerMoveTo.setTag(Common.FOCUS_CONTAINER_TRANSFER);

        //var blink=cc.blink(5.0,5);
        //this.node.runAction(blink);
        //this.node.x=oTransformedPosition.x;
        //this.node.y=oTransformedPosition.y;

        var ftaMoveTo = [];
        var ftaScaleTo = null;

        var ftaCombined = [];

        ftaMoveTo[0] = cc.moveTo(fDuration,
            fScaleFactor * (-fObjectWidth / 2 - (this._cornerOuterRadius / 2 - this._cornerInnerRadius)),
            fScaleFactor * (fObjectHeight / 2 + (this._cornerOuterRadius / 2 - this._cornerInnerRadius))
        );

        ftaMoveTo[1] = cc.moveTo(fDuration,
            0,
            fScaleFactor * (fObjectHeight / 2 + (this._cornerOuterRadius / 2 - this._cornerInnerRadius))
        );

        ftaMoveTo[2] = cc.moveTo(fDuration,
            fScaleFactor * (fObjectWidth / 2 + (this._cornerOuterRadius / 2 - this._cornerInnerRadius)),
            fScaleFactor * (fObjectHeight / 2 + (this._cornerOuterRadius / 2 - this._cornerInnerRadius))
        );

        ftaMoveTo[3] = cc.moveTo(fDuration,
            fScaleFactor * (-fObjectWidth / 2 - (this._cornerOuterRadius / 2 - this._cornerInnerRadius)),
            0
        );

        //Nothing should be done for 4

        ftaMoveTo[5] = cc.moveTo(fDuration,
            fScaleFactor * (fObjectWidth / 2 + (this._cornerOuterRadius / 2 - this._cornerInnerRadius)),
            0
        );

        ftaMoveTo[6] = cc.moveTo(fDuration,
            fScaleFactor * (-fObjectWidth / 2 - (this._cornerOuterRadius / 2 - this._cornerInnerRadius)),
            fScaleFactor * (-fObjectHeight / 2 - (this._cornerOuterRadius / 2 - this._cornerInnerRadius))
        );
        ftaMoveTo[7] = cc.moveTo(fDuration,
            0,
            fScaleFactor * (-fObjectHeight / 2 - (this._cornerOuterRadius / 2 - this._cornerInnerRadius))
        );
        ftaMoveTo[8] = cc.moveTo(fDuration,
            fScaleFactor * (fObjectWidth / 2 + (this._cornerOuterRadius / 2 - this._cornerInnerRadius)),
            fScaleFactor * (-fObjectHeight / 2 - (this._cornerOuterRadius / 2 - this._cornerInnerRadius))
        );

        //if (null!=this.node.getActionByTag(Common.FOCUS_CONTAINER_TRANSFER)){
        //    this.node.stopAction(Common.FOCUS_CONTAINER_TRANSFER);
        //}
        //this.node.stopAllActions();

        this.node.stopAction(this.node.getActionByTag(Common.FOCUS_CONTAINER_TRANSFER));
        this.node.runAction(ftaContainerMoveTo);

        for (var i = 1; i <= 9; i++) {
            if (5 == i) {
                continue;
            }
            if (2 == i || 8 == i) {
                ftaScaleTo = cc.scaleTo(fDuration, fScaleFactor * (fObjectWidth - 2 * this._cornerInnerRadius), fScaleFactor * 1.0);
            } else if (4 == i || 6 == i) {
                ftaScaleTo = cc.scaleTo(fDuration, fScaleFactor * 1.0, fScaleFactor * (fObjectHeight - 2 * this._cornerInnerRadius));
            } else {
                ftaScaleTo = cc.scaleTo(fDuration, fScaleFactor, fScaleFactor);
            }
            ftaCombined[i - 1] = cc.spawn(ftaMoveTo[i - 1], ftaScaleTo);
            ftaCombined[i - 1].setTag(Common.FOCUS_CELL_TRANSFER);
            /*
            if (null!=this.node.children[i-1].getActionByTag(Common.FOCUS_CELL_TRANSFER)){
                this.node.children[i-1].stopAction(Common.FOCUS_CELL_TRANSFER);
            }*/
            //this.node.stopAllActions();
            this.node.children[i - 1].stopAction(this.node.children[i - 1].getActionByTag(Common.FOCUS_CELL_TRANSFER));
            this.node.children[i - 1].runAction(ftaCombined[i - 1]);
        }
    },

    findTarget: function (oCurrentFocusInfo, aInFocusTargets, iStatus, iDirection) {

        if (null == oCurrentFocusInfo) {
            oCurrentFocusInfo = this._oScene.getCurrentFocusInfo();
        }
        if (null == aInFocusTargets) {
            aInFocusTargets = this._oScene.getFocusTargets()
        }
        var aFocusTargets = aInFocusTargets[iStatus];
        //var elFocusNow=document.getElementById(g_strFocusElementId);
        var fCurrentLeft = oCurrentFocusInfo.getLeft();
        var fCurrentTop = oCurrentFocusInfo.getTop();
        var fCurrentWidth = oCurrentFocusInfo.getWidth();
        var fCurrentHeight = oCurrentFocusInfo.getHeight();

        var oFocusTarget = null;  //node?
        var fDirectionWeight = 5.0;
        var fEvaluationRecord = 99999;

        //决定要搞哪一个
        var j = 0;
        if (Common.MOVE_DIRECTION_UP <= iDirection && iDirection <= Common.MOVE_DIRECTION_LEFT) {
            for (var key in aFocusTargets) { //for (var i=0;i<aFocusTargets.length;i++){
                // cc.log("循环次数："+j+++"/////"+key);
                //if (aFocusTargets[i].id == g_strFocusElementId || !doesElementDisplay(aFocusTargets[i])) continue;
                // cc.log(key + "=============" + aFocusTargets[key].name);

                if (!cc.isValid(aFocusTargets[key])) continue;      //TODO-jinwawa:注意有些节点已经destroy,但是实际销毁操作会延迟到当前帧渲染前执行，从下一帧开始，该对象将不再可用
                                                                    //              故使用cc.isValid(obj)来检查对象是否已被销毁

                let fiByKey = aFocusTargets[key].getComponent(FocusInfo);

                if (!fiByKey.getEnable()) {//不显示的不参与寻找 
                    continue;
                }

                var fTargetLeft = fiByKey.getLeft();
                var fTargetTop = fiByKey.getTop();
                var fTargetWidth = fiByKey.getWidth();
                var fTargetHeight = fiByKey.getHeight();
                // cc.log("循环中目标左边距："+fTargetLeft);
                // cc.log("循环中目标上边距:"+fTargetTop);

                //权重计算   移动方向上距离*3+和移动方向垂直的方向中心距离差 的和最小为最近控件
                var fDistanceOfEdge = 0.0; //移动方向边缘的距离
                var fOffsetOfCenter = 0.0; //垂直移动方向两块区域中心的距离
                var fOverlapWidth = 0.0;  //在移动方向上重叠的距离 复数为不重叠
                var fSmallEdgeWidth = 0.0; //短的那个边缘的宽度

                if (true) { //如果目标在限制区域内
                    switch (iDirection) {
                        case Common.MOVE_DIRECTION_UP:
                            // cc.log("参数:"+fCurrentTop+"///"+fTargetTop+"///"+fTargetHeight);
                            fDistanceOfEdge = fCurrentTop - fTargetTop - fTargetHeight;
                            fOffsetOfCenter = Math.abs(fTargetLeft + fTargetWidth / 2 - fCurrentLeft - fCurrentWidth / 2);
                            fOverlapWidth = ((fCurrentLeft + fCurrentWidth - fTargetLeft - fTargetWidth >= 0) ? fTargetLeft + fTargetWidth : fCurrentLeft + fCurrentWidth)
                                - ((fCurrentLeft - fTargetLeft >= 0) ? fCurrentLeft : fTargetLeft);
                            fSmallEdgeWidth = (fCurrentWidth < fTargetWidth) ? fCurrentWidth : fTargetWidth;
                            break;
                        case Common.MOVE_DIRECTION_DOWN:
                            fDistanceOfEdge = fTargetTop - fCurrentTop - fCurrentHeight;
                            fOffsetOfCenter = Math.abs(fTargetLeft + fTargetWidth / 2 - fCurrentLeft - fCurrentWidth / 2);
                            fOverlapWidth = ((fCurrentLeft + fCurrentWidth - fTargetLeft - fTargetWidth >= 0) ? fTargetLeft + fTargetWidth : fCurrentLeft + fCurrentWidth)
                                - ((fCurrentLeft - fTargetLeft >= 0) ? fCurrentLeft : fTargetLeft);
                            fSmallEdgeWidth = (fCurrentWidth < fTargetWidth) ? fCurrentWidth : fTargetWidth;
                            break;
                        case Common.MOVE_DIRECTION_LEFT:
                            fDistanceOfEdge = fCurrentLeft - fTargetLeft - fTargetWidth;
                            fOffsetOfCenter = Math.abs(fTargetTop + fTargetHeight / 2 - fCurrentTop - fCurrentHeight / 2);
                            fOverlapWidth = ((fCurrentTop + fCurrentHeight - fTargetTop - fTargetHeight >= 0) ? fTargetTop + fTargetHeight : fCurrentTop + fCurrentHeight)
                                - ((fCurrentTop - fTargetTop >= 0) ? fCurrentTop : fTargetTop);
                            fSmallEdgeWidth = (fCurrentHeight < fTargetHeight) ? fCurrentHeight : fTargetHeight;
                            break;
                        case Common.MOVE_DIRECTION_RIGHT:
                            fDistanceOfEdge = fTargetLeft - fCurrentLeft - fCurrentWidth;
                            fOffsetOfCenter = Math.abs(fTargetTop + fTargetHeight / 2 - fCurrentTop - fCurrentHeight / 2);
                            fOverlapWidth = ((fCurrentTop + fCurrentHeight - fTargetTop - fTargetHeight >= 0) ? fTargetTop + fTargetHeight : fCurrentTop + fCurrentHeight)
                                - ((fCurrentTop - fTargetTop >= 0) ? fCurrentTop : fTargetTop);
                            fSmallEdgeWidth = (fCurrentHeight < fTargetHeight) ? fCurrentHeight : fTargetHeight;
                            break;
                    }

                    // cc.log(fiByKey.node.name + "///////////////////估值" + fTargetLeft + "::" + fCurrentLeft + "::" + fCurrentWidth);
                    if (fDistanceOfEdge >= 0 /*&& fOffsetOfCenter<g_iBlockWidth*/) { //目标位置要在我前进的一侧(移动方向不能重叠),并且不能太偏离中心
                        // cc.log("fDistanceOfEdge>=0");
                        //估值=距离目标的邻边垂直距离*方向权重+重心所在轴偏移量
                        var fEvaluation = -100 * (fOverlapWidth / fSmallEdgeWidth) + fDistanceOfEdge;
                        //cc.log(aFocusTargets[i].id+"==>  "+fEvaluation+"  =-20*("+fSmallEdgeWidth+"/"+fOverlapWidth+")"+"+"+fDistanceOfEdge);
                        //+fOffsetOfCenter*fDirectionWeight;
                        if (fEvaluationRecord > fEvaluation) {
                            // cc.log(fEvaluationRecord+"/////"+fEvaluation);
                            fEvaluationRecord = fEvaluation;
                            //elFormerTarget=elFocusTarget;
                            //oFocusTarget=aFocusTargets[key];
                            oFocusTarget = fiByKey;
                        }
                    }
                }
                //elFocusTarget=FindNearestFocusTarget(strDirection,fFocusLeft,fFocusTop,fFocusWidth,fFocusHeight,fLeft,fTop,fWidth,fHeight);
            }

            //Log.warning("["+(elFormerTarget?elFormerTarget.id:"null")+","+(elFocusTarget?elFocusTarget.id:"null")+"]");    

            if (null == oFocusTarget) { //找不到目标 不移动，一般到了边界
                cc.log("No Target Found: oFocusTarget = null...");
                return null;
            }
        } else {
            cc.log("No Target Found: unavailable direction");
            return null
        }
        return oFocusTarget;

    },

    transformCoordinatesWeb2Cocos: function (fLeft, fTop, fObjectWidth, fObjectHeight) {
        var oCocosCoordinates = {};

        oCocosCoordinates.x = fLeft + fObjectWidth / 2 - this._screenWidth / 2;
        oCocosCoordinates.y = this._screenHeight / 2 - fObjectHeight / 2 - fTop;
        return oCocosCoordinates;
    },

    flyFocus: function (fiCurrentFocus, fiFocusTarget, iDirection, fScaleFactor, oScrollParameter, iDuration) {
        if (null == fiFocusTarget) {//todo:先判断这个是否更划得来
            //找不到目标的动画小交互
            //var blink1=cc.blink(0.6,20);
            //this.node.runAction(blink1);

            let aiJoggle = cc.repeat(
                cc.sequence(
                    cc.rotateTo(0.02, -2),
                    cc.rotateTo(0.02, 0),
                    cc.rotateTo(0.02, 2),
                    cc.rotateTo(0.02, 0)
                ),
                4
            );
            aiJoggle.setTag(Common.FOCUS_CONTAINER_JOGGLE);
            //if (null!=this.node.getActionByTag(Common.FOCUS_CONTAINER_JOGGLE)){
            //    this.node.stopAction(Common.FOCUS_CONTAINER_JOGGLE);
            //}
            this.node.stopAction(this.node.getActionByTag(Common.FOCUS_CONTAINER_JOGGLE));
            this.node.runAction(aiJoggle);
            return 0;
        }

        if (null == fiCurrentFocus) {
            fiCurrentFocus = this._oScene.getCurrentFocusInfo();
        }

        fScaleFactor = fScaleFactor || fiFocusTarget.getScaleFactor();
        if (null == fScaleFactor) {
            fScaleFactor = 1.0;
        }

        if (null == iDuration) {
            iDuration = Common.FOCUS_FLY_DURATION;
        }

        //是否是有效方向
        if (Common.MOVE_DIRECTION_UP <= iDirection && iDirection <= Common.MOVE_DIRECTION_LEFT) {
            //滚屏相关参数 elScroll,iScrollStep 如果都有效开始处理滚屏
            //oScrollParameter.element   需要滚动的元素 Object[Element]
            //oScrollParameter.step      滚动的距离 Integer
            //oScrollParameter.relation  滚动是否和焦点元素有关?  Integer [0|1]
            //oScrollParameter.direction 滚动方向  ['left'|'right'|'up'|'down']

            //旧的时间通知
            //this.node.dispachEvent('before_focus_change', { from: fiCurrentFocus, to: fiFocusTarget});
            let eventBeforeFocus = new cc.Event.EventCustom('before_focus_change', true);
            eventBeforeFocus.setUserData({ from: fiCurrentFocus, to: fiFocusTarget });
            this.node.dispatchEvent(eventBeforeFocus);

            let eventOnBlur = new cc.Event.EventCustom('blur', true);
            eventOnBlur.setUserData({ from: fiCurrentFocus, to: fiFocusTarget });
            this.node.dispatchEvent(eventOnBlur);
            //let eventOnFocus=new cc.Event.
            let nodeCurrent = fiCurrentFocus.node;//node;
            let nodeTarget = fiFocusTarget.node;//node;
            //if (fiCurrentFocus && fiCurrentFocus.onBlur && typeof fiCurrentFocus.onBlur =='function' ){
            //   fiCurrentFocus.onBlur();
            //}
            //处理因焦点移动导致的部分界面滑动
            let fXScrollStep = 0;
            let fYScrollStep = 0;
            let fXScrollTarget = 0; //新方法
            let fYScrollTarget = 0; //新方法
            if (null != oScrollParameter && null != oScrollParameter.node
                && null != oScrollParameter.getStep() && null != oScrollParameter.getHasRelation()) {  //满足此条件才考虑界面滚动
                //MOVE_DIRECTION_UP:0,
                //MOVE_DIRECTION_RIGHT:1,
                //MOVE_DIRECTION_DOWN:2,
                //MOVE_DIRECTION_LEFT:3,
                //默认反向
                if (null == oScrollParameter.getDirection()) {
                    switch (iDirection) {
                        case Common.MOVE_DIRECTION_UP: oScrollParameter.setDirection(Common.MOVE_DIRECTION_DOWN); break;
                        case Common.MOVE_DIRECTION_RIGHT: oScrollParameter.setDirection(Common.MOVE_DIRECTION_LEFT); break;
                        case Common.MOVE_DIRECTION_DOWN: oScrollParameter.setDirection(Common.MOVE_DIRECTION_UP); break;
                        case Common.MOVE_DIRECTION_LEFT: oScrollParameter.setDirection(Common.MOVE_DIRECTION_RIGHT); break;
                    }
                }
                //Deprecated Start 
                switch (oScrollParameter.getDirection()) {
                    case Common.MOVE_DIRECTION_UP:
                        fYScrollStep = oScrollParameter.getStep();
                        break;
                    case Common.MOVE_DIRECTION_DOWN:
                        fYScrollStep = -oScrollParameter.getStep();
                        break;
                    case Common.MOVE_DIRECTION_LEFT:
                        fXScrollStep = -oScrollParameter.getStep();
                        break;
                    case Common.MOVE_DIRECTION_RIGHT:
                        fXScrollStep = oScrollParameter.getStep();
                        break;

                }
                //let ftaMoveToScrollParameter = cc.moveTo(iDuration, 
                //                   oScrollParameter.node.x+fXScrollStep,
                //                    oScrollParameter.node.y-fYScrollStep
                //                );
                //Deprecated End
                switch (oScrollParameter.getDirection()) { //正负在外面算好了
                    case Common.MOVE_DIRECTION_UP:
                        fYScrollTarget = oScrollParameter.getTargetPosition();
                        break;
                    case Common.MOVE_DIRECTION_DOWN:
                        fYScrollTarget = oScrollParameter.getTargetPosition();
                        break;
                    case Common.MOVE_DIRECTION_LEFT:
                        fXScrollTarget = oScrollParameter.getTargetPosition();
                        break;
                    case Common.MOVE_DIRECTION_RIGHT:
                        fXScrollTarget = oScrollParameter.getTargetPosition();
                        break;

                }
                let finished = cc.callFunc((oScrollParameter.callback ? oScrollParameter.callback : function () {
                    cc.log("do something");
                }), this, oScrollParameter.scope);//todo:这里是否考虑要个回调
                let ftaMoveToScrollParameter = cc.sequence(cc.moveTo(iDuration, fXScrollTarget, fYScrollTarget), finished);

                ftaMoveToScrollParameter.setTag(Common.SCROLL_BY_FOCUS_CHANGE);
                oScrollParameter.node.stopAction(oScrollParameter.node.getActionByTag(Common.SCROLL_BY_FOCUS_CHANGE));
                //oScrollParameter.node.stopAllActions();
                oScrollParameter.node.runAction(ftaMoveToScrollParameter);
                oScrollParameter.setDirection(null);
                //oScrollParameter.node.x+=fXScrollStep;
                //oScrollParameter.node.y-=fYScrollStep;
            }

            //由于浮点数变成坐标必须取整所以不可避免会形成误差，其中的+1 -1为了保证边框不留空隙
            //Target会比边框稍大

            //let fDestFocusLeft = iScaledTargetLeft - g_iFocusFrameWidth  + iXScrollStep + "px";
            //let fDestFocusTop = iScaledTargetTop - g_iFocusFrameHeight  + iYScrollStep + "px";
            //let fDestFocusWidth = iScaledTargetWidth + 2 * g_iFocusFrameWidth + "px";
            //let fDestFocusHeight = iScaledTargetHeight + 2 * g_iFocusFrameHeight + "px";

            //只要改掉相对Left Top 就可
            //此处需很小心处理和上下代码的关系
            /*
            if (null != oScrollParameter && null != oScrollParameter.node
                && null != oScrollParameter.getStep() && null != oScrollParameter.getHasRelation()) {  //满足此条件才考虑界面滚动
                let sizeVisible = cc.Director.getVisibleSize();
                let fDestScrollElementLeft = oScrollParameter.node.x + fXScrollStep;
                let fDestScrollElementTop = sizeVisible.height - oScrollParameter.node.y + fYScrollStep;

                //这里还缺少动画 必须一起开始动
                oScrollParameter.node.x=fDestScrollElementLeft;
                oScrollParameter.node.y=oScrollParameter.node.y - fYScrollStep;
            }*/

            //准备好了所有数据  这里开始一起行动
            //if (g_fnOnBeforeFocusChange) {
            //  g_fnOnBeforeFocusChange(elFocusNow, elFocusTarget, strDirection);
            //}

            //按比例将焦点目标的区域进行缩放 得注意浮点数的问题

            let ftaScaleCurrentFocus = cc.scaleTo(iDuration, 1.0, 1.0);
            let ftaScaleFocusTarget = cc.scaleTo(iDuration, fScaleFactor, fScaleFactor);

            /*
            log("ArchorPoint:%f,%f,%f,%f", pfiCurrentFocus->node->getAnchorPoint().x, 
                pfiCurrentFocus->node->getAnchorPoint().y,
                pfiCurrentFocus->node->getAnchorPointInPoints().x,
                pfiCurrentFocus->node->getAnchorPointInPoints().y );
            */
            /*
            //红点测试
            auto sprite1 = cocos2d::Sprite::create("image/red_point.png");
            sprite1->setPosition(0,0
                //  pfiCurrentFocus->node->getAnchorPointInPoints().x
                //, pfiCurrentFocus->node->getAnchorPointInPoints().y);
            
            pfiCurrentFocus->node->addChild(sprite1, 20, "PointFlag");
            */

            // nodeCurrent.setLocalZOrder(10);
            // nodeTarget.setLocalZOrder(40);
            nodeCurrent.zIndex = 10;
            nodeTarget.zIndex = 40;

            ftaScaleCurrentFocus.setTag(Common.FEATURE_NODE_TRANSFER);
            ftaScaleFocusTarget.setTag(Common.FEATURE_NODE_TRANSFER);
            //if (null!=nodeCurrent.getActionByTag(Common.FEATURE_NODE_TRANSFER)){
            //    nodeCurrent.stopAction(Common.FEATURE_NODE_TRANSFER);    
            //}
            //if (null!=nodeTarget.getActionByTag(Common.FEATURE_NODE_TRANSFER)){
            //    nodeTarget.stopAction(Common.FEATURE_NODE_TRANSFER);    
            //}
            nodeCurrent.stopAction(nodeCurrent.getActionByTag(Common.FEATURE_NODE_TRANSFER));
            nodeTarget.stopAction(nodeTarget.getActionByTag(Common.FEATURE_NODE_TRANSFER));
            nodeCurrent.runAction(ftaScaleCurrentFocus);
            nodeTarget.runAction(ftaScaleFocusTarget);
            cc.log(fiFocusTarget.getLeft());
            cc.log(fiFocusTarget.getTop());
            this.fly(fiFocusTarget.getLeft() + fXScrollStep, fiFocusTarget.getTop() + fYScrollStep,
                fiFocusTarget.getWidth(), fiFocusTarget.getHeight(),
                iDuration, fScaleFactor);
            //if (fiTarget.onFocus && typeof fiTarget.onFocus =='function' ){
            //    fiTarget.onFocus();
            //}
            let eventOnFocus = new cc.Event.EventCustom('focus', true);
            eventOnFocus.setUserData({ from: fiCurrentFocus, to: fiFocusTarget });
            this.node.dispatchEvent(eventOnFocus);
            //旧的事件通知
            //this.node.emit('after_focus_change', { from: fiCurrentFocus, to: fiFocusTarget});
            let eventAfterFocus = new cc.Event.EventCustom('after_focus_change', true);
            eventAfterFocus.setUserData({ from: fiCurrentFocus, to: fiFocusTarget });
            this.node.dispatchEvent(eventAfterFocus);
            //新的事件通知方式 是否科学有待检验
            //let eventFocusLeave=new cc.Event.EventCustom('focus_leave',true);
            //eventFocusLeave.setUserData({from:fiCurrentFocus,to:fiFocusTarget});
            //nodeCurrent.dispatchEvent(eventFocusLeave);

            //let eventFocusHover=new cc.Event.EventCustom('focus_hover',true);
            //eventFocusHover.setUserData({from:fiCurrentFocus,to:fiFocusTarget});
            //nodeTarget.dispatchEvent(eventFocusHover);
            this._oScene.setCurrentFocus(fiFocusTarget);
            //计算完成以下开始完成所有动作
            //elFocusNow.style.zIndex = 0;
            //elFocusTarget.style.zIndex = 20;
            /*
            var elFocusContainer = document.getElementById("focus_container");
            //document.getElementById('view_port').style.left = destViewPortLeft;
            elFocusContainer.style.left = destFocusLeft;
            elFocusContainer.style.top = destFocusTop;
            //document.getElementById("focus5").style.width = destFocusWidth;
            //document.getElementById("focus5").style.height = destFocusHeight;
            elFocusContainer.style.width = destFocusWidth;
            elFocusContainer.style.height = destFocusHeight;
            */
            //if (g_fnOnAfterFocusChange) {
            //  g_fnOnAfterFocusChange(elFocusNow, elFocusTarget, strDirection);
            //}
            //总要先将前面那个复原
            //scaleElement(g_strFocusElementId, 1, 1);
            //g_strFocusElementId = elFocusTarget.id;
            return 1;
        } else {
            cc.log("No Target Found to Fly: Unavailable Direction");
            return 0;
        }
    },


    jumpFocus: function (fiCurrentFocus, fiFocusTarget, iDirection, fScaleFactor, oScrollParameter) {
        if (null == fiFocusTarget) {
            //找不到目标的动画小交互
            //var blink1=cc.blink(0.6,20);
            //this.node.runAction(blink1);
            let aiJoggle = cc.repeat(
                cc.sequence(
                    cc.rotateTo(0.02, -2),
                    cc.rotateTo(0.02, 0),
                    cc.rotateTo(0.02, 2),
                    cc.rotateTo(0.02, 0)
                ),
                4
            );
            aiJoggle.setTag(Common.FOCUS_CONTAINER_JOGGLE);
            this.node.stopAction(this.node.getActionByTag(Common.FOCUS_CONTAINER_JOGGLE));
            this.node.runAction(aiJoggle);
            return 0;
        }
        fScaleFactor = fScaleFactor || fiFocusTarget.getScaleFactor();
        //是否是有效方向
        if (Common.MOVE_DIRECTION_UP <= iDirection && iDirection <= Common.MOVE_DIRECTION_LEFT) {
            //let eventBeforeFocus=new cc.Event.EventCustom('before_focus_change', true);
            //eventBeforeFocus.setUserData({ from: fiCurrentFocus, to: fiFocusTarget});
            //this.node.dispatchEvent(eventBeforeFocus);
            //处理因焦点移动导致的部分界面滑动
            let fXScrollStep = 0;
            let fYScrollStep = 0;

            var ftaScaleCurrentFocus = cc.scaleTo(Common.FOCUS_FLY_DURATION, 1.0, 1.0);
            var ftaScaleFocusTarget = cc.scaleTo(Common.FOCUS_FLY_DURATION, fScaleFactor, fScaleFactor);

            var nodeCurrent = fiCurrentFocus.node;//node;
            var nodeTarget = fiFocusTarget.node;//node;

            nodeCurrent.setLocalZOrder(10);
            nodeTarget.setLocalZOrder(40);

            ftaScaleCurrentFocus.setTag(Common.FEATURE_NODE_TRANSFER);
            ftaScaleFocusTarget.setTag(Common.FEATURE_NODE_TRANSFER);

            nodeCurrent.stopAction(nodeCurrent.getActionByTag(Common.FEATURE_NODE_TRANSFER));
            nodeTarget.stopAction(nodeTarget.getActionByTag(Common.FEATURE_NODE_TRANSFER));

            nodeCurrent.runAction(ftaScaleCurrentFocus);
            nodeTarget.runAction(ftaScaleFocusTarget);

            this.fly(fiFocusTarget.getLeft(), fiFocusTarget.getTop(),
                fiFocusTarget.getWidth(), fiFocusTarget.getHeight(),
                0, fScaleFactor
            );
            //旧的事件通知
            //this.node.emit('after_focus_change', { from: fiCurrentFocus, to: fiFocusTarget});
            let eventAfterFocus = new cc.Event.EventCustom('after_focus_change', true);
            eventAfterFocus.setUserData({ from: fiCurrentFocus, to: fiFocusTarget });
            this.node.dispatchEvent(eventAfterFocus);

            //新的事件通知方式 是否科学有待检验
            //let eventFocusLeave=new cc.Event.EventCustom('focus_leave',true);
            //eventFocusLeave.setUserData({from:fiCurrentFocus,to:fiFocusTarget});
            //nodeCurrent.dispatchEvent(eventFocusLeave);

            //let eventFocusHover=new cc.Event.EventCustom('focus_hover',true);
            //eventFocusHover.setUserData({from:fiCurrentFocus,to:fiFocusTarget});
            //nodeTarget.dispatchEvent(eventFocusHover);

            this._oScene.setCurrentFocus(fiFocusTarget);

            return 1;

        } else {
            cc.log("No Target Found to Fly: Unavailable Direction");
            return 0;
        }
    },

    //跳向一个未来某一刻才会出现的Focus
    flyFocus2Fantasy: function (fiCurrentFocus, fiFocusTarget, iDirection, fScaleFactor, oScrollParameter) {

    },

    getCornerOuterRadius: function () {
        return this._cornerOuterRadius;
    },
    setCornerOuterRadius: function (cornerOuterRadius) {
        this._cornerOuterRadius = cornerOuterRadius;
    },
    getCornerInnerRadius: function () {
        return this._cornerInnerRadius;
    },
    setCornerInnerRadius: function (cornerInnerRadius) {
        this._cornerInnerRadius = cornerInnerRadius;
    },

    // called every frame, uncomment this function to activate update callback
    // update: function (dt) {

    // },
});