public bool RemovePlaneFromWaiting(String id)
        {
            TreeNode <Plane> plane = WaitingPlanes.Find(new Plane(id));

            if (plane != null)
            {
                ArrivedPlanes.Add(plane.Data);
                plane.Data.SetPriority(0);
                WaitingPlanes.Delete(plane.Data);
                if (plane.Data.Track != null)
                {
                    plane.Data.Track.SetPlane(null);
                    plane.Data.Track = null;
                }
                else
                {
                    TrackType            typeToSearch = new TrackType(plane.Data.GetMinimalTrackLength());
                    TreeNode <TrackType> type         = TrackTypes.Find(typeToSearch);
                    type.Data.WaitingPlanes.Delete(plane.Data);
                    type.Data.WaitingPlanesForSearch.Delete(plane.Data);
                }
                TrackAllocations.Add("plane ID" + plane.Data.GetInternationalID() + " removed from waiting queue");
                return(true);
            }
            else
            {
                return(false);
            }
        }
        public void AddNewPlane(String producerName, String type, String internationalID, double minimalTrackLength)
        {
            Plane plane = new Plane(producerName, type, internationalID, minimalTrackLength, SystemTime, 0);

            Planes.Add(plane);
            ArrivedPlanes.Add(plane);
            PlaneArrivals.Add("plane " + plane.GetInternationalID() + " arrived " + plane.GetArrivalTime());
        }
        /*
         * Returns true if plane id is already in system database
         */
        public bool NotifyArrival(String internationalID)
        {
            Plane            planeToSearch = new Plane(internationalID);
            TreeNode <Plane> planeFound    = Planes.Find(planeToSearch);

            if (planeFound == null)
            {
                return(false);
            }
            else
            {
                planeFound.Data.SetArrivalTime(SystemTime);
                ArrivedPlanes.Add(planeFound.Data);
                PlaneArrivals.Add("plane " + planeFound.Data.GetInternationalID() + " arrived " + planeFound.Data.GetArrivalTime());
                return(true);
            }
        }
        public void ReadFromFile()
        {
            SystemTime = DateTime.Parse(File.ReadAllText("D:\\.NET Projects\\PlaneDepartureTracking\\PlaneDepartureTrackingMSTest\\SystemTime.txt"));


            String[] planes = File.ReadAllText("D:\\.NET Projects\\PlaneDepartureTracking" +
                                               "\\PlaneDepartureTrackingMSTest\\Planes.txt").Split('\n');
            int test = 0;

            for (int i = 0; i < planes.Length; i++)
            {
                String [] row = planes[i].Split(',');
                if (row.Length >= 6)
                {
                    test++;
                    Plane plane = new Plane(row[0], row[1], row[2],
                                            Double.Parse(row[3]),
                                            DateTime.Parse(row[4]),
                                            Double.Parse(row[6].Replace('.', ',')));
                    plane.SetTrackRequirementTime(DateTime.Parse(row[5]));
                    Planes.Add(plane);
                }
            }
            System.Windows.Forms.MessageBox.Show("" + test);


            String[] trackAllocations = File.ReadAllText("D:\\.NET Projects\\PlaneDepartureTracking\\PlaneDepartureTrackingMSTest\\TrackAllocations.txt").Split(',');
            for (int i = 0; i < trackAllocations.Length; i++)
            {
                String allocation = trackAllocations[i];
                TrackAllocations.Add(allocation);
            }

            ArrivedPlanes.SplayDisabled = true;
            String[] arrivedPlanes = File.ReadAllText("D:\\.NET Projects\\PlaneDepartureTracking" +
                                                      "\\PlaneDepartureTrackingMSTest\\ArrivedPlanes.txt").Split();
            foreach (String planeID in arrivedPlanes)
            {
                TreeNode <Plane> plane = Planes.Find(new Plane(planeID));
                if (plane != null)
                {
                    ArrivedPlanes.Add(plane.Data);
                }
            }
            ArrivedPlanes.SplayDisabled = false;

            String[] planeArrivals = File.ReadAllText("D:\\.NET Projects\\PlaneDepartureTracking\\PlaneDepartureTrackingMSTest\\PlaneArrivals.txt").Split(',');
            foreach (String arrival in planeArrivals)
            {
                PlaneArrivals.Add(arrival);
            }

            String[] planeDepartures = File.ReadAllText("D:\\.NET Projects\\PlaneDepartureTracking\\PlaneDepartureTrackingMSTest\\PlaneDepartures.txt").Split(',');
            foreach (String departure in planeDepartures)
            {
                PlaneDepartures.Add(departure);
            }

            String[] pairs = File.ReadAllText("D:\\.NET Projects\\PlaneDepartureTracking" +
                                              "\\PlaneDepartureTrackingMSTest\\TrackPlanes.txt").Split(',');
            foreach (String pair in pairs)
            {
                String[] splittedPair = pair.Split(':');
                if (splittedPair.Length == 2)
                {
                    String           trackName = splittedPair[0];
                    String           planeID   = splittedPair[1];
                    TreeNode <Plane> plane     = Planes.Find(new Plane(planeID));
                    TreeNode <Track> track     = Tracks.Find(new Track(trackName));
                    if (plane != null && track != null)
                    {
                        plane.Data.Track = track.Data;
                        track.Data.SetPlane(plane.Data);
                    }
                }
            }


            WaitingPlanes.SplayDisabled = true;
            String[] waitingPlanes = File.ReadAllText("D:\\.NET Projects\\PlaneDepartureTracking" +
                                                      "\\PlaneDepartureTrackingMSTest\\WaitingPlanes.txt").Split();
            foreach (String planeID in waitingPlanes)
            {
                TreeNode <Plane> plane = Planes.Find(new Plane(planeID));
                if (plane != null)
                {
                    WaitingPlanes.Add(plane.Data);
                }
            }
            WaitingPlanes.SplayDisabled = false;

            foreach (double length in TrackTypesLengthList)
            {
                TreeNode <TrackType> type = TrackTypes.Find(new TrackType(length));

                if (type != null)
                {
                    type.Data.WaitingPlanesForSearch.SplayDisabled = true;
                    String[] waitingPlanesForSearchTrack = File.ReadAllText("D:\\.NET Projects\\PlaneDepartureTracking" +
                                                                            "\\PlaneDepartureTrackingMSTest\\" +
                                                                            type.Data.Length
                                                                            + "WaitingPlanesForSearch.txt").Split();
                    foreach (String planeID in waitingPlanesForSearchTrack)
                    {
                        TreeNode <Plane> plane = Planes.Find(new Plane(planeID));
                        if (plane != null)
                        {
                            type.Data.WaitingPlanesForSearch.Add(plane.Data);
                        }
                    }
                    type.Data.WaitingPlanesForSearch.SplayDisabled = false;

                    String[] waitingPlanesTrack = File.ReadAllText("D:\\.NET Projects\\PlaneDepartureTracking" +
                                                                   "\\PlaneDepartureTrackingMSTest\\" +
                                                                   type.Data.Length
                                                                   + "WaitingPlanes.txt").Split();
                    foreach (String planeID in waitingPlanesTrack)
                    {
                        TreeNode <Plane> plane = Planes.Find(new Plane(planeID));
                        if (plane != null)
                        {
                            type.Data.WaitingPlanes.Add(plane.Data);
                        }
                    }
                    foreach (Track track in type.Data.Tracks)
                    {
                        String[] trackHistory = File.ReadAllText("D:\\.NET Projects\\PlaneDepartureTracking" +
                                                                 "\\PlaneDepartureTrackingMSTest\\" +
                                                                 track.GetName() +
                                                                 "History.txt").Split('\n');

                        foreach (String entry in trackHistory)
                        {
                            String[] splittedEntry = entry.Split(',');
                            if (splittedEntry.Length == 2)
                            {
                                track.DepartureHistory.Add(new PlaneShortInfo(splittedEntry[0],
                                                                              DateTime.Parse(splittedEntry[1])));
                            }
                        }
                    }
                }
            }

            waitingCount = Int32.Parse(File.ReadAllText("D:\\.NET Projects\\PlaneDepartureTracking" +
                                                        "\\PlaneDepartureTrackingMSTest\\WaitingCount.txt"));
        }
        public void SaveToFile()
        {
            File.WriteAllText("D:\\.NET Projects\\PlaneDepartureTracking\\PlaneDepartureTrackingMSTest\\SystemTime.txt",
                              SystemTime.ToString());

            File.WriteAllText("D:\\.NET Projects\\PlaneDepartureTracking\\PlaneDepartureTrackingMSTest\\Planes.txt",
                              Planes.TraverseLevelOrder());

            StringBuilder trackAllocations = new StringBuilder();

            foreach (String allocation in TrackAllocations)
            {
                trackAllocations.Append(allocation + ",");
            }
            File.WriteAllText("D:\\.NET Projects\\PlaneDepartureTracking\\PlaneDepartureTrackingMSTest\\TrackAllocations.txt",
                              trackAllocations.ToString());

            File.WriteAllText("D:\\.NET Projects\\PlaneDepartureTracking\\PlaneDepartureTrackingMSTest\\ArrivedPlanes.txt",
                              ArrivedPlanes.TraverseIDsLevelOrder());

            StringBuilder planeArrivals = new StringBuilder();

            foreach (String arrival in PlaneArrivals)
            {
                planeArrivals.Append(arrival + ",");
            }
            File.WriteAllText("D:\\.NET Projects\\PlaneDepartureTracking\\PlaneDepartureTrackingMSTest\\PlaneArrivals.txt",
                              planeArrivals.ToString());

            StringBuilder planeDepartures = new StringBuilder();

            foreach (String departure in PlaneDepartures)
            {
                planeDepartures.Append(departure + ",");
            }
            File.WriteAllText("D:\\.NET Projects\\PlaneDepartureTracking\\PlaneDepartureTrackingMSTest\\PlaneDepartures.txt",
                              planeDepartures.ToString());

            StringBuilder trackString = new StringBuilder();

            foreach (Track track in TrackList)
            {
                if (track.GetPlane() != null)
                {
                    trackString.Append(track.GetName() + ":" + track.GetPlane().GetInternationalID() + ",");
                }
            }
            File.WriteAllText("D:\\.NET Projects\\PlaneDepartureTracking\\PlaneDepartureTrackingMSTest\\TrackPlanes.txt",
                              trackString.ToString());

            File.WriteAllText("D:\\.NET Projects\\PlaneDepartureTracking\\PlaneDepartureTrackingMSTest\\WaitingPlanes.txt",
                              WaitingPlanes.TraverseIDsLevelOrder());

            foreach (double length in TrackTypesLengthList)
            {
                TrackType type = TrackTypes.Find(new TrackType(length)).Data;

                File.WriteAllText("D:\\.NET Projects\\PlaneDepartureTracking\\PlaneDepartureTrackingMSTest\\" +
                                  type.Length
                                  + "WaitingPlanes.txt",
                                  type.WaitingPlanes.TraverseIDsLevelOrder());

                File.WriteAllText("D:\\.NET Projects\\PlaneDepartureTracking\\PlaneDepartureTrackingMSTest\\" +
                                  type.Length
                                  + "WaitingPlanesForSearch.txt",
                                  type.WaitingPlanesForSearch.TraverseIDsLevelOrder());

                foreach (Track track in type.Tracks)
                {
                    StringBuilder history = new StringBuilder();
                    foreach (PlaneShortInfo info in track.DepartureHistory)
                    {
                        history.Append(info.ID + "," + info.DepartureTime + "\n");
                    }
                    File.WriteAllText("D:\\.NET Projects\\PlaneDepartureTracking\\PlaneDepartureTrackingMSTest\\" +
                                      track.GetName() +
                                      "History.txt",
                                      history.ToString());
                }
            }

            File.WriteAllText("D:\\.NET Projects\\PlaneDepartureTracking\\PlaneDepartureTrackingMSTest\\WaitingCount.txt",
                              "" + waitingCount);
        }
        public bool NotifyTrackRequirement(String internationalID, double priority)
        {
            Plane            planeToSearch = new Plane(internationalID);
            TreeNode <Plane> planeFound    = ArrivedPlanes.Find(planeToSearch);

            if (planeFound != null)
            {
                planeFound.Data.SetTrackRequirementTime(SystemTime);
                ArrivedPlanes.Delete(planeFound.Data);
                planeFound.Data.SetPriority(priority + (SystemTime.ToUniversalTime() - beginOfTimes).TotalSeconds * 1.0 / 10000000000);
                WaitingPlanes.Add(planeFound.Data);
                waitingCount++;

                TrackType            typeToSearch = new TrackType(planeFound.Data.GetMinimalTrackLength());
                TreeNode <TrackType> typeFound    = TrackTypes.Find(typeToSearch);
                if (typeFound == null)
                {
                    return(false);
                }
                else
                {
                    foreach (Track track in typeFound.Data.Tracks)
                    {
                        if (track.GetPlane() == null)
                        {
                            planeFound.Data.Track = track;
                            track.SetPlane(planeFound.Data);
                            TrackAllocations.Add("plane ID" + planeFound.Data.GetInternationalID() + " to " + track.GetName()
                                                 );
                            break;
                        }
                    }
                    if (planeFound.Data.Track == null && waitingCount / TrackList.Count > 5)
                    {
                        int upperTypeIndex = TrackTypesLengthList.IndexOf(typeFound.Data.Length) + 1;
                        if (upperTypeIndex < TrackTypesLengthList.Count)
                        {
                            TrackType upperType = TrackTypes.Find(new TrackType(TrackTypesLengthList[upperTypeIndex])).Data;
                            foreach (Track track in upperType.Tracks)
                            {
                                if (track.GetPlane() == null)
                                {
                                    planeFound.Data.Track = track;
                                    track.SetPlane(planeFound.Data);
                                    TrackAllocations.Add("!!! plane ID" + planeFound.Data.GetInternationalID() + " to " + track.GetName()
                                                         );
                                    break;
                                }
                            }
                        }
                    }
                    if (planeFound.Data.Track == null)
                    {
                        typeFound.Data.WaitingPlanes.Add(planeFound.Data);
                        typeFound.Data.WaitingPlanesForSearch.Add(planeFound.Data);
                    }
                }
                return(true);
            }
            return(false);
        }