// @author: xxx@syg.com(必填, 创建模块的人员)
// --------------------------------------------------------------------
// @description:
//      战斗控制器
// <br/>Create: 2018-11-28 19:19:19
// --------------------------------------------------------------------
const BridgeController = require( "bridge.controller" );
const BattleEvent = require( "battle_event" );
const BattleConst = require( "battle_const" );
const MainuiEvent = require( "mainui_event" );
const BattleRolePool = require( "battle_role_pool" );
const FID = require( "bridge.function.ids" );

const BattleController = cc.Class( {

    extends: BridgeController,

	name: "BattleController",

    // 销毁
    onDestroy: function() {

        // 强制清除scene
        this.openDramaFightUI( false );
        this.model.closeFormView();
        this.clearBattleScene();
        if( BattleRolePool.getInstance ) {
            BattleRolePool.getInstance().clearCachePool();
            delete BattleRolePool.instance;
            BattleRolePool.instance = null;
        }

        this._super();
    },

    // 初始化配置数据
    initConfig: function() {
        this.model = Utils.createClass( "battle_model" )

        this.hook_model = Utils.createClass( "battle_hook_model" );

        this.model.initConfig();
        this.hook_model.initConfig()

        this.is_watch_replay = false;           // 是否属于观战状态

        this.is_unlock_chapter = false          // 是否解锁章节中 
        this.is_normal_battle = false;          // 是否是真战斗        
        this.finish_result_view_list = {};      // 胜利面板列表
        this.finish_fail_view_list = {};        // 失败面板列表;
        this.cache_list = [];                   //缓存界面列表
        this.is_watch_witness = false                              // --是否为观战状态
        this.init_fight_status = false
        this.circle_round_data = null                               // --挂机缓存数据
        this.cur_fight_type = 0
        this.is_battle_start = false                                //--是否已进入战斗状态
        this.is_pk_battle = false                                   //--是否切磋状态
        this.extend_fight_type = BattleConst.Fight_Type.Darma       //--额外的战斗类型记录
        this.fighting_type_list = {}
        this.is_drama_result = false
        this.sum_lev = 0                                           // --己方总等级
        this.enemy_lev = 0                                          //--敌方总等级


        //关于假数据
        this.is_battle_hook_wait = false;       //开始假挂机数据等待
        this.battle_test_data = {};
        this.is_test_skip = false;

        //特殊·结算
        this.special_results = {};
    },

    // 返回当前的model
    getModel: function() {
        return this.model;
    },

    // 假战斗数据
    getHookModel: function() {
        return this.hook_model;
    },

    // 注册监听事件
    registerEvents: function() {
        if( this.loading_enter_scene == null ) {
            this.loading_enter_scene = gcore.GlobalEvent.bind( MainuiEvent.LOADING_ENTER_SCENE, ( function() {
                this.showCachePanel();
            } ).bind( this ) )
        }

        //请求进入竞技场之前，需要告诉服务器，我要进去了，有没有真是战斗，快点告诉我
        if( this.combat_type_back_event == null ) {
            this.combat_type_back_event = gcore.GlobalEvent.bind( BattleEvent.COMBAT_TYPE_BACK, function( combat_type, type ) {
                if( type === 0 ){ //不存在战斗
                    this.openRelevanceWindowAtOnce( combat_type )
                }
                // else{
                //     let config = game.configs.combat_type_data.data_fight_list[combat_type];
                //     if(config && config.des){
                //         let tip = cc.js.formatStr(nx.text.getKey("battle_loading_tip"),config.des);
                //         return nx.tbox(tip);
                //     }
                // }
            }, this )
        }

        // 退出战斗需要打开进入战斗之前的一些窗体
        if( !this.battle_exit_event ) {
            this.battle_exit_event = gcore.GlobalEvent.bind( EventId.EXIT_FIGHT, function( combat_type ) {
                this.openRelevanceWindowAtOnce( combat_type )
            }.bind( this ) )
        }
    },

    // 注册协议接受事件
    registerProtocals: function() {
        this.RegisterProtocal( 20027, this.scInitFightStart );            // 战斗真正初始化数据,从0到1的战斗
        this.RegisterProtocal( 20001, this.handle20001 );
        this.RegisterProtocal( 20002, this.scRoundFightStart );           // 回合开始的播报   -- 包含回合开始的buff
        this.RegisterProtocal( 20004, this.scRoundFightOn );              // 回合中的播报     -- 包含回合结束buff和效果播报的buff
        this.RegisterProtocal( 20006, this.scFightEnd );                  // 战斗结算的,也就是真是战斗结束的
        this.RegisterProtocal( 20008, this.scFightExit );                 // 退出战斗
        this.RegisterProtocal( 20009, this.scSkipFirstTeam );             // 跳过一队
        this.RegisterProtocal( 20013, this.scReBattleFight );             // 战斗重连,切进战斗或者短线重连的战斗

        this.RegisterProtocal( 20014, this.scBattlePk );                  // 战斗切磋请求
        this.RegisterProtocal( 20015, this.scBattlePkRe );                // 战斗切磋返回
        this.RegisterProtocal( 20016, this.scBattlePkTwice );             // 战斗切磋同意

        this.RegisterProtocal( 20020, this.scRoundNextFight );            // 下一波怪物
        this.RegisterProtocal( 20022, this.scFightSpeed );                // 改变播放速度

        this.RegisterProtocal( 20029, this.scRecordBattle );              // 看录像
        this.RegisterProtocal( 20033, this.handle20033 );                 // 切磋结算
        this.RegisterProtocal( 20034, this.handle20034 );                 // 切磋视频分享
        this.RegisterProtocal( 20036, this.handle20036 );                 // 观看跨服录像,最后应该29协议全部转到这一条

        this.RegisterProtocal( 20060, this.handle20060 );                 // 请求战斗类型返回,这个时候只需要做对应ui操作的
        this.RegisterProtocal( 20061, this.handle20061 );                 // 假战斗初始化的,如果触发这个数据但是实际上是在真战斗中的时候,不做处理
        this.RegisterProtocal( 20062, this.handle20062 );                 // 跳过战斗
        this.RegisterProtocal( 20063, this.handle20063 );
        this.RegisterProtocal( 20064, this.handle20064 );                 //直接请求通关
        this.RegisterProtocal( 20065, this.handle20065 );                 //新版战斗总回合数
        this.RegisterProtocal( 20066, this.handle20066 );                 //无尽试炼下波次上报
        this.RegisterProtocal( 20070, this.handle20070 );
        this.RegisterProtocal( 20080, this.handle20080 );
    },

    reqBaseFromServer: function( _cb ) {
        // 配置加载 
        let cfgs = [
            "battle_act_data", // 英雄战斗模型
            "battle_bg_data", // 战斗场景
            "buff_data", // buff
            "combat_halo_data", // 阵容光环配置
            "combat_type_data", // 战斗配置（类型、天平模式、倍速等）
            "battle_lens_data"
        ];
        this.loadConfigs( cfgs, ( _ret, _data ) => {
            nx.dt.fnInvoke( _cb, true );
        } );
    },

    openDramaFightUI: function( status ) {
        if( this.show_fight_ui_status == status && this.fight_ui_combat == this.model.getFightStatus() ) {
            return;
        }
        this.show_fight_ui_status = status;
        this.fight_ui_combat = this.model.getFightStatus();

        if( !status ) {
            nx.bridge.closePanel( "WndBattleHook" );
            this.model.setBattleListPanelTime();
        } else {
            nx.bridge.createPanel( "WndBattleHook", { is_real_combat: this.model.getFightStatus() } )
            this.model.setBattleListPanelTime( 0 );
        }
        this.setIsNormaBattle( this.model.getFightStatus() );

        this.model.startCountDownToDelete();
    },

    // 是否在战斗中
    isInFight: function() {
        return this.model.getFightStatus()
    },

    // 是否有战斗场景
    hadBattleScene: function() {
        return ( this.model.getBattleScene() != null )
    },

    // 设置战斗场景的状态
    handleBattleSceneStatus: function( status ) {
        this.model.handleBattleSceneStatus( status )
    },

    handle20001: function(data){

    },

    // 根据战斗类型请求数据,r如果是切出战斗的话 则 combat_type:BattleConst.Fight_Type.Nil
    send20060: function( combat_type,_cb ) {
        var protocal = {
            combat_type: combat_type
        }
        this.SendProtocal( 20060, protocal,_cb );

        //新版战斗需要清除参数
        if( this.isInFight() ) {

        }
    },
    //  返回战斗状态,
    handle20060: function( data ) {
        if( data.combat_type == 0 ) {     // 这个就是切出战斗,
            this.clearBattleScene();
        } else {

        }
        gcore.GlobalEvent.fire( BattleEvent.COMBAT_TYPE_BACK, data.combat_type, data.type );
    },

    send20070: function( id,_cb ) {
        var protocal = {
            id: id
        }
        this.SendProtocal( 20070, protocal,_cb );
    },
    //  返回战斗状态,
    handle20070: function( data ) {
        if( !this.isGoodData( data ) ) {
            return;
        }
        if(data.id!=null){
            this.show_bat_id = data.id;
        }
    },

    getShowBatID(){
        return this.show_bat_id;
    },

    OutResult(){
        this.SendProtocal( 20080, {} );
    },

    handle20080: function( _data ) {
        if( !this.isGoodData( _data ) ) {
            return;
        }
    },


    handle20063: function(data){
        if(data.type_list){
            this.in_bat_list = data.type_list;
        }
    },

    send20064: function( combat_type ) {
        var protocal = {
            combat_type: combat_type
        }
        this.SendProtocal( 20064, protocal );
    },

    handle20064: function( data ) {
        console.log( data )
    },

    handle20065: function( data ) {

    },

    send20066: function( wave ) {
        var protocal = {
            wave: wave
        }
        this.SendProtocal( 20066, protocal );
    },

    handle20066: function( data ) {

    },

    waitOvertimeBattleHook() {
        if( !this.connect_timer ) {
            this.connect_timer = gcore.Timer.set( () => {
                if( this.is_battle_hook_wait ) {
                    this.is_battle_hook_wait = false;//关闭
                    gcore.GlobalEvent.fire( BattleEvent.COMBAT_TYPE_BACK, 3, 2 );//锁定假战斗
                }
            }, 1000, 1 );
        }
    },

    pushBattleResultData: function( data ) {

    },

    // 战斗结算的,也有可能不需要出结算面板
    scFightEnd: function( data ) {
        if( data.show_panel_type == 1 || data.combat_type == BattleConst.Fight_Type.LadderWar ) {
            nx.bridge.vset( "ResultInfo", data );
        }
        var is_replay = false;
        if( data.combat_type > 1000 ) {
            data.combat_type = data.combat_type - 1000;
            is_replay = true;
        }
        this.model.showWin( data, is_replay );
    },

    // 清理战斗场景,在退出战斗或者战斗结算之后,如果个战斗是剧情副本的战斗,那么就不需要清理掉场景,而是直接切换到假战斗
    clearBattleScene: function() {
        this.model.clearBattleScene();
    },

    // 请求切出战斗
    requestCutOutBattle: function(_cb) {
        this.send20060( BattleConst.Fight_Type.Nil,_cb );
    },

    // 战斗初始化数据
    scInitFightStart: function( data ) {
        let skip = nx.storage.get( "vip_skip" );
        if( Number( skip ) == 1 ) return;
        if( this.is_test_skip ) {
            this.is_test_skip = false;
            return;
        }

        if( BattleConst.canDoBattle( data.combat_type ) ) {
            if( data.combat_type == 35 || data.combat_type == 27) {//组队竞技场
                //加一个开始标志
                // this.model.setInitFightData( data );
            } else {
                // this.model.setArenaTeamStart( false );
            }
            // if( this.model.isArenaTeamStart() ) return;

            //设置最大回合数 
            // this.model.setMaxActionCount( game.configs.combat_type_data.data_fight_list[ data.combat_type ].max_action_count );
            this.model.updateCurBattleData( data, true );
            this.prepareLoaderBattleScene( data.combat_type, 2 );

        }
    },

    // 切进战斗
    scReBattleFight: function( data ) {
        if( BattleConst.canDoBattle( data.combat_type ) ) {
            this.model.updateCurBattleData( data, false );
            this.prepareLoaderBattleScene( data.combat_type, 2 );
        }
    },

    // 回合开始的播报
    scRoundFightStart: function( data ) {
        if(nx.dt.objEmpty(data))return;
        nx.debug( "回合开始播报" );
        this.model.playRoundStart( data);
    },

    // 回合中的播报
    scRoundFightOn: function( data ) {
        if(nx.dt.objEmpty(data))return;
        nx.debug( "回合播报" );
        this.model.playRoundIn( data );
    },

    // 回合播报结束通知服务端,对应的是20004
    csSkillPlayEnd: function() {
        nx.debug( "20004 播报完成" );
        this.SendProtocal(20005, {});
    },

    // 回合开始播报完成之后,通知服务端,对应的是20002
    csRoundFightEnd: function() {
        nx.debug( "20002 播报完成" );
        this.SendProtocal(20019, {});
    },

    // 战斗初始化完成之后
    csReadyFightStart: function() {
        nx.debug( "战斗初始化完成,通知服务端可以开始播报了" );
        this.SendProtocal( 20001, {} );
    },

    // 请求跳过战斗
    send20062: function() {
        this.SendProtocal(20062, {});
    },

    handle20062: function( data ) {
        if( !this.isGoodData( data ) ) {
            return;
        }
    },

    // 假战斗数据
    handle20061: function( data ) {
        cc.log( "假战斗数据" );

        //清除假数据
        this.is_battle_hook_wait = false;
        if( this.connect_timer ) {
            gcore.Timer.del( this.connect_timer );
            this.connect_timer = null;
        }
        
        if( this.hook_model ){
            this.hook_model.updateUnrealBattleData( data );
        }
        
        
        this.prepareLoaderBattleScene( data.combat_type, 1 );
            
            
        // }
        
    },

    csRecordBattle: function( replay_id ) {
        var protocal = {};
        protocal.replay_id = replay_id;
        this.SendProtocal( 20029, protocal );
    },

    // 战斗录像,这里只是记录战斗录像状态
    scRecordBattle: function( data ) {
        nx.tbox( data.msg );
        if( data.code == 1 ) {
            this.setWatchReplayStatus( true );
        }
    },

    // 切磋结果返回
    handle20033: function( data ) {
        if( data.combat_type == null ) {
            data.combat_type = BattleConst.Fight_Type.PK;
        }
        if( data.show_panel_type == null ) {
            data.show_panel_type = 2;
            nx.bridge.vset( "ResultInfo", data );
        }
        this.model.showWin( data );
    },
    newPKResultWin() {
        // if( !this.battle_pk_result_data ) return;
        // let data = this.battle_pk_result_data;
        // if( data.combat_type == null ) {
        //     data.combat_type = BattleConst.Fight_Type.PK;
        // }
        // if( data.show_panel_type == null ) {
        //     data.show_panel_type = 1
        // }
        // this.model.showWin( this.battle_pk_result_data );
        // this.battle_pk_result_data = null;
    },

    // 分享切磋视频
    on20034: function( replay_id, channel, target_name, share_type ) {
        var protocal = {}
        protocal.replay_id = replay_id
        protocal.channel = channel
        protocal.target_name = target_name
        protocal.share_type = share_type
        this.SendProtocal( 20034, protocal )
    },

    handle20034: function( data ) {
        nx.tbox( data.msg );
    },

    /**
     * 切换进战斗的唯一接口
     * @param {*} combat_type 
     * @param {*} in_fight_type 0:没有战斗 1:假战斗 2:真战斗
     */
    prepareLoaderBattleScene: function( combat_type, in_fight_type ) {
        if(combat_type == 1){//gm测试战斗
            this.ui_fight_type = 1;
        }
        if(this.ui_fight_type == 0)return;
        if( this.model ){
            this.model.createBattleScene( in_fight_type, combat_type );
            // 进入战斗,抛出事件
            if( in_fight_type == 2 ) {
                gcore.GlobalEvent.fire( EventId.ENTER_FIGHT, combat_type, in_fight_type );
            }
        }
       
    },

    /**
     * 下一波怪物的入口
     * @param {*} data 
     */
    scRoundNextFight: function( data ) {
        if( data ) {
            this.model.upDateNextMon( data );
        }
    },

    // 战斗每一帧更新
    update: function( dt ) {
        // this.model.mapMovescheduleUpdate(dt);
    },

    // 切换战斗背景移动状态,主要是用于真假剧情战斗切换
    changeMoveMapStatus: function( status ) {
        this.model.changeMoveMapStatus()
    },

    // 查看录像返回
    sender_20036: function( replay_id, replay_srv_id ) {
        var protocal = {
            replay_id: replay_id,
            replay_srv_id: replay_srv_id,
        }
        this.SendProtocal( 20036, protocal );
    },
    handle20036: function( data ) {
        if( data.code == 1 ) {
            this.setWatchReplayStatus( true )
        }
    },

    // 退出战斗
    csFightExit: function() {
        this.SendProtocal( 20008, {} );
    },
    scFightExit: function( data ) {
        nx.tbox( data.msg );
    },

    // 跳过一队
    csSkipFirstTeam: function() {
        this.SendProtocal( 20009, {} );
    },

    scSkipFirstTeam: function( data ) {
        nx.tbox( data.msg );
    },

    // 是否是观战状态
    getWatchReplayStatus: function() {
        return this.is_watch_replay;
    },

    // 设置观战状态
    setWatchReplayStatus: function( status ) {
        this.is_watch_replay = status;
    },

    // 是否是观战或者切磋状态
    getIsClickStatus: function() {
        var combat_type = this.model.getCombatType();
        return this.getWatchReplayStatus() || ( combat_type == BattleConst.Fight_Type.PK ) || ( combat_type == BattleConst.Fight_Type.HeroTestWar );
    },

    setUnlockChapterStatus: function( status ) {
        this.is_unlock_chapter = status;
    },

    getUnlockChapterStatus: function() {
        return this.is_unlock_chapter;
    },

    //进入主场景后显示缓存的界面
    showCachePanel: function() {
        if( this.cache_list == null || this.cache_list.length <= 0 ) return;
        for( var i in this.cache_list ) {
            if( this.cache_list[ i ].function ) {
                this.cache_list[ i ].function();
            }
        }
        this.cache_list = [];
    },

    //特殊結算
    pushSpecialRetInfo(combat_type,data){
        this.special_results[combat_type] = data;

        //如果當前戰鬥就是目標戰鬥，那就直接結算
        if(this.model.getCombatType() == 0){//this.getIsSameBattleType(combat_type) || 
            this.checkSpecialResults();
        }
    },

    //每次特殊結算界面關閉時，清除目標數據
    delSpecialRetInfo(combat_type){
        if(this.special_results[combat_type]){
            console.log("特殊结算缓存清除");
            delete this.special_results[combat_type];
        }
    },

    checkSpecialResults(){
      
        console.log("特殊结算展示");
        for(let type in this.special_results){
            nx.bridge.createPanel("WndSpecialSettle",{data:this.special_results[type]});
            return;
        }
    },

    // 战斗结算界面
    openFinishView: function( status, combat_type, data ) {


        if( status == true ) {
            if( !this.is_unlock_chapter ) {
                if( combat_type == BattleConst.Fight_Type.LadderWar ) {
                    nx.storage.set( "battleArena", FID.CrossLadder );
                    gcore.GlobalEvent.fire( BattleEvent.DISPENSE_TYPE_RESLUT );
                } else if( combat_type == BattleConst.Fight_Type.Arean_Team ) { //組隊競技場
                    // var ArenateamController = require("arenateam_controller")
                    // ArenateamController.getInstance().openArenateamFightResultPanel(true, data)
                } else if( combat_type == BattleConst.Fight_Type.PK ) {        // PK
                    // this.finish_result_view_list[combat_type] = Utils.createClass("battle_pk_result_window");
                    // this.finish_result_view_list[combat_type].open(data)
                } else if( combat_type == BattleConst.Fight_Type.Arena  ) {
                    //自己有自己的结算界面
                  
                    nx.storage.set( "battleArena", FID.Arena );
                    gcore.GlobalEvent.fire( BattleEvent.DISPENSE_TYPE_RESLUT );
                } else if( combat_type == BattleConst.Fight_Type.Adventrue ){
                    let data = nx.bridge.vget( "ResultInfo" );
                    this.model.result(data,null);
                    nx.bridge.vset( "ResultInfo", {} );
                }else if( combat_type == BattleConst.Fight_Type.Training_Camp ){
                    nx.storage.set( "battleArena", FID.NewTrain );
                    // nx.bridge.createPanel( "WndTrainingCamp" );
                }
                // else if(combat_type == 3 || combat_type == 7){
                //     if(data.result == 1){
                //         this.checkSpecialResults(combat_type);
                //     }else{
                //         if( combat_type != 0 ){
                //             this.openOtherFinish( combat_type );
                //         }
                //     }
                // }
                else {
                    if( data.result == 1 ) {
                        //设置不要马上显示升级
                        // LevupgradeController.getInstance().waitForOpenLevUpgrade(true)
                        if( combat_type == 0 ){
                            gcore.GlobalEvent.fire( BattleEvent.DISPENSE_TYPE_RESLUT );
                            return;
                        }
                        this.openOtherFinish( combat_type );
                    } else {
                        // cc.log( "打开失败界面" )
                        if( combat_type != 0 ){
                            this.openOtherFinish( combat_type );
                        }
                    }
                }
            }
        } else {
            if( this.finish_result_view_list[ combat_type ] ) {
                this.finish_result_view_list[ combat_type ].close();
                this.finish_result_view_list[ combat_type ] = null;
            }
        }

    },

    getFinishView: function( combat_type ) {
        if( this.finish_result_view_list ) {
            return this.finish_result_view_list[ combat_type ]
        }
    },

    //打开战斗伤害统计界面
    openBattleHarmInfoView: function( status, data ) {
        // if (status == true) {
        //     if (this.harm_info_view == null) {
        //         this.harm_info_view = Utils.createClass("battle_harm_info_window");
        //     }
        //     this.harm_info_view.open(data);
        // } else {
        //     if (this.harm_info_view) {
        //         this.harm_info_view.close();
        //         this.harm_info_view = null;
        //     }
        // }
    },

    //主要用于结算id不等于20006的结算功能
    openOtherFinish( combat_type ) {
        if(this.getIsSameBattleType(combat_type)){
            let data = nx.bridge.vget( "ResultInfo" );
            if( data.result ) {
                if( data.result == 1 ) {//成功
                    this.openWinFinishView( true, combat_type );
                    // nx.bridge.Tag2PanelClose("WndWinSettle");
                } else {//失败
                    this.openFailFinishView( true, combat_type );
                    //  nx.bridge.Tag2PanelClose("WndFailSettle");
                }
                nx.bridge.vset( "DailyPop", 1 );
            } else {//不需要结算数据
    
            }
        }
    },

    openWinFinishView( status, combat_type ) {
        if( status ) {
            if( !this.is_unlock_chapter ) {
                //设置不要马上显示升级
                let data = nx.bridge.vget( "ResultInfo" );
                if(data.combat_type != combat_type)return;
                nx.bridge.createPanel( "WndWinSettle", { combat_type: combat_type } );
            } else {
                this.battle_controller.send20060( BattleConst.Fight_Type.Darma );
            }
        } else {
            nx.bridge.closePanel( "WndWinSettle" );
            nx.bridge.vset( "ResultInfo", {} );
        }
    },

    //失败结算界面
    openFailFinishView: function( status, combat_type ) {
        if( status ) {
            if( !this.is_unlock_chapter ) {
                //设置不要马上显示升级
                nx.bridge.createPanel( "WndFailSettle", { combat_type: combat_type } );
            } else {
                this.battle_controller.send20060( BattleConst.Fight_Type.Darma );
            }
        } else {
            nx.bridge.closePanel( "WndFailSettle" );
            nx.bridge.vset( "ResultInfo", {} );
        }
    },

    //获取是否相同的战斗类型
    getIsSameBattleType: function( combat_type ) {
        return combat_type == this.model.getCombatType();
    },

    getIsInBattleing(combat_type){
        for(let i in this.in_bat_list){
            let type = this.in_bat_list[i];
            if(type!=11 && combat_type == type){//非无尽试炼
                return true;
            }
        }

        return false;
    },

    // -- 打开阵营详细面板
    openBattleCampView( status, form_id ) {
        if( status == true ) {
            nx.bridge.createPanel( "WndBattkeCamp", { form_id: form_id } );
        } else {
            nx.bridge.closePanel( "WndBattkeCamp" );
        }
    },

    // 记录是否为假战斗的战斗
    setIsNormaBattle: function( status ) {
        this.is_normal_battle = status;
    },

    // 是否是假战斗....
    getIsNoramalBattle: function() {
        return this.is_normal_battle;
    },

    // 改变战斗速度
    csFightSpeed: function( speed ) {
        var protocal = {}
        protocal.speed = speed;
        this.SendProtocal( 20022, protocal );
    },

    scFightSpeed: function( data ) {
        if(data.code == 0){
            nx.tbox( data.msg );
        }
    },

    getCtrlBattleScene: function( cal_back ) {
        var battle_scen = this.model.getBattleScene();
        cal_back( battle_scen );
    },

    getDramaFightUI: function( finish_cb ) {
        if( finish_cb ) {
            finish_cb( this.model.getDramaFightUI() );
        } else {
            if( this.model )
                return this.model.getDramaFightUI();
        }
    },

    // ---------------------切磋请求
    csBattlePk: function( target_id, target_srv_id, is_province ) {
        var protocal = {};
        protocal.target_id = target_id;
        protocal.target_srv_id = target_srv_id;
        protocal.is_province = is_province;
        this.SendProtocal( 20014, protocal );
    },

    scBattlePk: function( data ) {
        nx.tbox( data.msg );
        require( "chat_controller" ).getInstance().closeChatPanel( false );
        require( "friend_controller" ).getInstance().openFriendCheckPanel( false );
    },

    // 被切磋对象,在18600收到提示之后,调用这个接口同意或者取消掉
    confirmBattlePk: function( promptVo ) {

    },

    // 被切磋对象,同意切磋或者拒绝切磋
    csBattlePkRe: function( bool, data ) {
        var protocal = {};
        protocal.target_id = data.target_id;
        protocal.target_srv_id = data.target_srv_id;
        protocal.is_agree = bool ? 1 : 0;
        this.SendProtocal( 20015, protocal );
    },

    scBattlePkRe: function( data ) {
        nx.tbox( data.msg );
    },

    // 目标这统一了自己发起的请求.这时候自己的二次确认
    scBattlePkTwice: function( data ) {
        if( data ) {
            if( !this.isInFight() ) {
                var accept_fun = function() {
                    this.csBattlePkTwiceConfirm( true, { target_srv_id: data.target_srv_id, target_id: data.target_id } );
                }.bind( this );
                var refuse_fun = function() {
                    this.csBattlePkTwiceConfirm( false, { target_srv_id: data.target_srv_id, target_id: data.target_id } );
                }.bind( this );
                var desc = cc.js.formatStr( Utils.TI18N( "玩家<color=#0x249015>%s</color>同意了你的切磋请求,点击”立即切磋“立即进入切磋战斗？" ), data.target_name || "" );
                nx.mbox( desc, [ "cancel", "confirm" ], ( _key, _box ) => {
                    if( _key == "cancel" ) {
                        refuse_fun();
                    } else if( _key == "confirm" ) {
                        accept_fun();
                    }
                }, "friend_str12" );
            }
        }
    },

    // 发起者同意进战斗或者拒绝
    csBattlePkTwiceConfirm: function( bool, data ) {
        var protocal = {};
        protocal.target_id = data.target_id;
        protocal.target_srv_id = data.target_srv_id;
        protocal.is_agree = bool ? 1 : 0;;
        this.SendProtocal( 20016, protocal );
    },
    //  打开buff总览界面
    openBattleBuffInfoView( status, left_name, right_name ) {
        if( status ) {
            nx.bridge.createPanel( "WndBattleBuffInfo", { left_name: left_name, right_name: right_name } );
        } else {
            nx.bridge.closePanel( "WndBattleBuffInfo" );
        }
    },
    // - 更新buff列表界面数据
    updateBattleBuffListView( data, group, partner_bid ) {
        if( this.buff_list_view && this.buff_list_view.checkIsChosedBuffList( group, partner_bid ) ) {
            this.buff_list_view.setData( data )
        }
    },
    // -- 打开buff列表界面
    openBattleBuffListView( status, data, group, partner_bid ) {
        if( status ) {
            nx.bridge.createPanel( "WndBattleBuffList", { data: data, group: group, partner_bid: partner_bid } );
        } else {
            nx.bridge.closePanel( "WndBattleBuffList" );
        }
    },

    openBattleView: function( status, combat_type ) {
        if( status )
            this.createMap( null, BattleConst.Fight_Type.Darma )
        else {
            if( this.resources_load ) {
                this.resources_load.DeleteMe()
                this.resources_load = null
            }
            this.setCurFightType( 0 )
            this.send20060( 0 )
            this.circle_round_data = null
            // 這個地方感覺需要判斷當前是不是在戰鬥中,否則這裡也會拋出退出戰鬥事件
            this.clear( true )
        }
    },

    clear: function( is_change ) {
        this.model.clear( true )
        this.battle_hook_model.battleclear()
        let is_detele = this.getExtendFightType() != BattleConst.Fight_Type.Darma || this.cur_fight_type == 0
        if( this.battle_scene && !tolua.isnull( this.battle_scene ) ) {
            if( is_detele == true || is_change == true ) {
                if( this.resources_load ) {
                    this.resources_load.DeleteMe()
                    this.resources_load = null
                }
                this.battle_scene.cleanFightView()
                this.battle_scene.destroy();
                this.battle_scene = null
                this.fight_type = null
            }
        }
    },

    setCurFightType: function( fight_type ) {
        this.cur_fight_type = fight_type
    },

    /*****战斗面板切换 */
    // 获取当前的面板
    getUIFightType: function() {
        return this.ui_fight_type;
    },

    // 设置当前面板数据
    setUIFightType: function( value ) {
        this.ui_fight_type = value
    },

    // 是否在剧情副本界面
    checkIsInDramaUIFight: function() {
        return this.ui_fight_type == 4;
    },

    // 请求打开战斗相关的窗体,同时也包含了剧情副本的
    requestOpenBattleRelevanceWindow: function( battle_type, params, _cb ) {
        this.relevance_ui_last_type = this.ui_fight_type;
        this.relevance_battle_type = battle_type;
        this.relevance_params = params;
        this.relevance_ui_fight_type = BattleConst.getUIFightByFightType( battle_type );
        this.setUIFightType( this.relevance_ui_fight_type );
        this.send20060( battle_type, _cb );
    },

    // 还原之前的ui战斗类型,因为可能几个带战斗类型的面板互相调用
    resetUIFightType: function() {
        if( this.relevance_ui_last_type ) {
            this.ui_fight_type = this.relevance_ui_last_type;
            this.relevance_ui_last_type = 0;
        }
    },

    //新手演示和试用战斗触发 1 演示 2 试用
    //id 英雄id 1默认试用
    requestUseHeroBattle(type = 1,id = 1){
        let fight_type = 44;
        if(type == 2){
            fight_type = 45;
        }
        this.requestOpenBattleRelevanceWindow(fight_type,null,(_data)=>{
            if(_data){
                this.send20070(id);
                nx.bridge.plot.next();
            }
        });
    },

    //打开关联窗体,这里针对世界boss又需要重新判断调整
    openRelevanceWindowAtOnce: function( combat_type ) {
        if( combat_type == BattleConst.Fight_Type.WorldBoss || combat_type == BattleConst.Fight_Type.SingleBoss ) {
            if( this.relevance_battle_type != BattleConst.Fight_Type.WorldBoss && this.relevance_battle_type != BattleConst.Fight_Type.SingleBoss ) return
        } else {
            if( this.relevance_battle_type != combat_type ) return
        }
        if( combat_type == BattleConst.Fight_Type.GuildDun ) {//公會boss
            nx.bridge.createPanel( "WndGuildChallenge" );
        } else if( combat_type == BattleConst.Fight_Type.StarTower ) {//試煉塔
            nx.bridge.createPanel( "WndStartower", {} );
        } else if( combat_type == BattleConst.Fight_Type.Arena ) {//競技場
            nx.bridge.createPanel( "WndArenaLoopChallenge" );
        }else if( combat_type == BattleConst.Fight_Type.CrossChampion ) {//跨服冠军赛
            nx.bridge.createPanel( "WndCrossChampionWorship" );
        } else if( combat_type == BattleConst.Fight_Type.Endless ) {//無盡試煉
            require( "endless_trail_controller" ).getInstance().openEndlessMainWindow( true )
        } else if( combat_type == BattleConst.Fight_Type.ExpeditFight ) {
            // require( "heroexpedit_controller" ).getInstance().openHeroExpeditView( true )
        } else if( combat_type == BattleConst.Fight_Type.LadderWar ) {//天梯賽
            nx.bridge.createPanel( "WndLadder" );
        } else if( combat_type == BattleConst.Fight_Type.DungeonStone ) {//日常副本
            nx.bridge.createPanel( "WndDungeonMain", {} );
        } else if( combat_type == BattleConst.Fight_Type.GuildWar ) {
            nx.bridge.createPanel("WndGuildBatMain",{});
        } else if( combat_type == BattleConst.Fight_Type.Adventrue ) {
            nx.bridge.createPanel("WndAdventureModel",{});
        } else if( combat_type == BattleConst.Fight_Type.LimitExercise ) {
            // require( "limitexercise_controller" ).getInstance().openLimitExerciseChangeView( true )
        } else if( combat_type == BattleConst.Fight_Type.ElementWar ) {//元素神殿
             require( "element_controller" ).getInstance().openElementMainWindow( true )
        } else if( combat_type == BattleConst.Fight_Type.PlanesWar ) {//位面戰爭
            nx.bridge.createPanel( "WndPlanesafkMain", {} );
        } else if( combat_type == BattleConst.Fight_Type.Training_Camp ) {  // 新手训练营
            nx.bridge.createPanel( "WndTrainingCamp" );
        } else if( combat_type == BattleConst.Fight_Type.Arean_Team ) {  // 组队竞技场
            // require( "arenateam_controller" ).getInstance().openArenateamMainWindow( true )
        } else if( combat_type == BattleConst.Fight_Type.EliteMatchWar || combat_type == BattleConst.Fight_Type.EliteKingMatchWar ) {
            nx.bridge.createPanel("WndEliteRankMain",{});
        } else if( combat_type == BattleConst.Fight_Type.GuildSecretArea ) { //公會秘境
            // require( "guildsecretarea_controller" ).getInstance().openGuildsecretareaMainWindow( true, this.relevance_params )
        } else if( combat_type == BattleConst.Fight_Type.HeavenWar ) { //神裝副本
            nx.bridge.createPanel("WndHeavenMain",{});
        } else if(combat_type == BattleConst.Fight_Type.newYearBoss){//陣營大戰
            nx.bridge.createPanel("WndCampfightMain",{});
        }

        this.relevance_battle_type = null;
        this.relevance_params = null;
    },

    /*****战斗面板切换 */
} );

module.exports = BattleController;