namespace OpenTraffic.Model.TrafficGenerator
{
    using System;
    using System.Collections.Generic;
    using OpenTraffic.Model.Result;
    using OpenTraffic.Model.Route;

    public class ResultGenerator : AbstractTrafficGenerator
    {
        private List<RouteContainer> routes;
        private List<VehicleClass> classes;
        private Result.ResultData result;
        private Random rand;

        public ResultGenerator()
        {
        }

        public ResultGenerator(List<RouteContainer> routes, List<VehicleClass> classes, Result.ResultData res)
        {
            this.routes = routes;
            this.result = res;
            this.classes = classes;
        }

        public override List<Vehicle> CreateTraffic(float stopTime)
        {
            List<Vehicle> vehs = new List<Vehicle>();
            rand = new Random(12);

            foreach (ResultFrame rf in result.Frames)
            {
                foreach (VehicleClass c in classes)
                {
                    foreach (RouteContainer rc in routes)
                    {
                        foreach (TrafficRoute r in rc.Routes)
                        {
                            ResultRoute rr = rf.GetRoute(c, r);
                            if (rr.vehicles != 0)
                            {
                                int ncars = (int)Math.Floor(rr.vehicles + rand.NextDouble());
                                double deltatime = (rf.StopTime - rf.StartTime) / (ncars + 1);
                                double time = rf.StartTime + deltatime * rand.NextDouble();

                                for (int i = 0; i < ncars; i++)
                                {
                                    if (r != null)
                                    {
                                        System.Diagnostics.Debug.Assert(time <= rf.StopTime);
                                        Vehicle v = new Vehicle((TrafficZone)r.Source.Source, (TrafficZone)r.Target.Target,
                                            (float)time, r, c);
                                        v.Reset();
                                        vehs.Add(v);
                                        time += deltatime;
                                    }
                                }

                            }
                        }

                    }

                }
            }
            return vehs;
        }

        public override AbstractTrafficGenerator SplitDemand(IDictionary<int, int> part, int id)
        {
            List<RouteContainer> nrs = new List<RouteContainer>();

            if (part != null)
            {
                foreach (RouteContainer r in routes)
                {
                    if (part[r.Source.Source.Id] == id)
                    {
                        nrs.Add(r);
                    }
                }
            }

            return new ResultGenerator(nrs, classes, result);
        }

        public override float GetInflow(TrafficZone z, float t)
        {
            return 0.0f;
        }
    }
}