import { onHomeworkFinish, playAudioByUrl, playDragonBoneAnimation } from "../script/util";
import { defaultData } from "../script/defaultData";

cc.Class({

	extends: cc.Component,

	properties: {
	},

	// 生命周期 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;
	},


	// 生命周期 start
	start() {
		let getData = this.getData.bind(this);
		if (window && window.courseware) {
			getData = window.courseware.getData;
		}

		getData((data) => {
			console.log('data:', data);
			this.data = data || this.getDefaultData();
			this.data = JSON.parse(JSON.stringify(this.data))
			this.preloadItem()
		})
	},

	getData(func) {
		if (window && window.courseware) {
			window.courseware.getData(func, 'scene');
			return;
		}

		const middleLayer = cc.find('middleLayer');
		if (middleLayer) {
			const middleLayerComponent = middleLayer.getComponent('middleLayer');
			middleLayerComponent.getData(func);
			return;
		}

		func(this.getDefaultData());
	},

	getDefaultData() {
		return defaultData;
	},

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


	addPreloadImage() {
		this._imageResList.push({ url: this.data.bgItem.url });
		this._imageResList.push(...this.data.hotZoneItemArr
			.map(data => data.pic_url)
			.map(url => { return { url: url } })
		);
	},

	addPreloadAudio() {
		this._imageResList.push(...this.data.hotZoneItemArr
			.map(data => data.audio_url)
			.map(url => { return { url: url } })
		);

		this._audioResList.push({ url: this.data.startAudio });
		this._audioResList.push({ url: this.data.endAudio });
	},

	addPreloadAnima() {

	},

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

			this.loadEnd();
			if (window && window["air"]) {
				window["air"].hideAirClassLoading();
			}

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

	loadEnd() {
		this.initData();
		this.initView();
		this.initListener();
	},

	initData() {

	},

	initView() {
		this.coolCatSpeakStart(() => {

		});
		const canvas = cc.find('Canvas');
		const bg = cc.find('Canvas/bg/ImgBg');
		this.loadSpriteByUrl(bg, this.data.bgItem.url, () => {
			bg.scale = Math.min((canvas.width / bg.width), (canvas.height / bg.height));

			this.itemList = this.data.hotZoneItemArr.map(async itemData => await this.createItem(itemData, bg));
			this.itemList.forEach(item => {
				item.on('click', () => {
					item.clicked = true;
					if (this.itemList.every(tmpItem => tmpItem.clicked)) {
						this.coolCatSpeakEnd();
					}
					playAudioByUrl(itemData.audio_url);
					const time = 0.05;
					cc.tween(item)
						.to(time, { angle: 10 })
						.to(time * 2, { angle: -10 })
						.to(time, { angle: 0 })
						.start();
				});
			})
		});
	},

	createItem(itemData, bg) {
		return new Promise((resolve, reject) => {
			const bgScale = bg.width / this.data.bgItem.rect.width;

			const item = cc.instantiate(cc.find('item'));
			item.parent = bg;
			this.loadSpriteByUrl(item, itemData.pic_url, () => {
				item.scale = itemData.imgScale * bgScale;
				item.x = itemData.rect.x * bgScale - bg.width / 2 + item.width * item.scaleX / 2;
				item.y = bg.height / 2 - itemData.rect.y * bgScale - item.height * item.scaleY / 2;
				resolve(item);
			});
		});
	},

	initListener() {

	},


	coolCatSpeakStart(cb) {
		const cat = cc.find('Canvas/bg/catFrame/CoolCat');
		playDragonBoneAnimation(cat, 'begin', -1);
		this.playAudioByUrl(this.data.startAudio, () => {
			playDragonBoneAnimation(cat, 'normal', -1);
			cb();
		});
	},

	coolCatSpeakEnd(cb) {
		const cat = cc.find('Canvas/bg/catFrame/CoolCat');
		playDragonBoneAnimation(cat, 'finish', -1);
		this.playAudioByUrl(this.data.endAudio, () => {
			playDragonBoneAnimation(cat, 'normal', -1);
			cb();
		});
	},






















	loadSpriteByUrl(node, url, cb) {
		cc.loader.load({ url }, (err, img) => {
			const spriteFrame = new cc.SpriteFrame(img)
			const spr = node.getComponent(cc.Sprite);
			spr.spriteFrame = spriteFrame;
			if (cb) {
				cb();
			}
		});
	},

	playAudioByUrl(audio_url, cb = null) {
		if (audio_url) {
			cc.assetManager.loadRemote(audio_url, (err, audioClip) => {
				const audioId = cc.audioEngine.play(audioClip, false, 0.8);
				if (cb) {
					cc.audioEngine.setFinishCallback(audioId, () => {
						cb();
					});
				}
			});
		}
	},
});
