using Microsoft.AspNetCore.Mvc;
using PartSource.Data.Models;
using PartSource.Services;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Net;
using System.Threading.Tasks;

using NexpartMake = PartSource.Data.Nexpart.Make;
using NexpartModel = PartSource.Data.Nexpart.Model;
using NexpartEngine = PartSource.Data.Nexpart.Engine;
using NexpartSubmodel = PartSource.Data.Nexpart.SubModel;

namespace PartSource.Api.Controllers
{
    /// <summary>
    /// This controller exists to enable legacy support for the old Nexpart-based vehicle lookup.
    /// </summary>
    [Route("vehicles")]
    [Route("v1/vehicles")]
    [ApiController]
    [ApiExplorerSettings(GroupName = "v1")]
    public class LegacyVehiclesController : BaseNexpartController
    {
        private readonly VehicleService _vehicleService;

        public LegacyVehiclesController(VehicleService vehicleService)
        {
            _vehicleService = vehicleService;
        }

        [HttpGet]
        [Route("makes")]
        public async Task<ActionResult> GetMakes()
        {
            IList<VehicleMake> vehicleMakes = await _vehicleService.GetMakes();
            IList<NexpartMake> nexpartMakes = new List<NexpartMake>();

            foreach (VehicleMake make in vehicleMakes)
            {
                nexpartMakes.Add(new NexpartMake
                {
                    Id = make.MakeId,
                    Value = make.Name.Trim()
                });
            }

            return Ok(new { data = new { make = nexpartMakes } });
        }

        [HttpGet]
        [Route("models/makeid/{makeId}/modelyear/{year}")]
        public async Task<ActionResult> GetModels(int makeId, int year)
        {
            IList<VehicleModel> vehicleModels = await _vehicleService.GetModels(makeId, year);
            IList<NexpartModel> nexpartModels = new List<NexpartModel>();

            foreach (VehicleModel model in vehicleModels)
            {
                nexpartModels.Add(new NexpartModel
                {
                    Id = model.ModelId,
                    Value = model.Name.Trim()
                });
            }

            return Ok(new { data = new[] { new { model = nexpartModels } } });
        }

        [HttpGet]
        [Route("basevehicle/makeid/{makeId}/modelid/{modelId}/modelyear/{year}")] 
        [Route("basevehicles/makeid/{makeId}/modelid/{modelId}/modelyear/{year}")]
        public async Task<ActionResult> GetBaseVehicle(int makeId, int modelId, int year)
        {
            BaseVehicle baseVehicle = await _vehicleService.GetBaseVehicle(makeId, modelId, year);

            return Ok(new { data = baseVehicle });
        }

        [HttpGet]
        [Route("engines/basevehicleid/{baseVehicleId}")]
        [Route("engines/basevehicleid/{baseVehicleId}/submodelid/{subModelId}")]
        public async Task<ActionResult> GetEngines(int baseVehicleId, int? submodelId = null)
        {
            IList<NexpartEngine> nexpartEngines = new List<NexpartEngine>();
            IList<Engine> engines = submodelId == null
                ? await _vehicleService.GetEngines(baseVehicleId)
                : await _vehicleService.GetEngines(baseVehicleId, (int)submodelId);

            foreach(Engine engine in engines)
            {
                nexpartEngines.Add(new NexpartEngine
                {
                    Id = engine.EngineConfigId,
                    Value = engine.Description.Trim()
                });
            }

            return Ok(new { data = new { engine = nexpartEngines } });
        }

        [HttpGet]
        [Route("trim/makeid/{makeId}/modelid/{modelId}/modelyear/{year}")]
        [Route("submodels/makeid/{makeId}/modelid/{modelId}/modelyear/{year}")]
        public async Task<ActionResult> GetSubmodels(int makeId, int modelId, int year)
        {
            IList<Submodel> submodels = await _vehicleService.GetSubmodels(makeId, modelId, year);
            IList<NexpartSubmodel> nexpartSubmodels = new List<NexpartSubmodel>();

            foreach (Submodel submodel in submodels)
            {
                nexpartSubmodels.Add(new NexpartSubmodel
                {
                    Id = submodel.SubmodelId.ToString(),
                    Description = submodel.Name.Trim()
                });
            }

            return Ok(new { data = new { subModel = nexpartSubmodels } });
        }

        [HttpGet]
        [Route("detail/basevehicleid/{baseVehicleId}/submodelid/{submodelId}/engineconfigid/{engineConfigId}")]
        public async Task<ActionResult> GetVehicleDetail(int baseVehicleId, int submodelId, int engineConfigId)
        {
            Vehicle vehicle = await _vehicleService.GetVehicle(baseVehicleId, engineConfigId, submodelId);

            return Ok(new { data = vehicle });
        }

        [HttpGet]
        [Route("types")]
        public ActionResult GetVehicleTypes()
        {
            return new StatusCodeResult((int)HttpStatusCode.Gone);
        }

        [HttpGet]
        [Route("makes/vehicletypeid/{vehicleTypeId}")]
        public ActionResult GetMakes(int vehicleTypeId)
        {
            return new StatusCodeResult((int)HttpStatusCode.Gone);
        }

        [HttpGet]
        [Route("models/makeid/{makeId}/modelyear/{year}/vehicletypeid/{vehicleTypeId}")]
        public ActionResult GetModels(int makeId, int year, int vehicleTypeId)
        {
            return new StatusCodeResult((int)HttpStatusCode.Gone);
        }
    }
}