import { defaultData } from "../script/defaultData_duiduipeng";

export class MyCocosSceneComponent extends cc.Component {

  // 生命周期 onLoad
  onLoad() {
    this.initSceneData();
    this.initSize();
  }

  _imageResList = null;
  _audioResList = null;
  _animaResList = null;
  initSceneData() {
    this._imageResList = [];
    this._audioResList = [];
    this._animaResList = [];
  }

  _designSize = null;  // 设计分辨率
  _frameSize = null;  // 屏幕分辨率
  _mapScaleMin = null;  // 场景中常用缩放（取大值）
  _mapScaleMax = null;  // 场景中常用缩放（取小值）
  _cocosScale = null;  // cocos 自缩放 （较少用到）
  initSize() {
    // 注意cc.winSize只有在适配后(修改fitHeight/fitWidth后)才能获取到正确的值,因此使用cc.getFrameSize()来获取初始的屏幕大小
    let screen_size = cc.view.getFrameSize().width / cc.view.getFrameSize().height
    let design_size = cc.Canvas.instance.designResolution.width / cc.Canvas.instance.designResolution.height
    let f = screen_size >= design_size
    cc.Canvas.instance.fitHeight = f
    cc.Canvas.instance.fitWidth = !f

    const frameSize = cc.view.getFrameSize();
    this._frameSize = frameSize;

    this._designSize = cc.view.getDesignResolutionSize();

    let sx = cc.winSize.width / frameSize.width;
    let sy = cc.winSize.height / frameSize.height;
    this._cocosScale = Math.min(sx, sy);

    sx = frameSize.width / this._designSize.width;
    sy = frameSize.height / this._designSize.height;
    this._mapScaleMin = Math.min(sx, sy) * this._cocosScale;
    this._mapScaleMax = Math.max(sx, sy) * this._cocosScale;

    cc.director['_scene'].width = frameSize.width;
    cc.director['_scene'].height = frameSize.height;
  }

  data = null;

  // 生命周期 start
  start() {
    if (window && (<any>window).courseware && (<any>window).courseware.getData) {
      (<any>window).courseware.getData((data) => {
        this.log('data:' + data);
        this.data = data || this.getDefaultData();
        this.data = JSON.parse(JSON.stringify(this.data));
        this.initData();
        this.preloadItem();
      })
    } else {
      this.log('data:' + "======");
      this.data = this.getDefaultData();
      this.data = JSON.parse(JSON.stringify(this.data));
      this.initData();
      this.preloadItem();
    }
  }
  initData(){

  }

  getDefaultData() {
    return defaultData;
  }

  preloadItem() {
    this.addPreloadImage();
    this.addPreloadAudio();
    this.addPreloadAnima();
    this.preload();
  }

  addPreloadImage() {
  }

  addPreloadAudio() {
  }

  addPreloadAnima() {
  }

  preload() {
    const preloadArr = this._imageResList.concat(this._audioResList).concat(this._animaResList);
    cc.assetManager.loadAny(preloadArr, null, null, (err, data) => {

      if (window && window["air"]) {
        // window["air"].onCourseInScreen = (next) => {
        //   window["air"].isCourseInScreen = true;
        //   this.onLoadEnd();
        //   next();
        // };
        this.onLoadEnd();
        window["air"].hideAirClassLoading();
      } else {
        this.onLoadEnd();
      }

      cc.debug.setDisplayStats(false);
    });
  }

  log (str) {
    const node = cc.find('middleLayer');
    if(node){
      node.getComponent('middleLayer').log(str);
    }else{
      cc.log(str);
    }
  }


  onLoadEnd() {

  }
  // ------------------------------------------------
  getSprNode(resName) {
    const sf = cc.find('Canvas/res/img/' + resName).getComponent(cc.Sprite).spriteFrame;
    const node = new cc.Node();
    node.addComponent(cc.Sprite).spriteFrame = sf;
    return node;
  }
  getSprforNode(resName, node) {
    const sf = cc.find('Canvas/res/img/' + resName).getComponent(cc.Sprite).spriteFrame;
    node.getComponent(cc.Sprite).spriteFrame = sf;
  }


  getSpriteFrimeByUrl(url, cb) {
    cc.loader.load({ url }, (err, img) => {
      if(img){
        const spriteFrame = new cc.SpriteFrame(img)
        if (cb) {
          cb(spriteFrame);
        }
      }else{
        console.log("getSpriteFrimeByUrlerr",err)
        cb(null)
      }
    })
  }

  getSprNodeByUrl(url, cb) {
    const node = new cc.Node();
    const spr = node.addComponent(cc.Sprite);
    this.getSpriteFrimeByUrl(url, (sf) => {
      if(sf) spr.spriteFrame = sf;
      if (cb) {
        cb(node);
      }
    })
  }
  getSprForNodeByUrl(url, node, cb = null) {
    const spr = node.getComponent(cc.Sprite);
    this.getSpriteFrimeByUrl(url, (sf) => {
      spr.spriteFrame = sf;
      if (cb) {
        cb();
      }
    })
  }

  asyncPlayAudioByUrl(audio_url, cb = null) {
    // audio_url="ooooo"
    if (audio_url) {
      console.log("audio_url===",audio_url)
      return new Promise((resole, reject) => {
        cc.assetManager.loadRemote(audio_url, (err, audioClip) => {
          if(audioClip){
            // cc.audioEngine.stopAll();
            const audioId = cc.audioEngine.play(audioClip, false, 0.8);
            cc.audioEngine.setFinishCallback(audioId, () => {
              if(cb)cb();
              resole(null);
            })
          }else{
            if(cb)cb();
            console.log("asyncPlayAudioByUrlerr=====",err)
            resole(null);
          }
         
        })
      })
    
    } else {
      cb && cb();
      return Promise.resolve();
    }
  }

	playBgAudioByUrl(audio_url, cb = null, loadCb = null) {
		return new Promise((resolve, reject) => {
			if (!audio_url) return resolve(null);
			cc.assetManager.loadRemote(audio_url, (err, audioClip: any) => {
				const audioId = cc.audioEngine.playMusic(audioClip, true);
				cc.audioEngine.setFinishCallback(audioId, () => {
					cb && cb();
				});
				loadCb && loadCb(audioId);
				resolve(audioId);
			});
		});
	}

	playAudioByUrl(audio_url, cb = null) {
		return new Promise((resolve, reject) => {
			if (!audio_url) return resolve(null);
			cc.assetManager.loadRemote(audio_url, (err, audioClip: any) => {
				const audioId = cc.audioEngine.play(audioClip, false, 0.8);
				cc.audioEngine.setFinishCallback(audioId, () => {
					cb && cb(audioId);
				});
				resolve(audioId);
			});
		});
	}
	stopAudio(audioId) {
		if (audioId < 0) return;
		cc.audioEngine.stopEffect(audioId);
	}


}
