using Newtonsoft.Json;

using System;

using System.Collections.Generic;

using System.Linq;

using System.Net.Http;

using System.Threading.Tasks;

using System.Web.Mvc;

using Xunit;

​

namespace FlightRoutesCalculatorApp

{

    public class HomeController : Controller

    {

​

        private IFlightCatalogService _flightCatalogService { get; set; }

        private IRoutesCatalogService _routesCatalogService { get; set; }

        private ICheapestFlightRouteService _cheapestFlightRouteService { get; set; }

​

        //TODO: Implement autofac for the IOC (Inversion of control)

        public HomeController()

        {

            _flightCatalogService = new FlightCatalogService();

            _routesCatalogService = new RoutesCatalogService();

            _cheapestFlightRouteService = new CheapestFlightRouteService(_routesCatalogService);

        }

​

        public async Task<ActionResult> Index()

        {

            //Get the catalog of fligts

            var flightsCatalog = await _flightCatalogService.GetCatalog();

            //Get the cheapest flight route

            var cheapestFlightRoute = _cheapestFlightRouteService.SearchCheapestFlightRoute(flightsCatalog.OutboundFlights, flightsCatalog.InboundFlights);

​

            //Filter allowed flight routes

            var validInboundFlights = _routesCatalogService.GetAllowedFlightRoutesIds(cheapestFlightRoute.OutboundFlight, flightsCatalog.InboundFlights);

​

            //Create the model

            FlightRoutesViewModel model = new FlightRoutesViewModel(flightsCatalog.OutboundFlights, flightsCatalog.InboundFlights, cheapestFlightRoute, validInboundFlights);

​

            return View(model);

​

        }

​

        [HttpPost]

        public async Task<ActionResult> Index(FlightRoutesViewModel frm)

        {

            //Get the catalog of fligts

            var flightsCatalog = await _flightCatalogService.GetCatalog();

​

            int outboundFlightId = int.Parse(frm.OutboundFlightSelectedId);

​

            //Search the outbound flight

            var outboundFlight = flightsCatalog.OutboundFlights.Where(c => c.Id == outboundFlightId).FirstOrDefault();

​

            //Init a list for a single outbound flight

            IList<Flight> singleOutboundFlightList = new List<Flight>();

            singleOutboundFlightList.Add(outboundFlight);

​

            //Get the cheapest flight route

            var cheapestFlightRoute = _cheapestFlightRouteService.SearchCheapestFlightRoute(singleOutboundFlightList, flightsCatalog.InboundFlights);

​

            //Filter allowed flight routes

            var validInboundFlights = _routesCatalogService.GetAllowedFlightRoutesIds(cheapestFlightRoute?.OutboundFlight, flightsCatalog?.InboundFlights);

​

            FlightRoutesViewModel vm = new FlightRoutesViewModel(flightsCatalog.OutboundFlights, flightsCatalog.InboundFlights, cheapestFlightRoute, validInboundFlights);

​

            return View(vm);

​

        }

    }

​

    #region Flight Catalog Service

    public interface IFlightCatalogService

    {

        Task<FlightCatalog> GetCatalog();

    }

​

    /// <summary>

    /// This service get the remote catalog data from our flight aggregator

    /// </summary>

    public class FlightCatalogService : IFlightCatalogService

    {

​

        static readonly HttpClient client = new HttpClient();

​

        /// <summary>

        /// Get the data from our flight aggregator

        /// </summary>

        /// <returns>A Catalog that contains outbound flights and inbound flights</returns>

        public async Task<FlightCatalog> GetCatalog()

        {

​

            FlightCatalog flightCatalog = null;

​

            try

            {

                HttpResponseMessage response = await client.GetAsync("http://www.mocky.io/v2/5cebcb7d330000cc296d7772");

                response.EnsureSuccessStatusCode();

                string responseBody = await response.Content.ReadAsStringAsync();

                flightCatalog = JsonConvert.DeserializeObject<FlightCatalog>(responseBody);

            }

            catch (Exception e)

            {

                Console.WriteLine("\nException Caught!");

                Console.WriteLine("Message :{0} ", e.Message);

            }

​

            return flightCatalog;

​

        }

​

    }

​

    /// <summary>

    /// Represents the catalog offers of our flight aggregator

    /// </summary>

    public class FlightCatalog

    {

        public IList<Flight> OutboundFlights { get; set; }

        public IList<Flight> InboundFlights { get; set; }

    }

​

    /// <summary>

    /// Data flight structure

    /// </summary>

    public class Flight

    {

        public int Id { get; set; }

        public string Airline { get; set; }

        public string DepartureAirportCode { get; set; }

        public string ArrivalAirportCode { get; set; }

        public decimal Price { get; set; }

    }

    #endregion

​

    #region Routes Catalog Service

    public interface IRoutesCatalogService

    {

​

        IEnumerable<FlightRoutes> GetAllRoutes(IList<Flight> outboundFlights, IList<Flight> inboundFlights);

        IList<int> GetAllowedFlightRoutesIds(Flight outboundFlight, IList<Flight> inboundFlights);

​

    }

​

    public class RoutesCatalogService : IRoutesCatalogService

    {

​

        /// <summary>

        /// Gets all the routes flights

        /// </summary>

        /// <param name="outboundFlights">List of outbound flights</param>

        /// <param name="inboundFlights">List of inbound flights</param>

        /// <returns></returns>

        //TODO: Convert to an IList ??

        public IEnumerable<FlightRoutes> GetAllRoutes(IList<Flight> outboundFlights, IList<Flight> inboundFlights)

        {

​

            if (outboundFlights == null || inboundFlights == null) return null;

​

            var routesWithAirLineMatchCatalog = from outbound in outboundFlights

                                                join inbound in inboundFlights on new { X1 = outbound.DepartureAirportCode, X2 = outbound.ArrivalAirportCode, X3 = outbound.Airline } equals new { X1 = inbound.ArrivalAirportCode, X2 = inbound.DepartureAirportCode, X3 = inbound.Airline }

                                                select new FlightRoutes(outbound, inbound);

​

            if (routesWithAirLineMatchCatalog != null)

                return routesWithAirLineMatchCatalog;

​

            var routesWithoutAirLineMatchCatalog = from outbound in outboundFlights

                                                   join inbound in inboundFlights on new { X1 = outbound.DepartureAirportCode, X2 = outbound.ArrivalAirportCode } equals new { X1 = inbound.ArrivalAirportCode, X2 = inbound.DepartureAirportCode }

                                                   select new FlightRoutes(outbound, inbound);

​

            return routesWithoutAirLineMatchCatalog;

​

        }

​

        /// <summary>

        /// Given an outbound flights in rerturns the valid inbound flights

        /// </summary>

        /// <param name="outboundFlight"></param>

        /// <param name="inboundFlights"></param>

        /// <returns></returns>

        public IList<int> GetAllowedFlightRoutesIds(Flight outboundFlight, IList<Flight> inboundFlights)

        {

            if (outboundFlight == null || inboundFlights == null) 

                return null;

​

            IList<Flight> singleOutboundFligthList = new List<Flight>();

            singleOutboundFligthList.Add(outboundFlight);

​

            var flightRoutes = GetAllRoutes(singleOutboundFligthList, inboundFlights);

​

            if (flightRoutes == null)

                return null;

​

            IList<int> validInboundFlightsIdsList = new List<int>();

            foreach (var route in flightRoutes)

            {

                validInboundFlightsIdsList.Add(route.InboundFlight.Id);

            }

​

            return validInboundFlightsIdsList;

        }

​

    }

​

    public class FlightRoutes

    {

​

        public Flight OutboundFlight { get; set;}

        public Flight InboundFlight { get; set;}

​

        public FlightRoutes(Flight outboundFlight, Flight inboundFlight)

        {

            OutboundFlight = outboundFlight;

            InboundFlight = inboundFlight;

        }

​

    }

    #endregion

​

    #region Cheapest Flight Route

    public interface ICheapestFlightRouteService

    {

        CheapestFlightRoute SearchCheapestFlightRoute(IList<Flight> outboundFlights, IList<Flight> inboundFlights);

    }

​

    /// <summary>

    /// This class search the cheapest of all routes

    /// </summary>

    public class CheapestFlightRouteService : ICheapestFlightRouteService

    {

​

        private IRoutesCatalogService _routeCatalogService;

​

        public CheapestFlightRouteService(IRoutesCatalogService routeCatalogService)

        {

            _routeCatalogService = routeCatalogService; // ?? throw new Exception(nameof(routeCatalogService));

        }

​

        /// <summary>

        /// Search the cheapest flight route

        /// </summary>

        /// <param name="outboundFlight"></param>

        /// <param name="inboundFlights"></param>

        /// <returns></returns>

        public CheapestFlightRoute SearchCheapestFlightRoute(IList<Flight> outboundFlights, IList<Flight> inboundFlights)

        {

​

            IList<CheapestFlightRoute> routesTotalPriceList = new List<CheapestFlightRoute>();

​

            var routes = _routeCatalogService.GetAllRoutes(outboundFlights, inboundFlights);

​

            foreach (var item in routes)

                routesTotalPriceList.Add(new CheapestFlightRoute(item.OutboundFlight, item.InboundFlight, item.OutboundFlight.Price + item.InboundFlight.Price));

​

            return routesTotalPriceList.OrderBy(c => c.TotalPrice).FirstOrDefault();

​

        }

​

    }

​

    public class CheapestFlightRoute

    {

        public Flight OutboundFlight { get; set;}

        public Flight InboundFlight { get; set;}

        public decimal TotalPrice { get; set;}

​

        public CheapestFlightRoute(Flight outboundFlight, Flight inboundFlight, decimal totalPrice)

        {

            OutboundFlight = outboundFlight;

            InboundFlight = inboundFlight;

            TotalPrice = totalPrice;

        }

    }

    #endregion

​

    #region Unit Test

    public class FligthRoutesTest

    {

​

        private IFlightCatalogService _flightCatalogService { get; set; }

        private IRoutesCatalogService _routesCatalogService { get; set; }

        private ICheapestFlightRouteService _cheapestFlightRouteService { get; set; }

​

        private FlightCatalog _catalogFlights { get; set; }

​

        //TODO: Implement autofac for the IOC (Inversion of control)

        public FligthRoutesTest()

        {

            _flightCatalogService = new FlightCatalogService();

            _routesCatalogService = new RoutesCatalogService();

            _cheapestFlightRouteService = new CheapestFlightRouteService(_routesCatalogService);           

        }

​

        [Theory]

        [InlineData(1, "AMS", "BCN")]

        public async Task Should_Get_From_OutboundFlightId_1_A_Valid_Inbound_Flight_Route_AMS_BCN(int outboundFlightId, string inboundDepartureExpected, string inboundArribalExpected)

        {

​

            _catalogFlights = await _flightCatalogService.GetCatalog();

            Flight outboundFlight = _catalogFlights.OutboundFlights.Where(c => c.Id == outboundFlightId).FirstOrDefault();

            IRoutesCatalogService sut = new RoutesCatalogService();

​

            var result = sut.GetAllowedFlightRoutesIds(outboundFlight, _catalogFlights.InboundFlights);

​

            foreach(var id in result)

            {

                Flight inboundFlight = _catalogFlights.InboundFlights.Where(c => c.Id == id).FirstOrDefault();

                Assert.Equal(inboundDepartureExpected, inboundFlight.DepartureAirportCode);

                Assert.Equal(inboundArribalExpected, inboundFlight.ArrivalAirportCode);

            }

​

        }

​

        [Theory]

        [InlineData(2, "AMS", "BCN")]

        public async Task Should_Get_A_OutboundFlightId_2_Valid_Inbound_Flight_Route_AMS_BCN(int outboundFlightId, string inboundDepartureExpected, string inboundArribalExpected)

        {

​

            _catalogFlights = await _flightCatalogService.GetCatalog();

            Flight outboundFlight = _catalogFlights.OutboundFlights.Where(c => c.Id == outboundFlightId).FirstOrDefault();

            IRoutesCatalogService sut = new RoutesCatalogService();

​

            var result = sut.GetAllowedFlightRoutesIds(outboundFlight, _catalogFlights.InboundFlights);

​

            foreach (var id in result)

            {

                Flight inboundFlight = _catalogFlights.InboundFlights.Where(c => c.Id == id).FirstOrDefault();

                Assert.Equal(inboundDepartureExpected, inboundFlight.DepartureAirportCode);

                Assert.Equal(inboundArribalExpected, inboundFlight.ArrivalAirportCode);

            }

​

        }

​

        [Theory]

        [InlineData(3, "AMS", "GIR")]

        public async Task Should_Get_A_OutboundFlightId_2_Valid_Inbound_Flight_Route_AMS_GIR(int outboundFlightId, string inboundDepartureExpected, string inboundArribalExpected)

        {

​

            _catalogFlights = await _flightCatalogService.GetCatalog();

            Flight outboundFlight = _catalogFlights.OutboundFlights.Where(c => c.Id == outboundFlightId).FirstOrDefault();

            IRoutesCatalogService sut = new RoutesCatalogService();

​

            var result = sut.GetAllowedFlightRoutesIds(outboundFlight, _catalogFlights.InboundFlights);

​

            foreach (var id in result)

            {

                Flight inboundFlight = _catalogFlights.InboundFlights.Where(c => c.Id == id).FirstOrDefault();

                Assert.Equal(inboundDepartureExpected, inboundFlight.DepartureAirportCode);

                Assert.Equal(inboundArribalExpected, inboundFlight.ArrivalAirportCode);

            }

​

        }

​

    }

    #endregion 

​

}