/**
 * 跳判断相关脚本代码
 */

function Event() {
	this.events = {};
}
Event.prototype.addEventListener = function (type, listener) {
	this.events[type] = this.events[type] || [];
	this.events[type].push(listener);
};
Event.prototype.trigger = function () {
	for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) {
		args[_key] = arguments[_key];
	}

	var type = args[0];
	var params = args.slice(1);
	if (!!this.events[type]) {
		// console.log("type:",type);
		this.events[type].forEach(function (listener) {
			try {
				listener.apply(null, params);
			} catch (e) {
				console.error(e);
			}
		});
	}
};
var jumpOpts = {
	//是否上升的标志位
	isDirectionUp: false,
	//持续上升次数
	continueUpCount: 0,
	//上一点的持续上升的次数，为了记录波峰的上升次数
	continueUpFormerCount: 0,

	continueDownCount: 0,
	continueDownFormerCount: 0,

	//上一点的状态，上升还是下降
	lastStatus: false,
	//波峰值
	peakOfWave: 0,
	//波谷值
	valleyOfWave: 0,
	//检测到极快的波动的次数
	timeOfPeakCount: 0,
	//开始添加
	bUpdateTimeOfPeakCount: false,
	//开始更新的次数
	startCount: 0,
	//停止跳
	bStopJump: false,
	//上次传感器的值
	gravityOld: 0,

	bUpState: false,
}
var ActionJump = function ActionJump() {

	this.jumpOpts = jumpOpts;
	//其他波峰波谷参数相关数组记录
	this.peakOfWaveArray = [];
	this.peakOfWaveMaxValue = 0;
	this.valleyOfWaveArray = [];
	this.valleyOfWaveMinValue = 0;

	this.peakOfWaveArrayValue = [];
	this.valleyOfWaveArrayValue = [];

	this.peakOfWaveArrayValueLinear = [];
	this.valleyOfWaveArrayValueLinear = [];


	this.highestCount = 0;
	//陀螺仪
	this.oriGyroYArray = [];

	this.isJumpTop = false;

	this.event = new Event();


	this.frameCapacity = 6;
	this.frame = [];
	this.frameLength = 5;
	this.frameOffset = 0;

	this.frameHitCapacity = 11;
	this.frameHit = [];//打击后的n帧

	for (var i = 0; i < this.frameCapacity; ++i) {
		var o = new Object();
		// o.acc = [0, 0, 0];
		// o.gyr = [0, 0, 0];
		o.resultant = 0;
		this.frame.push(o);
	}


}
ActionJump.prototype.addEventListener = function (type, listener) {
	this.event.addEventListener(type, listener);
};


ActionJump.prototype.updateJump = function () {
	let data = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
	//使用三个轴的数据，计算重力轴的加速度。最后减去重力的加速度值
	//********加速计********
	let {
		lAccX,
		lAccY,
		lAccZ
	} = data.linearAcc;
	let {
		oAccX,
		oAccY,
		oAccZ
	} = data.oriAcc;
	let {
		oGyroX,
		oGyroY,
		oGyroZ
	} = data.oriGyro;
	let {
		bYAxis
	} = data;
	let _tempAxisData = bYAxis ? oGyroY : oGyroX;
	this.detectorNewStep(data.resultant, lAccX, lAccY, lAccZ, oAccX, oAccY, oAccZ, data.runIndex, _tempAxisData);
};



/*
 * 检测步子，并开始计步
 * 1.传入数据
 * 2.如果检测到了波峰，并且符合时间差以及阈值的条件，则判定为1步
 * 3.符合时间差条件，波峰波谷差值大于initialValue，则将该差值纳入阈值的计算中
 * */
ActionJump.prototype.detectorNewStep = function (resultant, linearX, linearY, linearZ, oriX, oriY, oriZ, _runIndex,
	_oGyroY) {
	let _judgmentValue = oriZ;
	// if (this.jumpOpts.gravityOld == 0) {
	// 	this.jumpOpts.gravityOld = _judgmentValue;
	// } else {
	if (!this.jumpOpts.bStopJump) {
		// let {
		// 	bState,
		// 	bType,
		// 	value
		// } = this.detectorPeakOfWaveAndValleyOfWave(_judgmentValue, this.jumpOpts.gravityOld);
		// let lastFrame = this.frame[(this.frameOffset + this.frameLength - 1) % this.frameCapacity];
		// let last2Frame = this.frame[(this.frameOffset + this.frameLength - 2) % this.frameCapacity];
		// let last3Frame = this.frame[(this.frameOffset + this.frameLength - 3) % this.frameCapacity];
		// let last4Frame = this.frame[(this.frameOffset + this.frameLength - 4) % this.frameCapacity];
		// let last5Frame = this.frame[(this.frameOffset + this.frameLength - 5) % this.frameCapacity];
		let newFrame = this.frame[(this.frameOffset + this.frameLength) % this.frameCapacity];
		newFrame.resultant = resultant;

		if (resultant > 20 && !this.jumpOpts.bUpState) {
			this.jumpOpts.bUpState = true;
			this.isJumpTop = false;
			this.highestCount = 0;
			//陀螺仪部分
			this.oriGyroYArray = [];
			this.peakOfWaveArrayValue = [];
			this.valleyOfWaveArrayValue = [];
			this.peakOfWaveArrayValueLinear = [];
			this.valleyOfWaveArrayValueLinear = [];

			this.jumpOpts.startCount = 0;

			// console.log("开始:", JSON.stringify(this.frame), '当前：', resultant);

		}
		if (this.jumpOpts.bUpState) {

			if (_judgmentValue > 2) {
				if (_judgmentValue > this.peakOfWaveMaxValue)
					this.peakOfWaveMaxValue += _judgmentValue;
				// this.peakOfWaveArrayValue.push(_judgmentValue);

			}
			else if (_judgmentValue < -2) {
				if (_judgmentValue < this.valleyOfWaveMinValue)
					this.valleyOfWaveMinValue += _judgmentValue;
				// this.valleyOfWaveArrayValue.push(_judgmentValue);

			}
			// if (linearZ > 2)
			// 	this.peakOfWaveArrayValueLinear.push(linearZ);
			// else if (linearZ < -2)
			// 	this.valleyOfWaveArrayValueLinear.push(linearZ);

			if (Math.abs(_oGyroY) > 5)
				this.oriGyroYArray.push(_oGyroY);
			//出现极值后
			// Math.abs(linearZ) < 7 &&
			if (Math.abs(resultant) < 9.8) {
				console.log('出现极值后：', linearZ, resultant);
				// this.isJumpTop = true;
				this.highestCount++;
				if (this.highestCount >= 1) {
					//达到最高点，
					this.jumpOpts.bStopJump = true;
					this.jumpOpts.bUpdateTimeOfPeakCount = true;
					// this.isJumpTop = false;

					let _currentMaxValue = 0;
					// console.log("highestCount peakOfWaveArray", JSON.stringify(this.peakOfWaveArray));
					// console.log("highestCount valleyOfWaveArray", JSON.stringify(this.valleyOfWaveArray));

					// let allPeakOfWave = 0;
					// for (let i = 0; i < this.peakOfWaveArrayValue.length; i++) {
					// 	allPeakOfWave += this.peakOfWaveArrayValue[i];
					// }

					// let allValleyOfWave = 0;
					// for (let i = 0; i < this.valleyOfWaveArrayValue.length; i++) {
					// 	allValleyOfWave += this.valleyOfWaveArrayValue[i];
					// }

					// let allPeakOfWaveLinear = 0;
					// for (let i = 0; i < this.peakOfWaveArrayValueLinear.length; i++) {
					// 	allPeakOfWaveLinear += this.peakOfWaveArrayValueLinear[i];
					// }

					// let allValleyOfWaveLinear = 0;
					// for (let i = 0; i < this.valleyOfWaveArrayValueLinear.length; i++) {
					// 	allValleyOfWaveLinear += this.valleyOfWaveArrayValueLinear[i];
					// }

					// console.log("highestCount peakOfWaveArrayValue", JSON.stringify(this.peakOfWaveArrayValue));
					// console.log("highestCount valleyOfWaveArrayValue", JSON.stringify(this.valleyOfWaveArrayValue));
					// console.log("ori总值 peak:"+allPeakOfWave+" valley:"+allValleyOfWave);
					// console.log("linear总值 peak:"+allPeakOfWaveLinear+" valley:"+allValleyOfWaveLinear);
					// console.log("达到最高点时候数值 Max:", this.peakOfWaveMaxValue, " min:", this.valleyOfWaveMinValue);
					//(Math.abs(this.peakOfWaveMaxValue) > 5 && Math.abs(this.valleyOfWaveMinValue) - Math
					//  .abs(this.peakOfWaveMaxValue) < 10) ||
					if (Math.abs(this.peakOfWaveMaxValue) > Math.abs(this.valleyOfWaveMinValue)) {
						_currentMaxValue = this.peakOfWaveMaxValue;
					} else {
						_currentMaxValue = this.valleyOfWaveMinValue;
					}

					let allOGyroValue = 0;
					for (let i = 0; i < this.oriGyroYArray.length; i++) {
						allOGyroValue += this.oriGyroYArray[i];
					}
					allOGyroValue /= this.oriGyroYArray.length;

					// this.event.trigger('resultant', {
					// 	type: "jump",
					// 	acc: _currentMaxValue,
					// 	value: resultant
					// });

					// this.event.trigger('resultant', {
					// 	type: "curAngle",
					// 	value: _currentMaxValue,
					// 	resultant: resultant
					// });

					// this.event.trigger('resultant', {
					// 	type: "rotate",
					// 	value: allOGyroValue,
					// 	resultant: resultant
					// });
					//后面通用使用这个类型传输数据
					this.event.trigger('resultant', {
						type: "stateDataOfJump",
						currentMaxValue: _currentMaxValue,
						peakOfWaveMaxValue: this.peakOfWaveMaxValue,
						valleyOfWaveMinValue: this.valleyOfWaveMinValue,
						oGyroValue: allOGyroValue,
						resultant: resultant,
						name: "highestCountEnd"
					});
					this.jumpOpts.bUpState = false;
				}

			}
		}
		if ((this.frameOffset += 1) >= this.frameCapacity) {
			this.frameOffset -= this.frameCapacity;
		}
	} else if (this.jumpOpts.bUpdateTimeOfPeakCount) {
		this.jumpOpts.timeOfPeakCount++;
		//todo 如果直跳，可以调节更小的 limitTimeOfPeakCount
		let limitTimeOfPeakCount = 30;
		if (this.jumpOpts.timeOfPeakCount >= limitTimeOfPeakCount) {
			this.jumpOpts.timeOfPeakCount = 0;
			this.jumpOpts.bStopJump = false;
			this.event.trigger('resultant', {
				type: "stop"
			});
			console.log("timeOfPeakCount >= " + limitTimeOfPeakCount);
			this.resetAll();
			this.jumpOpts.bUpdateTimeOfPeakCount = false;
		}
	}
	// this.event.trigger('resultant', {
	// 	type: "bUpdateDraw",
	// 	linearX: linearX,
	// 	linearZ: linearZ,
	// 	linearY: linearY,
	// 	oriX: oriX,
	// 	oriY: oriY,
	// 	oriZ: oriZ
	// });
}


ActionJump.prototype.detectorPeakOfWaveAndValleyOfWave = function (newValue, oldValue) {
	this.jumpOpts.lastStatus = this.jumpOpts.isDirectionUp;
	if (newValue >= oldValue) {
		this.jumpOpts.continueDownFormerCount = this.jumpOpts.continueDownCount;
		this.jumpOpts.continueDownCount = 0;
		this.jumpOpts.isDirectionUp = true;
		this.jumpOpts.continueUpCount++;
	} else {
		this.jumpOpts.continueUpFormerCount = this.jumpOpts.continueUpCount;
		this.jumpOpts.continueUpCount = 0;
		this.jumpOpts.isDirectionUp = false;
		this.jumpOpts.continueDownCount++;
	}
	if (!this.jumpOpts.isDirectionUp && this.jumpOpts.lastStatus && this.jumpOpts.continueUpFormerCount >= 2 && Math
		.abs(oldValue) > 4) {
		this.jumpOpts.peakOfWave = oldValue;
		return {
			value: oldValue,
			bType: 'peakOfWave',
			bState: true
		};
	} else if (!this.jumpOpts.lastStatus && this.jumpOpts.isDirectionUp && this.jumpOpts.continueDownFormerCount >=
		2 && Math.abs(oldValue) > 4) {
		this.jumpOpts.valleyOfWave = oldValue;
		return {
			value: oldValue,
			bType: 'valleyOfWave',
			bState: true
		};
	} else {
		return {
			value: oldValue,
			bType: 'None',
			bState: false
		};
	}
}
//重置对应的参数
ActionJump.prototype.resetAll = function () {
	// console.log('******************* resetAll ******************');
	this.peakOfWaveArray = [];
	this.peakOfWaveMaxValue = 0;
	this.valleyOfWaveArray = [];
	this.valleyOfWaveMinValue = 0;
	this.highestCount = 0;


	this.jumpOpts.continueDownFormerCount = 0;
	this.jumpOpts.continueDownCount = 0;
	this.jumpOpts.continueUpFormerCount = 0;
	this.jumpOpts.continueUpCount = 0;

	// this.jumpOpts.gravityOld = 0;
}

if (typeof module === "object" && typeof module.exports === "object") {
	module.exports = ActionJump;
}
