using PartSource.Automation.Models.Cache;
using PartSource.Data.Nexpart;
using PartSource.Services;
using System;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace PartSource.Automation.Services
{
    public class VehicleCacheService
    {
        private readonly ConcurrentBag<VehicleCacheItem> _vehicleCache;
        private readonly ConcurrentBag<BaseVehicle> _sorryNotCanadianCache;

        private readonly NexpartService _nexpartService;

        public VehicleCacheService(NexpartService nexpartService)
        {
            _vehicleCache = new ConcurrentBag<VehicleCacheItem>();
            _sorryNotCanadianCache = new ConcurrentBag<BaseVehicle>();

            _nexpartService = nexpartService;
        }

        public VehicleCacheItem Get(int baseVehicleId, int engineConfigId)
        {
            return _vehicleCache.FirstOrDefault(v => v.BaseVehicle.BaseVehicleId == baseVehicleId && v.BaseVehicle.EngineConfigId == engineConfigId);
        }

        public void Add(VehicleCacheItem vehicle)
        {
            _vehicleCache.Add(vehicle);
        }

        public bool TryAdd(int baseVehicleId, int engineConfigId)
        {
            BaseVehicle sorryNotCanadian = _sorryNotCanadianCache.FirstOrDefault(b => b.BaseVehicleId == baseVehicleId && b.EngineConfigId == engineConfigId);
            if (sorryNotCanadian != null)
            {
                return false;
            }

            VehicleIdSearch vehicleIdSearch = new VehicleIdSearch
            {
                VehicleIdentifier = new VehicleIdentifier
                {
                    BaseVehicleId = baseVehicleId,
                    EngineConfigId = engineConfigId
                },
                ResultOption = new ResultOption[2]
                {
                    new ResultOption { Value = "BASE_VEHICLE" },
                    new ResultOption { Value = "BASE_VEHICLE_DESC" }
                },
                RegionId = new RegionId
                {
                    Value = 2
                }
            };

            VehicleIdSearchResponse response = _nexpartService.SendRequest<VehicleIdSearch, VehicleIdSearchResponse>(vehicleIdSearch).Result;
            if (response.ResponseBody?.BaseVehicle == null)
            {
                BaseVehicle vehicle = new BaseVehicle
                {
                    BaseVehicleId = baseVehicleId,
                    EngineConfigId = engineConfigId
                };

                _sorryNotCanadianCache.Add(vehicle);

                return false;
            }

            BaseVehicle baseVehicle = response.ResponseBody.BaseVehicle;
            baseVehicle.EngineConfigId = engineConfigId;

            SubModelSearch smSearch = new SubModelSearch()
            {
                MakeId = baseVehicle.MakeId,
                ModelId = baseVehicle.ModelId,
                Year = baseVehicle.Year,
                RegionId = 2
            };
            SubModelSearchResponse smResponse = _nexpartService.SendRequest<SubModelSearch, SubModelSearchResponse>(smSearch).Result;

            SubModel[] subModels = smResponse.ResponseBody?.SubModel;
            if (subModels == null)
            {
                _sorryNotCanadianCache.Add(baseVehicle);
                return false;
            }

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

            foreach (SubModel submodel in subModels)
            {
                VehicleIdSearch vidSearch = new VehicleIdSearch
                {
                    VehicleIdentifier = new VehicleIdentifier()
                    {
                        BaseVehicleId = baseVehicle.BaseVehicleId,
                        EngineConfigId = baseVehicle.EngineConfigId
                    },
                    Criterion = new Criterion[1]
                    {
                        new Criterion
                        {
                            Attribute = "SUB_MODEL",
                            Id = int.Parse(submodel.Id)
                        }
                    },
                    RegionId = new RegionId
                    {
                        Value = 2
                    },
                };

                VehicleIdSearchResponse vidResponse = _nexpartService.SendRequest<VehicleIdSearch, VehicleIdSearchResponse>(vidSearch).Result;
                
                int? vehicleId = vidResponse.ResponseBody?.VehicleToEngineConfigId;
                if (vehicleId != null && vehicleId > 0)
                {
                    vehicleIds.Add((int)vehicleId);
                }
            }

            VehicleCacheItem cacheItem = new VehicleCacheItem
            {
                BaseVehicle = baseVehicle,
                VehicleIds = vehicleIds
            };

            _vehicleCache.Add(cacheItem);

            return true;
        }
    }
}