using System;
using System.Collections.Generic;
using System.Linq;
using System.Web.Mvc;
using NHibernate;
using NHibernate.Linq;
using Sleis.Models;
using Sleis.Infrastructure;
using log4net;
using Sleis.Utility;
using System.Linq.Expressions;
using Spring.Data.Generic;
using Spring.Data.Common;

namespace Sleis.Data
{
    public enum DbProviderType { Oracle, MsSql }
    public abstract class BaseData : AdoDaoSupport, IBaseData
    {
        internal static ILog Log;

       
        private ISessionFactory _sessionFactory;
        private ISession _currentSession;
        public IPropertyPlaceholder Properties { get; set; }

        /// <summary>
        /// Session factory for sub-classes.
        /// </summary>
        public ISessionFactory SessionFactory
        {
            protected get { return _sessionFactory; }
            set { _sessionFactory = value; }
        }

        /// <summary>
        /// Get's the current active session. Will retrieve session as managed by the 
        /// Open Session In View module if enabled.
        /// </summary>
        /*protected ISession CurrentSession
        {
            get { return _sessionFactory.GetCurrentSession(); }
        }
        */
        public BaseData()
        {
            Log = LogManager.GetLogger(this.GetType());
            //if (AdoTemplate == null) { throw new NullReferenceException("AdoTemplate not configured"); }            
        }
        public DbProviderType DbProviderType
        {            
            get
            {
                if(DbProvider.DbMetadata.ProductName.Contains("Oracle"))
                {
                    return DbProviderType.Oracle;
                }
                return DbProviderType.MsSql;
            }
        }
        public ISession GetSession()
        {
            Log.Debug("Getting Session...");  
            //Injected via spring
            //return SessionFactory.OpenSession();
            if (SessionFactory != null)
            {
                return SessionFactory.OpenSession();               
            }
            throw new ArgumentNullException("Session is null.");            
        }
        
        
        public virtual void Init()
        {
            ArgumentValidationUtility.ThrowOnNull(Properties, "Properties");
        }

        #region AdoTemplate Param Helper Functions
        public object GetDateTimeDbParam(DateTime val)
        {
            return (val == DateTime.MinValue) ? (object)DBNull.Value : val;
        }

        public string CreateParameterName(string name)
        {
            return AdoTemplate.DbProvider.CreateParameterName(name);            
        }
        public object GetOutParamValue(string name, IDbParameters args)
        {
            //for whatever reason, MS Based SQL params have to be accessed by @Name, while Oracle just uses non prefixed name....not sure about other DBs yet.
            if (DbProviderType != DbProviderType.Oracle)
                return args[CreateParameterName(name)].Value;
            return args[name].Value;
        }
        public object GetNullableDbParam(object val)
        {
            return (val == null) ? (object)DBNull.Value : val;
        }        
        public object GetNullableDbStringParam(string val)
        {
            return (String.IsNullOrEmpty(val) || String.IsNullOrEmpty(val.Trim()) || val.Trim().ToLower().Equals("null")) ? (object)DBNull.Value : val;
        }
      
        #endregion



        public override string ToString()
        {
            return Utility.ReflectionUtility.GetPublicPropertiesString(this);
        }
        public virtual IQueryable<T> Query<T>() where T : BaseIdentityModel
        {
            using (ISession session = GetSession())
            {
                return session.Query<T>();
            }
        }
        public int Count<Obj>(Expression<Func<Obj, bool>> predicate) where Obj : Sleis.Models.BaseIdentityModel
        {
            using (ISession session = GetSession())
            {
                return session.Query<Obj>().Count(predicate);
            }
        }
        public IList<Obj> GetAll<Obj>()
        {
            using (ISession session = GetSession())
            {
                return (from d in session.Query<Obj>()
                        select d).ToList();
            }
        }
        public Obj GetSingle<Obj>(ISession session, Expression<Func<Obj, bool>> predicate) where Obj : BaseIdentityModel
        {           
            return session.Query<Obj>().SingleOrDefault(predicate);            
        }
        public Obj GetSingle<Obj>(Expression<Func<Obj, bool>> predicate) where Obj : BaseIdentityModel
        {
            using (ISession session = GetSession())
            {
                return session.Query<Obj>().SingleOrDefault(predicate);
            }
        }
        public Obj GetSingle<Obj>(Expression<Func<Obj, bool>> predicate, Expression<Func<Obj, Obj>> selectPredicate) where Obj : BaseIdentityModel
        {
            using (ISession session = GetSession())
            {
                return session.Query<Obj>().Select<Obj, Obj>(selectPredicate).SingleOrDefault(predicate);
            }
        }
        public IList<Obj> Get<Obj>(Expression<Func<Obj, bool>> predicate, Expression<Func<Obj, Obj>> selectPredicate) where Obj : BaseIdentityModel
        {
            using (ISession session = GetSession())
            {
                return session.Query<Obj>().Where(predicate).Select<Obj, Obj>(selectPredicate).ToList<Obj>();
            }
        }   
        public IList<Obj> Get<Obj>(Expression<Func<Obj, bool>> predicate) where Obj : BaseIdentityModel
        {
            using (ISession session = GetSession())
            {
                return session.Query<Obj>().Where(predicate).ToList();
            }
        }
        public IQueryable<Obj> Get<Obj>(Expression<Func<Obj, bool>> predicate, ISession session) where Obj : BaseIdentityModel
        {
            return session.Query<Obj>().Where(predicate);            
        }
        public IList<Obj> Get<Obj>(Expression<Func<Obj, bool>> predicate, Action<Orderable<Obj>> order, int pageNum, int pageSize) where Obj : BaseIdentityModel
        {
            if (pageSize < 1) { pageSize = GetDefaultPageSize(); } 
            using (ISession session = GetSession())
            {
                return Fetch<Obj>(predicate, order, session)
                    .Skip(pageNum * pageSize)
                    .Take(pageSize)                    
                    .ToList();
            }
        }
        public virtual IQueryable<T> Fetch<T>(Expression<Func<T, bool>> predicate, Action<Orderable<T>> order, ISession session) where T: BaseIdentityModel
        {
            var orderable = new Orderable<T>(Get<T>(predicate, session));
            order(orderable);
            return orderable.Queryable;            
        }
        public Obj Create<Obj>(Obj obj) where Obj : BaseIdentityModel
        {
            using (ISession session = GetSession())
            {
                session.SaveOrUpdate(obj);
                return obj;
            }
        }
        public Obj GetById<Obj>(int id) where Obj : BaseIdentityModel
        {
            using (ISession session = GetSession())
            {
                return session.Query<Obj>().SingleOrDefault<Obj>(o => o.Id == id);
            }
        }

        public bool Exists<Obj>(Expression<Func<Obj, bool>> predicate, ISession session) where Obj : IIdentifiable
        {
            return session.Query<Obj>().Any<Obj>(predicate);
        }

        public Obj Create<Obj>(Obj obj, ISession session) where Obj : BaseIdentityModel
        {
            //session.Evict(obj);
            session.Save(obj);
            return obj;
        }
        public void Update<Obj>(Obj obj) where Obj : BaseIdentityModel
        {
            using (ISession session = GetSession())
            {
                using (var txn = session.BeginTransaction())
                {
                    session.Update(obj);
                    txn.Commit();
                }
            }

        }
        public void Update<Obj>(Obj obj, ISession session) where Obj : BaseIdentityModel
        {
            session.Update(obj);
        }
        public void SaveOrUpdate<Obj>(Obj obj, ISession session) where Obj : BaseIdentityModel
        {
            session.SaveOrUpdate(obj);           
        }
        public void SaveOrUpdate<Obj>(Obj obj) where Obj : BaseIdentityModel
        {
            using (ISession session = GetSession())
            {
                session.SaveOrUpdate(obj);
                session.Flush();
            }
        }
        public void Delete<Obj>(int id) where Obj : BaseIdentityModel
        {
            using (ISession session = GetSession())
            {
                using (var txn = session.BeginTransaction())
                {
                    session.Delete(GetById<Obj>(id));
                    txn.Commit();
                }
            }
        }
        public void Delete<Obj>(int id, ISession session) where Obj : BaseIdentityModel
        {
            session.Delete(GetById<Obj>(id));
        }
        public void Delete<Obj>(Obj obj, ISession session) where Obj : BaseIdentityModel
        {
            session.Delete(obj);
        }
        private int GetDefaultPageSize()
        {
            int size = 0;
            Int32.TryParse(Properties.Get(Constants.DefaultPageSize), out size);
            return size;
        }

    }

    public abstract class BaseData<T> : BaseData, Sleis.Data.IBaseData<T>, IBaseData where T : BaseIdentityModel
    {
        public IList<T> GetAll()
        {
            using (ISession session = GetSession())
            {
                return (from d in session.Query<T>()
                       select d).ToList();
            }
        }        
        
		public T GetSingle(Expression<Func<T, bool>> predicate)
		{
            using (ISession session = GetSession())
            {
                return session.Query<T>().SingleOrDefault(predicate);
            }
		}
       

        public IList<T> Get(Expression<Func<T, bool>> predicate)
        {
            using (ISession session = GetSession())
            {
                return session.Query<T>().Where(predicate).ToList();
            }
        }
       

        public T GetById(int id) 
        {
            using (ISession session = GetSession())
            {
                var entities = from d in session.Query<T>()
                               where d.Id == id
                               select d;
                return entities.FirstOrDefault<T>();
            }
        }
        

        public T Create(T obj)
        {
            using (ISession session = GetSession())
            {
                session.SaveOrUpdate(obj);
                return obj;
            }
        }
        
        public T Create(T obj, ISession session)
        {
            session.SaveOrUpdate(obj);
            return obj;
        }
        
        public void Update(T obj)
        {
            using (ISession session = GetSession())
            {
                using (var txn = session.BeginTransaction())
                {
                    session.Update(obj);
                    txn.Commit();
                }
            }

        }
        public void Update(T obj, ISession session)
        {
            session.Update(obj);
        }
        public void SaveOrUpdate(T obj, ISession session)
        {
            session.SaveOrUpdate(obj);
        }
        public void SaveOrUpdate(T obj)
        {
            using (ISession session = GetSession())
            {
                session.SaveOrUpdate(obj);
                session.Flush();
            }
        }
        public void Delete(int id)
        {
            using (ISession session = GetSession())
            {
                using (var txn = session.BeginTransaction())
                {
                    session.Delete(GetById(id));
                    txn.Commit();
                }
            }
        }       
        public void Delete(int id, ISession session)
        {
            session.Delete(GetById(id)); 
        }
        public void Delete(T obj, ISession session)
        {
            session.Delete(obj);
        }
    }
}