using System;
using System.Collections.Generic;
//using System.Linq;
using System.Web;
using System.Text;

    public class Route
    {
        public string name;
        public List<TripPattern> cTripPattern;
        public List<Trip> cTrip;
        public List<Trip> setcTrip()
        {
            cTrip = new List<Trip>();
            foreach (TripPattern tp in cTripPattern)
            {
                cTrip.AddRange(tp.cTrip);
            }

            // storing yesterday's trips.
            int nTrip = cTrip.Count;
            int day = 0;
            while (cTrip.Count < (nTrip + 4))
            {
                day = day + 1;
                for (int ii = 0; ii < nTrip; ii++)
                {
                    Trip yTrip = cTrip[ii].Copy();
                    for (int i = 0; i < yTrip.cArrivalTime.Count; i++)
                    {
                        yTrip.cArrivalTime[i] = yTrip.cArrivalTime[i] - (day * 24 * 60);
                    }
                    cTrip.Add(yTrip);
                }
            }
            return cTrip;
        }

        public List<string> cDest()
        {
            return cTripPattern[0].cDest;
        }

        public List<int> cDestIndex(string aDest)
        {
            List<int> cDestIndex = new List<int>();
            List<string> cDest = this.cDest();
            // i = 0 represents the start time and not arrival time.
            for (int i = 1; i < cDest.Count; i++)
            {
                if (aDest == cDest[i])
                {
                    cDestIndex.Add(i);
                }
            }
            return cDestIndex;
        }

        public List<Trip> cTripNearestTime(string aDest, int time)
        {
            List<Trip> cTripNearestTime = new List<Trip>();
            List<int> cDestIndex = this.cDestIndex(aDest);
            for (int i = 0; i < cTrip.Count; i++)
            {
                Trip aTrip = cTrip[i];
                if (cDestIndex.Exists(delegate(int index) { return aTrip.cArrivalTime[index] < time; }))
                {
                    cTripNearestTime.Add(aTrip);
                }
            }
            int j = cDestIndex[cDestIndex.Count - 1];
            cTripNearestTime.Sort(delegate(Trip t1, Trip t2) { return t1.cArrivalTime[j].CompareTo(t2.cArrivalTime[j]); });
            return cTripNearestTime;
        }

        public List<int> startandEndTime(string startDest, string endDest, int aArrivalTime)
        {
            List<Trip> cTripNearestTime = this.cTripNearestTime(endDest, aArrivalTime);
            Trip bestTrip = cTripNearestTime[cTripNearestTime.Count - 1].Copy();
            Trip continueBestTrip = cTripNearestTime[cTripNearestTime.Count - 2].Copy();
            Trip secondBestTrip = cTripNearestTime[cTripNearestTime.Count - 3].Copy();
            Trip continueSecondBestTrip = cTripNearestTime[cTripNearestTime.Count - 4].Copy();
            if (bestTrip.overlaps(continueBestTrip))
            {
                secondBestTrip = continueBestTrip;
                continueBestTrip = cTripNearestTime[cTripNearestTime.Count - 3].Copy();
            }
            continueBestTrip.Append(bestTrip);
            continueSecondBestTrip.Append(secondBestTrip);
            List<int> bestStartandEndTime = continueBestTrip.startandEndTime(startDest, endDest, aArrivalTime);
            List<int> secondBestStartEndTime = continueSecondBestTrip.startandEndTime(startDest, endDest, aArrivalTime);
            bestStartandEndTime.AddRange(secondBestStartEndTime);
            return bestStartandEndTime;
        }

        public string joinStartandEnd(Route startRoute, string startDest, string endDest)
        {
            List<string> csDest = new List<string>();
            List<string> ceDest = new List<string>();
            csDest.AddRange(startRoute.cDest());
            ceDest.AddRange(this.cDest());
            List<string> commonDest = new List<string>();
            foreach (string str in csDest)
            {
                if (ceDest.Contains(str))
                {
                    commonDest.Add(str);
                }
            }
            int endIndex = -1;
            List<string> cEndDest = this.cDest();
            for (int i = cEndDest.Count - 1; endIndex < 0; i--)
            {
                if (cEndDest[i] == endDest)
                {
                    endIndex = i;
                }
            }
            int startIndex = -1;
            for (int i = endIndex - 1; (startIndex < 0) & (i >= 0); i--)
            {
                if (cEndDest[i] == endDest)
                {
                    endIndex = i;
                }
                if (commonDest.Contains(cEndDest[i]))
                {
                    startIndex = i;
                }
            }
            return cEndDest[startIndex];
        }
    }