package de.hems.trafficsim;

import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;
import java.util.Observable;

public class Track extends Observable {
    protected List<Vehicle> vehicles;

    public List<List<VehicleTimeRecord>> getVtrList() {
        return vtrList;
    }

    protected List<List<VehicleTimeRecord>> vtrList;
    protected float trackLength;
    protected float sumAvgMemory;

    public float getLastAvg() {
        return lastAvg;
    }

    protected float lastAvg;

    public List<Vehicle> getVehicles() {
        return vehicles;
    }

    public float getTrackLength() {
        return trackLength;
    }

    public Track(int numberVehicles, float trackLength) {
        this.trackLength = trackLength;
        this.vehicles = createVehiclesList(numberVehicles);
        this.vtrList = new LinkedList<>();
        this.sumAvgMemory = 0;
        this.lastAvg = 0;
    }

    protected List<Vehicle> createVehiclesList(int numberVehicles){
        List<Vehicle> result = new ArrayList<>();
        for(int i=0;i<numberVehicles;i++){
            Vehicle vehicle = new Vehicle(i, i, 6, 0.3f, this.trackLength);
            result.add(vehicle);
        }

        return result;
    }

    public void timeElapse() {
        for(int i=0; i<vehicles.size();i++) {
            Vehicle v = vehicles.get(i);
            int forerunnerIndex = i + 1;
            if (forerunnerIndex >= vehicles.size()) {
                forerunnerIndex -= vehicles.size();
            }
            Vehicle forerunner = vehicles.get(forerunnerIndex);
            float distanceForerunner = forerunner.getPosition() - v.getPosition() - 1;
            if(distanceForerunner < 0.0){
                distanceForerunner += this.trackLength;
            }
            v.updateVelocity(distanceForerunner);
        }
        List <VehicleTimeRecord> records = new ArrayList<>(vehicles.size());
        this.vtrList.add(records);
        for(Vehicle v: vehicles){
            v.timeElapse();
            VehicleTimeRecord vtr = new VehicleTimeRecord(v.id, v.position, v.curVelocity, v.maxVelocity);
            records.add(vtr);
        }
        update_avg();
        this.setChanged();
        this.notifyObservers();
        this.clearChanged();
//        try  {
//            Thread.sleep(125);
//        } catch (InterruptedException ex) {
//
//        }
    }

    public float avg_step(int step){
        float sum_step = 0;
        for (VehicleTimeRecord r : vtrList.get(step)) {
            sum_step +=  r.velocity;
        }
        return sum_step / vehicles.size();
    }

    protected void update_avg(){
        sumAvgMemory += avg_step(vtrList.size()-1);
        lastAvg = sumAvgMemory / vtrList.size();
    }

    public float avg_span(int start, int end){
        float sum_span = 0;
        for (int i=start; i <end;i++){
            sum_span += avg_step(i);
        }
        return sum_span / (end-start+1);
    }

}