using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using System.Web.Mvc;
using NHibernate;
using NHibernate.Linq;
using Sleis.Models;
using Sleis.Infrastructure;
using Sleis.Utility;
using System.Collections;
using System.Text;
using log4net;
using Sleis.Data;
using System.Reflection;
using System.Threading.Tasks;
using System.Linq.Expressions;


namespace Sleis.Utility
{
    public static class LookupUtility
    {
        private static readonly ILog Log = LogManager.GetLogger(typeof(LookupUtility));
        private static readonly TimeSpan CacheDuration;
        private static readonly IPropertyPlaceholder Properties;
        

        static LookupUtility()
        {
            CacheDuration = SpringServiceProvider.GetService<TimeSpan>("lokupCacheDuration");
            Properties = SpringServiceProvider.GetService<IPropertyPlaceholder>("deploymentVars");  
            
        }       
        public static void Init()
        {
            IPropertyPlaceholder props = Properties;
            bool precacheLookups = false;

            //TODO: Attempting fix here.  Seems as if cache scheduler is getting here at times before this class is instantiated. 
            if(props == null)
                props = SpringServiceProvider.GetService<IPropertyPlaceholder>("deploymentVars");

            Boolean.TryParse(props.Get("lookup.cache"), out precacheLookups);
            if (precacheLookups)           
            {
                Task[] tasks = new Task[23]
                {
                    Task.Factory.StartNew(() => Get<EpaControlDeviceStatus>()),
                    Task.Factory.StartNew(() => Get<EpaEmissionUnitStatus>()),
                    Task.Factory.StartNew(() => Get<EpaEmissionUnitType>()),
                    Task.Factory.StartNew(() => Get<EpaFacilityCategory>()),
                    Task.Factory.StartNew(() => Get<EpaFacilityCollectionMethod>()),
                    Task.Factory.StartNew(() => Get<EpaFacilityGeodeticRefSystem>()),
                    Task.Factory.StartNew(() => Get<EpaFacilityGeoReferencePoint>()),
                    Task.Factory.StartNew(() => Get<EpaFacilityNaics>()),
                    Task.Factory.StartNew(() => Get<EpaFacilityStatus>()),
                    Task.Factory.StartNew(() => Get<EpaPollutant>()),
                    Task.Factory.StartNew(() => Get<EpaProcessEmissionCalculationMaterialType>()),
                    Task.Factory.StartNew(() => Get<EpaProcessEmissionCalculationParameterType>()),
                    Task.Factory.StartNew(() => Get<EpaProcessEmissionCalculationUom>()),
                    Task.Factory.StartNew(() => Get<EpaRegulationProgram>()),
                    Task.Factory.StartNew(() => Get<EpaReleasePointCategory>()),
                    Task.Factory.StartNew(() => Get<EpaReleasePointGasFlowRate>()),
                    Task.Factory.StartNew(() => Get<EpaReleasePointGasVel>()),
                    Task.Factory.StartNew(() => Get<EpaReleasePointStatus>()),
                    Task.Factory.StartNew(() => Get<EpaReleasePointType>()),
                    Task.Factory.StartNew(() => Get<EpaReleasePointUom>()),
                    Task.Factory.StartNew(() => Get<EpaUnitDesignUom>()),
                    Task.Factory.StartNew(() => Get<EpaUnitProcessClass>()),
                    Task.Factory.StartNew(() => Get<EpaEmissionCalculationMethod>()),
                };
            }
        }

        public static string[] Reload()
        {
            return CacheUtility.Clear();
        }

        public static List<SimpleLookupItem> Reload<T>() where T : EpaBaseObject
        {
            string typeName = typeof(T).Name;
            CacheUtility.Remove(typeName);
            return Get<T>();
        }

        public static List<SimpleLookupItem> Get<T>() where T : EpaBaseObject
        {
            string typeName = typeof(T).Name;
            List<SimpleLookupItem> list = CacheUtility.Get<List<SimpleLookupItem>>(typeName);

            if (list == null || list.Count < 1)
            {
                using (ISession session = SessionFactoryProvider.SessionFactory.OpenSession())
                {
                    try
                    {
                        Log.InfoFormat("{0} was not in cache. Loading...", typeName);
                        list = (from d in session.Query<T>()
                                orderby d.Description
                                select new SimpleLookupItem(d)).ToList();
                    }
                    catch (QueryException)
                    {
                        Log.InfoFormat("{0} does not contain descrption field. Trying query again and odering by code...", typeName);
                        list = (from d in session.Query<T>()
                                orderby d.Code
                                select new SimpleLookupItem(d)).ToList();
                    }
                }
                CacheUtility.Add(typeName, list, CacheDuration, false);
            }

            return list; //(d.Epa == null) ? 0 : d.Epa.Year
        }
        public static List<SimpleLookupItem> Get<T>(Expression<Func<T, bool>> predicate) where T :  EpaBaseObject, new()
        {
            string typeName = typeof(T).Name;            
            List<SimpleLookupItem> list = CacheUtility.Get<List<SimpleLookupItem>>(typeName);
            
            //this is causing issues do to caching as SimpleLookupItem.  We can't filter predicate on list since T is EpaBaseObject
            //would be best to re-do caching strategy with simplelookupItems...for now, will just query DB
            //if(list==null || list.Count<1)
            //{
                using (ISession session = SessionFactoryProvider.SessionFactory.OpenSession())
                {
                    try
                    {
                        Log.InfoFormat("{0} was not in cache. Loading...", typeName);
                        list = session.Query<T>().Where(predicate).OrderBy(d=>d.Description).Select(x=>new SimpleLookupItem(x)).ToList();
                                
                    }
                    catch (QueryException)
                    {
                        Log.InfoFormat("{0} does not contain descrption field. Trying query again and odering by code...", typeName);
                        list = session.Query<T>().Where(predicate).OrderBy(d => d.Code).Select(x => new SimpleLookupItem(x)).ToList();
                    }
                }
                CacheUtility.Add(typeName, list, CacheDuration, false);
            //}           
            return list; //(d.Epa == null) ? 0 : d.Epa.Year
        }

        public static SimpleLookupItem Get<T>(string code) where T : EpaBaseObject
        {
            string typeName = typeof(T).Name;
            SimpleLookupItem result = new SimpleLookupItem();
            List<SimpleLookupItem> list = CacheUtility.Get<List<SimpleLookupItem>>(typeName);
            if (list != null && list.Count > 0)
            {
                result = list.SingleOrDefault(x => x.Code == code);
            }
            if (result == null || String.IsNullOrWhiteSpace(result.Code))
            {
                return GetNotFromCache<T>(code);
            }
            return result;
        }       
        //will be removed later
        public static SimpleLookupItem GetNotFromCache<T>(string code) where T : EpaBaseObject
        {
            using(ISession session = SessionFactoryProvider.SessionFactory.OpenSession())
            {
            return (from d in session.Query<T>()
                    where d.Code == code
                   orderby d.Description
                    select new SimpleLookupItem(d)).FirstOrDefault();
            }

        }

        public static List<SimpleLookupItem> Get<T>(int year) where T : EpaBaseObject
        {
            return Get<T>().Where(x => x.Year == 0 || x.Year >= year).ToList();
        }

        //help create the dropdown list
        public static List<SimpleLookupItem> Get<T>(string code, int year) where T : EpaBaseObject
        {
            //if master inventory, make sure we default year to today's date.  
            if (year <= 0)
            {
                year = DateTime.Now.Year;
            }
            List<SimpleLookupItem> list = Get<T>().Where(x => x.Year == 0 || x.Year >= year).ToList();
            if(list.Find(x=>x.Code == code)==null)
            {
                SimpleLookupItem item = Get<T>(code);
                if(item!=null)
                {
                    list.Add(item);
                }
            }
            return list;
        }

        public static List<SimpleLookupItem> GetLike(string type, string code, int maxMatchSize, int year = 0)
        {
            List<SimpleLookupItem> list = CacheUtility.Get<List<SimpleLookupItem>>(type);

            if (list == null || list.Count < 1)
            {
                //a little bit of reflection to get the list loaded and into cache
                Type lookupUtility = typeof(LookupUtility);
                MethodInfo mi = lookupUtility.GetMethod("Get", new Type[]{});
                // Assign the Lookup type to the type parameter of the Get Method on this class.
                Type lookupType = Type.GetType(String.Format("Sleis.Models.{0}", type), true, true);
                MethodInfo getMethod = mi.MakeGenericMethod(lookupType);
                list = (List<SimpleLookupItem>)getMethod.Invoke(null, null);                 
            }
            //if master inventory, make sure we default year to today's date.  
            if (year <= 0)
            {
                year = DateTime.Now.Year;
            }
            if (list != null)
            {
                IEnumerable<SimpleLookupItem> resultList = null;
                if (year > 0)
                {
                    //Keep the year as not nullable to not have to check for null
                    resultList = list.Where(x => x.Contains(code) && (x.Year == 0 || x.Year >= year));
                }
                else
                {
                    resultList = list.Where(x => x.Contains(code));
                }

                list = resultList.Take(maxMatchSize).ToList();
            }
            else
            {
                Log.ErrorFormat("Lookup type not mapped: {0}", type);
                list = new List<SimpleLookupItem>();
            }
            return list;
        }
        public static List<SimpleLookupItem> GetEmissionCalculationMethods()
        {
            string typeName = typeof(EpaEmissionCalculationMethod).Name;
            return LookupUtility.Get<EpaEmissionCalculationMethod>();
            /*if (list == null || list.Count < 1)
            {
                using (ISession session = SessionFactoryProvider.SessionFactory.OpenSession())
                {
                    list = (from d in session.Query<EpaEmissionCalculationMethod>()
                              select (d)).ToList<SimpleLookupItem>();
                }
                CacheUtility.Add(typeName, list, CacheDuration, false);
            }
            return list.ToList<EpaEmissionCalculationMethod>();
             * */
        }
    }
}