/* ScummVM - Graphic Adventure Engine
 *
 * ScummVM is the legal property of its developers, whose names
 * are too numerous to list here. Please refer to the COPYRIGHT
 * file distributed with this source distribution.
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * aint32 with this program; if not, write to the Free Software
 *
 *
 * Based on the original sources
 *   Faery Tale II -- The Halls of the Dead
 *   (c) 1993-1996 The Wyrmkeep Entertainment Co.
 */

#ifndef SAGA2_GAMERATE_H
#define SAGA2_GAMERATE_H

namespace Saga2 {

enum {
	kGRFramesPerSecond = 0
};

class frameCounter {
	uint32 _ticksPerSecond;
	uint32 _lastTime;

protected:
	uint32 _frames;
	float _instantFrameCount;

public:
	frameCounter(uint32 perSec, uint32 now) {
		_ticksPerSecond = perSec;
		_frames = 0;
		_lastTime = now;
		_instantFrameCount = 0;
	}

	virtual ~frameCounter() {}

	virtual void updateFrameCount() {
		int32 frameTime = gameTime - _lastTime;
		_lastTime = gameTime;
		_frames++;
		_instantFrameCount = frameTime ? _ticksPerSecond / frameTime : 100;
	}

	virtual float frameStat(int statID = kGRFramesPerSecond) {
		return _instantFrameCount;
	}
};


enum {
	kGRFramesPerKilosecond   = 1,
	kGRFPKS1SecAvgNewest     = 2,
	kGRFPKS1SecAvgNew        = 3,
	kGRFPKS1SecAvg           = 4,
	kGRFPKS1SecAvgOld        = 5,
	kGRFPKS1SecAvgOldest     = 6,
	kGRFPKS5SecAvg           = 7,
	kGRFPKSAvg1SecAvg        = 8,
	kGRFPKS1SecVarNewest     = 9,
	kGRFPKS1SecVarNew        = 10,
	kGRFPKS1SecVar           = 11,
	kGRFPKS1SecVarOld        = 12,
	kGRFPKS1SecVarOldest     = 13,
	kGRFPKS5SecVar           = 14,
	kGRFPKSVar1SecAvg        = 15
};

class frameSmoother: public frameCounter {
	float _desiredFPS;

	uint32 _historySize;
	float *_frameHistory;

	float _avg1Sec[5];
	float _avg5Sec;
	float _secAvg;
	float _dif1Sec[5];
	float _dif5Sec;
	float _secDif;

	float ksHistory(int32 i) {
		return 1000.0 * _frameHistory[i];
	}

	void calculateAverages() {
		// clear averages
		for (int i = 0; i < 5; i++)
			_avg1Sec[i] = 0;

		_avg5Sec = 0;

		// get totals
		for (uint i = 0; i < _historySize; i++)
			_avg1Sec[i / int(_desiredFPS)] += ksHistory(i);

		// get averages
		for (uint i = 0; i < 5; i++) {
			_avg5Sec += _avg1Sec[i];
			_avg1Sec[i] /= _desiredFPS;
		}

		// get broad averages
		_secAvg = _avg5Sec / 5;
		_avg5Sec /= (5 * _desiredFPS);
	}

	void calculateVariance() {
		// clear variances
		for (int i = 0; i < 5; i++)
			_dif1Sec[i] = 0;

		_dif5Sec = 0;

		// get variance totals
		for (uint i = 0; i < _historySize; i++) {
			_dif1Sec[i / int(_desiredFPS)] += ABS(ksHistory(i) - _avg1Sec[i / int(_desiredFPS)]);
			_dif5Sec += ABS(ksHistory(i) - _avg5Sec);
		}

		// get average variances
		for (uint i = 0; i < 5; i++) {
			_secDif += _avg1Sec[i] - _secAvg;
			_dif1Sec[i] /= _desiredFPS;
		}

		// get broad variance
		_dif5Sec /= (5 * _desiredFPS);
	}


public:
	frameSmoother(int32 fps, uint32 perSec, uint32 now);


	virtual ~frameSmoother() {
		if (_frameHistory)
			delete[] _frameHistory;

		_frameHistory = nullptr;
	}

	virtual void updateFrameCount() {
		frameCounter::updateFrameCount();
		_frameHistory[_frames % _historySize] = _instantFrameCount;
		if (0 == (_frames % int(_desiredFPS))) {
			calculateAverages();
			calculateVariance();
		}
	}

	virtual float frameStat(int statID = kGRFramesPerSecond) {
		int oldestOffset = (_frames % _historySize) / _desiredFPS;
		switch (statID) {
		case kGRFramesPerKilosecond  :
			return 1000 * _instantFrameCount;
		case kGRFPKS1SecAvgNewest    :
			return _avg1Sec[4 + oldestOffset];
		case kGRFPKS1SecAvgNew       :
			return _avg1Sec[3 + oldestOffset];
		case kGRFPKS1SecAvg          :
			return _avg1Sec[2 + oldestOffset];
		case kGRFPKS1SecAvgOld       :
			return _avg1Sec[1 + oldestOffset];
		case kGRFPKS1SecAvgOldest    :
			return _avg1Sec[0 + oldestOffset];
		case kGRFPKS5SecAvg          :
			return _avg5Sec;
		case kGRFPKSAvg1SecAvg       :
			return _secAvg;
		case kGRFPKS1SecVarNewest    :
			return _dif1Sec[4 + oldestOffset];
		case kGRFPKS1SecVarNew       :
			return _dif1Sec[3 + oldestOffset];
		case kGRFPKS1SecVar          :
			return _dif1Sec[2 + oldestOffset];
		case kGRFPKS1SecVarOld       :
			return _dif1Sec[1 + oldestOffset];
		case kGRFPKS1SecVarOldest    :
			return _dif1Sec[0 + oldestOffset];
		case kGRFPKS5SecVar          :
			return _dif5Sec;
		case kGRFPKSVar1SecAvg       :
			return _secDif;
		default:
			return frameCounter::frameStat(statID);
		}
	}
};

frameSmoother::frameSmoother(int32 fps, uint32 perSec, uint32 now)
	: frameCounter(perSec, now) {
	assert(fps);
	_desiredFPS = fps;
	_historySize = fps * 5;
	_frameHistory = new float[_historySize];

	for (uint32 i = 0; i < _historySize; i++)
		_frameHistory[i] = 0;

	for (int i = 0; i < 5; i++)
		_dif1Sec[i] = _avg1Sec[i] = 0;

	_dif5Sec = 0;
	_avg5Sec = 0;
	_secDif = 0;
	_secAvg = 0;
}

} // end of namespace Saga2

#endif