using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.UI;

public class BikeManager : MonoBehaviour {

    [SerializeField]
    public int playerID; // {get; set; }
    // metric system ftw
    [SerializeField]
    private float distanceToRun = 100f; // {get; set; }
    [SerializeField]
    private float wheelDiameter = .559f; // {get; set; }
    [SerializeField]
    private int ticPerTurn = 4;
    [SerializeField]
    private float speedIntegrationTime = .5f;

    private string inputID;
    private float distancePerTick;
    private float distanceRun;
    private float normalSpeed;

    public float Speed {get; set; }

    private Queue<float> impulses = new Queue<float>();
    private float lastTimeImp;
    private float lastTimeDlt;
    public  float maxTimeDlt = 1.0f;
    private float filteredSpeed;

    private VideoManager vm;

    private GameManager gm;

    void Awake() {
    }

	// Use this for initialization
	void Start () {
        gm = GameManager.Instance;
        gm.RegisterBike(this, playerID);

        vm = gameObject.GetComponent<VideoManager>();

        // TODO: Refactor w a player manager ?
        switch (playerID) {
            case 0: 
                inputID = "WheelP1";
                break;
            case 1: 
                inputID = "WheelP2";
                break;
        }

        distancePerTick = wheelDiameter * Mathf.PI / ticPerTurn;
        Debug.Log("Distance to run:" + distanceToRun);
        Debug.Log("Distance per tick:" + distancePerTick);

        normalSpeed = distanceToRun / vm.raceFinishTime;
	}
	
	// Update is called once per frame
	void Update () {
	    if (Input.GetButtonDown(inputID))
            WheelTic();

        //Speed = getBikeSpeedLegacy(speedIntegrationTime);
        Speed = getBikeSpeedApproxFiltered();

        vm.speed = Speed / normalSpeed;
	}

    void FixedUpdate() {
    }

    int getBikeImpulses(float timeWindow = .5f) {
        if (impulses.Count == 0) {
            return 0;
        }

        float time = Time.time;
        float delta = time - impulses.Peek();
        while (delta > timeWindow) {
            impulses.Dequeue();
            if (impulses.Count == 0) {
                break;
            }
            delta = time - impulses.Peek();
        }
        return impulses.Count;
    }

    float getBikeSpeedApproxFiltered(float max = 90 / 3.6f) {
        float speed = getBikeSpeedApprox();
        if (speed < max)
            filteredSpeed = speed;
        return filteredSpeed;
    }

    float getBikeSpeedApprox() {
        float newTimeDlt = Time.time - lastTimeImp;

        if (lastTimeDlt < 0.01)
            return 0f;
        if (newTimeDlt < lastTimeDlt)
            return distancePerTick / lastTimeDlt;
        if (newTimeDlt < maxTimeDlt)
            return distancePerTick / newTimeDlt;
        return 0f;
    }

    float getBikeSpeedLegacy(float timeWindow = .5f) {
        int imp = getBikeImpulses(timeWindow);
        return imp * distancePerTick / timeWindow;
    }

    void WheelTic() {
        impulses.Enqueue(Time.time);
        distanceRun += distancePerTick;
        //Debug.Log(GetProgress());
        
        lastTimeDlt = Time.time - lastTimeImp;
        lastTimeImp = Time.time;

        Debug.Log(lastTimeDlt);
    }

    public float GetProgress() {
        return distanceRun / distanceToRun;
    }

    public float GetDistance() {
        return distanceRun;
    }
}