/*
 * Copyright (c) 2005-2006 Erik Tigerholm <eriktigerholm@gmail.com>
 *
 * Permission to use, copy, modify, and distribute this software for any
 * purpose with or without fee is hereby granted, provided that the above
 * copyright notice and this permission notice appear in all copies.
 *
 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 */
namespace OpenTraffic.Network
{
    using System;
    using System.Collections.Generic;
    using System.IO;
    using System.Net;
    using OpenTraffic.Model;
    using OpenTraffic.Model.Route;

    class SyncPacket : Packet<Client>
    {
        private List<LinkInfo> links = null;
        private List<Vehicle> vehicles = null;

        private Client c;

        public const int Type = 1;

        public SyncPacket(Client c, UdpClient<Client> n, IPEndPoint ip)
            : base(n, (int)PACKET_TYPES.SYNC, ip)
        {
            this.c = c;
        }

        public SyncPacket(Client c, UdpClient<Client> n, IPEndPoint ip,
            List<LinkInfo> links, List<Vehicle> vehicle)
            : base(n, (int)PACKET_TYPES.SYNC, ip)
        {
            this.c = c;

            using (MemoryStream mstream = new MemoryStream())
            {
                int nLinks;
                int nVehicles;
                nLinks = links.Count;
                nVehicles = vehicle.Count;

                mstream.Write(BitConverter.GetBytes(nLinks), 0, 4);
                mstream.Write(BitConverter.GetBytes(nVehicles), 0, 4);

                for (int i = 0; i < nLinks; i++)
                {
                    LinkInfo li = links[0];
                    links.RemoveAt(0);
                    mstream.Write(BitConverter.GetBytes(li.Id), 0, 4);
                    mstream.Write(BitConverter.GetBytes(li.FreeCapacity), 0, 4);
                    mstream.Write(BitConverter.GetBytes(li.EstimatedFlow), 0, 4);

                    //                Console.WriteLine("--> Link " + li.Id + " has " + li.FreeCapacity + " free capacity");
                }

                for (int i = 0; i < nVehicles; i++)
                {
                    Vehicle v = vehicle[0];
                    vehicle.RemoveAt(0);

                    // IF you change someting here do not forget to change deserialize method.
                    //                mstream.Write(BitConverter.GetBytes(v.Origin.Id), 0, 4);
                    //                mstream.Write(BitConverter.GetBytes(v.Destination.Id), 0, 4);
                    if (v.LastTimePassedNode == 0.0f) v.LastTimePassedNode = v.StartTime;
                    mstream.Write(BitConverter.GetBytes(v.trafficRoute.ConatinerId), 0, 4);
                    mstream.Write(BitConverter.GetBytes(v.trafficRoute.SubId), 0, 4);
                    mstream.Write(BitConverter.GetBytes(v.StartTime), 0, 4);
                    mstream.Write(BitConverter.GetBytes(v.LastTimePassedNode), 0, 4);
                    mstream.Write(BitConverter.GetBytes(v.routeClass.IdRegister), 0, 2);
                    mstream.Write(BitConverter.GetBytes(v.RoutePos), 0, 2);
                }

                data = mstream.ToArray();
                // Console.WriteLine("Packet: " + nLinks + "/" + links.Count +
                //     " \tVehicle " + nVehicles + "/" + vehicle.Count);
            }
        }

        public override void DoAction()
        {
            c.UpdateModel(ip, links, vehicles);
            n.AddPacketToSend(new AckPacket(this.n, this.ip, this.Sequence));
        }

        protected override void Deserialize(byte[] bytes)
        {
            // System.Runtime.Serialization.IFormatter bin = new System.Runtime.Serialization.Formatters.Binary.BinaryFormatter();
            if (bytes != null)
            {
                using (MemoryStream mstream = new MemoryStream(bytes, 0, bytes.Length))
                {
                    links = new List<Model.LinkInfo>();
                    byte[] buff = new byte[128];

                    mstream.Read(buff, 0, 4);
                    int numLinkInfo = BitConverter.ToInt32(buff, 0);

                    mstream.Read(buff, 0, 4);
                    int numVehicle = BitConverter.ToInt32(buff, 0);
                    //            Console.WriteLine();
                    for (int i = 0; i < numLinkInfo; i++)
                    {
                        mstream.Read(buff, 0, 3 * 4);
                        int id = BitConverter.ToInt32(buff, 0);
                        float capacity = BitConverter.ToSingle(buff, 4);
                        float estimatedFlow = BitConverter.ToSingle(buff, 8);
                        //                  Console.WriteLine("<-- Link " + id + " has " + capacity + " free capacity");

                        links.Add(new LinkInfo(id, capacity, estimatedFlow));
                    }

                    vehicles = new List<Vehicle>();

                    for (int i = 0; i < numVehicle; i++)
                    {
                        mstream.Read(buff, 0, 20);

                        int rcId = BitConverter.ToInt32(buff, 0);
                        int routeId = BitConverter.ToInt32(buff, 4);
                        float starttime = BitConverter.ToSingle(buff, 8);
                        float latest = BitConverter.ToSingle(buff, 12);
                        int cl = BitConverter.ToInt16(buff, 16);
                        int routePos = BitConverter.ToInt16(buff, 18);

                        RouteContainer rc = c.GetRoute(rcId);
                        TrafficRoute r = rc.GetRoute(routeId);
                        Vehicle v = new OpenTraffic.Model.Vehicle(
                                                     (TrafficZone)r.Source.Source,
                                                     (TrafficZone)r.Target.Target,
                                                       starttime,
                                                       r,
                                                       c.GetClass(cl));
                        v.LastTimePassedNode = latest;
                        v.RoutePos = routePos;
                        vehicles.Add(v);
                    }
                }
            }
        }

        public override void DoAck()
        {
        }

        public override string ToString()
        {
            int nvc = vehicles == null ? 0 : vehicles.Count;
            int nlc = links == null ? 0 : links.Count;
            return base.ToString() + " | nCars: " + nvc +
                " | nLink: " + nlc;
        }
    }

}