import { _decorator, AudioSource, Component, instantiate, Node, Prefab, Widget } from 'cc';
import { event_item, event_item_switch_scene_event, scene_item_data, task_data } from '../../data/data';
import { scene_page } from './scene_page';
import { scene_page_dir } from './scene_page_dir';
import { ClientEvent } from '../clientEvent';
import { config } from '../config';
import { gameManager } from './gameManager';
import { taskServce } from './TaskSchedule/taskServce';
const { ccclass, property } = _decorator;

@ccclass('scene_layer')
export class scene_layer extends Component {
    @property(Node) content:Node = null;
    @property(Prefab) scenePagePrefab:Prefab = null;
    @property(Node) scenePageDir:Node = null;
    protected mSceneTask:task_data = null;
    private mTaskEventItemList:event_item[] = []
    protected mScenePages:scene_item_data[] =[]
    private mCurPage:number = 0;
    private mAudioList:Map<string,Node> = new Map;
    protected start(): void {
        this.node.addComponent(AudioSource)
    }
    public initSceneTask(data:task_data) {
        this.mSceneTask = data
        this.getTaskSwitchSceneEventList()
    }
    
    public initScene(pages:scene_item_data[],type:number){
        ClientEvent.on(config.EventRun.NOTICE_EVENT,this.beActive.bind(this),this)
        this.mScenePages = pages;
        this.initSceneDir(type)
        this.loadAllPage()
    }

    public unInit(){
        this.content.destroyAllChildren()
        this.content.removeAllChildren()
        this.mScenePages = []
        this.mCurPage = 0;
        this.mAudioList.clear()
        ClientEvent.off(config.EventRun.NOTICE_EVENT,this.beActive.bind(this),this)
    }

    getAudioSource(){
        if(this.node.getComponent(AudioSource)==null){
            this.node.addComponent(AudioSource)
        }
        return this.node.getComponent(AudioSource)
    }
    beActive(widgetId:number,event:event_item){
        if(event.type===config.event_type.play_sound){
            let is_can_play = true;
            if(gameManager.Singleton.getLevelData()){
                if(gameManager.getUserData().isOpenPeiYin){
                    is_can_play = true;
                }else{
                    is_can_play = false;
                }
            }
            if(is_can_play){
                if(event.event_item_play_sound_data!=null){
                    if(event.event_item_play_sound_data.isLoop==undefined){
                        event.event_item_play_sound_data.isLoop = false;
                    }
                    if(event.event_item_play_sound_data.volume==undefined){
                        event.event_item_play_sound_data.volume = 1;
                    }
                    this.addAudioItemAndPlay(event.event_item_play_sound_data.sound_res.url,event.event_item_play_sound_data.volume ,event.event_item_play_sound_data.isLoop)
                }
            }
   
        }else if(event.type===config.event_type.stop_play_loop_sound){
            if(event.event_item_stop_play_loop_sound_data!=null){
                this.deleteAudioItem(event.event_item_stop_play_loop_sound_data.res)
            }
        }
    }

    addAudioItemAndPlay(res:string, volume:number,isLopp:boolean = false){
        // let content = this.getCurScenePage().node;
        let content = this.content;
        let audio_node = this.mAudioList.get(res)
        if(audio_node==null){
            audio_node = new Node
            audio_node.parent = content;
            audio_node.addComponent(AudioSource)
            this.mAudioList.set(res,audio_node)
        }
        audio_node.getComponent(AudioSource).clip = gameManager.getCacheSoundByName(res);
        audio_node.getComponent(AudioSource).play();
        audio_node.getComponent(AudioSource).volume = volume;
        audio_node.getComponent(AudioSource).loop = isLopp;
    }

    deleteAudioItem(res:string){
        let audio_node = this.mAudioList.get(res)
        if(audio_node){
            audio_node.getComponent(AudioSource).stop()
            audio_node.removeFromParent()
            this.mAudioList.delete(res)
        }
    }
    changePage(page:number){
        this.mCurPage = page;
        this.onChangeUpdatePages()
        if(this.mScenePages.length>1){
            this.scenePageDir.getComponent(scene_page_dir).showAllBtn()
            if(this.mCurPage<=0){
                this.scenePageDir.getComponent(scene_page_dir).hideUpBtn()
            }
            if(this.mCurPage==this.mScenePages.length-1){
                this.scenePageDir.getComponent(scene_page_dir).hideNextBtn() 
            }
        }
     
    }

    onChangeUpdatePages(){
        for (let index = 0; index < this.content.children.length; index++) {
            const page = this.content.children[index];
            if(page.getComponent(AudioSource)!=null){

            }else{
                page.active = (this.mCurPage == index)
            }
          
        }
    }

    loadAllPage(){
        this.content.removeAllChildren()
        for (let index = 0; index < this.mScenePages.length; index++) {
            const item_data:scene_item_data = this.mScenePages[index];
            let item:Node = instantiate(this.scenePagePrefab);
            item.parent = this.content;
            item.getComponent(Widget).target = this.content;
            item.getComponent(scene_page).initView(item_data)
        }
        this.changePage(0)
    }

    public getCurScenePage(){
        return this.content.children[this.mCurPage].getComponent(scene_page)
    }

    public isCurScenePageCheckWidgetFinish(widget_id:number):boolean{
        let page:scene_page = this.getCurScenePage()
        return  page.checkFinish(widget_id)
    }

    public isCurScenePageCheckWidgetShow(widget_id:number):boolean{
        let page:scene_page = this.getCurScenePage()
        return  page.checkShow(widget_id)
    }

    onUp(){
        let up_page = this.mCurPage -1;
        if(up_page>=0){
            this.onClickCurPageDirectionButton(true)
            gameManager.Singleton.onLaunch(()=>{
                this.changePage(up_page)
            })
        }
    }

    onNext(){
        let next_page = this.mCurPage +1;
        if(next_page<this.mScenePages.length){
            this.onClickCurPageDirectionButton(false)
            gameManager.Singleton.onLaunch(()=>{
                this.changePage(next_page)
            })
        }
    }

    onClickCurPageDirectionButton(isUp:boolean) {
        if(this.mSceneTask == null) {
            return
        }
        let cur_page = this.mCurPage
        let event_id = -1
        for(let i = 0; i<this.mTaskEventItemList.length; i++) {
            let element = this.mTaskEventItemList[i]
            let element_switch_scene_event_data:event_item_switch_scene_event = element.event_item_switch_scene_event_data
            if(element_switch_scene_event_data.binding_page_index == cur_page) {
                if(isUp) {
                    if(element_switch_scene_event_data.direction == config.switch_scene_page_direction.up || element_switch_scene_event_data.direction == config.switch_scene_page_direction.left) {
                        event_id = element.event_id
                        break
                    }
                } else {
                    if(element_switch_scene_event_data.direction == config.switch_scene_page_direction.down || element_switch_scene_event_data.direction == config.switch_scene_page_direction.right) {
                        event_id = element.event_id
                        break
                    }
                }
            }
        }
        if(event_id != -1) {
            // 切换场景有延时0.7
            this.scheduleOnce(()=>{
                ClientEvent.dispatchEvent(config.EventRun.MORE_SCENE_DIRECTION_BUTTON_CLICK_FINISH, event_id)
            },0.7)
        }
    }

    getTaskSwitchSceneEventList() {
        if(this.mSceneTask == null) {
            return
        }
        for(let i = 0; i < this.mSceneTask.event_list.length; i++) {
            let element:event_item = this.mSceneTask.event_list[i]
            if(element.type == config.event_type.switch_scene_event && element.event_item_switch_scene_event_data != null) {
                this.mTaskEventItemList.push(element)
            }
        }
    }

    initSceneDir(type:number){
        if(this.mScenePages.length>1){
            this.scenePageDir.getComponent(scene_page_dir).initView(type,this.onUp.bind(this),this.onNext.bind(this))
        }else{
            this.scenePageDir.getComponent(scene_page_dir).hideAllBtn()
        }
       
    }
}