using System;
using System.Collections.Generic;
using System.Linq;
using Sony.Filtr.Contracts.Abstractions;
using Sony.Filtr.Contracts.Definitions;
using Sony.Filtr.Contracts.Entities;
using Sony.Filtr.Core.LastModified;
using Sony.Filtr.DistributedCaching;

namespace Sony.Filtr.Applications
{
    public class ApplicationInstanceManager : IApplicationInstanceManager
    {
        private readonly ApplicationFactory _applicationFactory;
        private readonly DistributedCacheHandler _distributedCacheHandler;
        private readonly LastModifiedManager _lastModifiedManager;

        public ApplicationInstanceManager(ApplicationFactory applicationFactory, DistributedCacheHandler distributedCacheHandler, LastModifiedManager lastModifiedManager)
        {
            _applicationFactory = applicationFactory;
            _distributedCacheHandler = distributedCacheHandler;
            _lastModifiedManager = lastModifiedManager;
        }

        const string CacheKey = "Applications:" + Application.Version;
        const string ApplicationRegionsCacheKey = "ApplicationRegions:" + Application.Version;

        public Application GetApplication(int id)
        {
            var keypair = GetApplications().FirstOrDefault(a => a.ID == id);
            return keypair;
        }

        public List<Application> GetApplications()
        {
            var applications = _distributedCacheHandler.Get(CacheKey) as List<Application>;
            if (applications == null)
            {
                applications = _applicationFactory.GetApplications();
                _distributedCacheHandler.Put(CacheKey, applications);
            }
            return applications;
        }

        public void ClearApplicationsCache()
        {
            _distributedCacheHandler.Remove(CacheKey);
        }
        
        public Application GetFallbackApplication()
        {
            return GetApplications().FirstOrDefault(a => a.FallbackApplication && !a.WorkoutMarket);
        }

        public Application GetWorkoutFallbackApplication()
        {
            return GetApplications().FirstOrDefault(a => a.FallbackApplication && a.WorkoutMarket);
        }

        public Application GetGlobalPushApplication()
        {
            return GetApplications().FirstOrDefault(a => a.GlobalPushApplication);
        }

        public Application GetApplicationByCountry(string countryCode, bool fallback = true, bool onlyActive = true)
        {
            var apps = GetApplications().Where(a => a.SpotifyRegionCode.Equals(countryCode, StringComparison.InvariantCultureIgnoreCase));
            if (onlyActive)
            {
                apps = apps.Where(a=> a.Active);
            }

            var app = apps.FirstOrDefault();
            if (app != null)
                return app;

            if (fallback)
                return GetFallbackApplication();

            return null;
        }

        public Application GetRegularApplicationByCountrySpecialFallback(string countryCode)
        {
            var apps = GetApplications().Where(a=> !a.WorkoutMarket).ToList();

            var app = apps.FirstOrDefault(a => a.SpotifyRegionCode.Equals(countryCode, StringComparison.InvariantCultureIgnoreCase));
            if (app != null && app.SpotifyRegionCode.Equals("MX", StringComparison.InvariantCultureIgnoreCase) && !app.Active)
                return GetApplicationByCountry("ES");
            if (app != null && app.Active)
                return app;

            if (IsCentralAmericanAndCaribbeanCountry(countryCode))
            {
                var cacMarket = apps.FirstOrDefault(a => a.SpotifyRegionCode.Equals("CA&C", StringComparison.InvariantCultureIgnoreCase));
                if (cacMarket != null && cacMarket.Active)
                    return cacMarket;
            }

            if (IsLatinCountry(countryCode))
            {
                var latinMarket = apps.FirstOrDefault(a => a.SpotifyRegionCode.Equals("Latin", StringComparison.InvariantCultureIgnoreCase));
                if (latinMarket != null && latinMarket.Active)
                    return latinMarket;
            }

            return GetFallbackApplication();
        }


        public bool IsCentralAmericanAndCaribbeanCountry(string countryCode)
        {
            var cacCountryCodes = GetCentralAmericanAndCaribbeanCountryCodes();

            return cacCountryCodes.Contains(countryCode, StringComparer.InvariantCultureIgnoreCase);
        }

        private static readonly IList<string> CacCountryCodes = new[]
        {
            "cr", //Costa Rica
            "pa", //Panama
            "sv", //El Salvador
            "gt", //Guatemala
            "hn", //Honduras 
            "ni", //Nicaragua
            "do", //Dominikanska Republiken
        };
        public IList<string> GetCentralAmericanAndCaribbeanCountryCodes()
        {
            return CacCountryCodes;
        }

        public Application GetWorkoutApplicationByCountrySpecialFallback(string countryCode)
        {
            var workoutApps = GetApplications().Where(a => a.WorkoutMarket).ToList();

            var app = workoutApps.FirstOrDefault(a => a.Active && a.SpotifyRegionCode.Equals(countryCode, StringComparison.InvariantCultureIgnoreCase));
            if (app != null)
                return app;

            if (IsCentralAmericanAndCaribbeanCountry(countryCode))
            {
                var cacMarket = GetCentralAmericaMarket(workoutApps);
                if (cacMarket != null && cacMarket.Active)
                    return cacMarket;
            }

            if (IsLatinCountry(countryCode))
            {
                var latinMarket = GetLatinMarket(workoutApps);
                if (latinMarket != null && latinMarket.Active)
                    return latinMarket;
            }

            return GetWorkoutFallbackApplication();
        }

        public Application GetCentralAmericaMarket(IEnumerable<Application> apps)
        {
            var cacMarket = apps.FirstOrDefault(a => a.SpotifyRegionCode.Equals("ca&c", StringComparison.InvariantCultureIgnoreCase));
            return cacMarket;
        }

        public Application GetLatinMarket(IEnumerable<Application> apps)
        {
            var latinMarket = apps.FirstOrDefault(a => a.SpotifyRegionCode.Equals("latin", StringComparison.InvariantCultureIgnoreCase));
            return latinMarket;
        }


        public bool IsLatinCountry(string countryCode)
        {
            var latinCountryCodes = GetLatinCountryCodes();

            return latinCountryCodes.Contains(countryCode, StringComparer.InvariantCultureIgnoreCase);
        }

        static readonly IList<string> LatinCountryCodes = new[]
        {
            "ar", //Argentina - ar
            "bo", //Bolivia - bo
            "cl", //Chile - cl
            "cr", //Costa Rica - cr
            "co", //Columbia - co
            "ec", //Ecuador - ec
            "sv", //El Salvador - sv
            "gt", //Guatemala - gt
            "hn", //Honduras - hn
            "mx", //Mexico - mx
            "ni", //Nicaragua - ni
            "pa", //Panamá - pa
            "py", //Paraguay - py
            "pe", //Perú - pe
            "do", //República Dominicana - do
            "uy", //Uruguay - uy
        };

        public IList<string> GetLatinCountryCodes()
        {
            return LatinCountryCodes;
        }


        public Application SaveApplication(Application app)
        {
            if (app.ID == default(int))
            {
                app = _applicationFactory.InsertApplication(app);
            }
            else
            {
                _applicationFactory.UpdateApplication(app);
            }
            
            ClearApplicationsCache();
            _lastModifiedManager.SetLastModifyDate(app, EntityType.Applications);
            _lastModifiedManager.SetLastModifyDate(null, EntityType.Applications);

            return app;
        }

        public void DeleteApplication(Application app)
        {
            _lastModifiedManager.SetLastModifyDate(app, EntityType.Applications);
            _lastModifiedManager.SetLastModifyDate(null, EntityType.Applications);

            _applicationFactory.RemoveApplication(app);

            ClearApplicationsCache();
        }

        private List<string> GetCompoundApplicationMarkets(Application app)
        {
            var cacheKey = $"{ApplicationRegionsCacheKey}:{app.ID}";
            var markets = _distributedCacheHandler.Get(cacheKey) as List<string>;

            if (markets == null)
            {
                markets = _applicationFactory.GetApplicationMarkets(app);
                _distributedCacheHandler.Put(cacheKey, markets);
            }
            return markets;
        }

        private List<string> GetApplicationRegions(Application app)
        {
            var regionsForApplication = GetCompoundApplicationMarkets(app);

            if (regionsForApplication == null || !regionsForApplication.Any())
            {
                regionsForApplication = new List<string>() { app.SpotifyRegionCode };
            }

            return regionsForApplication;
        }

        public List<string> GetApplicationRegions(string spotifyCountryCode)
        {
            List<string> applicationRegions = new List<string>();
            var app = GetApplicationByCountry(spotifyCountryCode, fallback: false, onlyActive: false);
            if (app != null)
            {
                applicationRegions = GetApplicationRegions(app);
            }
            else
            {
                applicationRegions.Add(spotifyCountryCode);
            }

            return applicationRegions;
        }
        
    }
}