using FluentNHibernate.Cfg;
using FluentNHibernate.Cfg.Db;
using Gestor.Infrastructure.Entities.Seguros;
using NHibernate;
using NHibernate.Cfg;
using NHibernate.Connection;
using NHibernate.Impl;
using NHibernate.Mapping;
using NHibernate.Tool.hbm2ddl;
using System;
using System.ComponentModel;
using System.Data.SqlClient;
using System.Linq;
using System.Runtime.CompilerServices;

namespace Gestor.Infrastructure.Configuration
{
	public class SessionFactory
	{
		private static ISessionFactory _sessionFactory;

		private static string ConnectionString
		{
			get;
			set;
		}

		public static bool Retry
		{
			get;
			set;
		}

		private static ISessionFactory Session
		{
			get
			{
				object connection;
				SessionFactoryImpl sessionFactoryImpl = SessionFactory._sessionFactory as SessionFactoryImpl;
				if (sessionFactoryImpl != null)
				{
					connection = sessionFactoryImpl.ConnectionProvider.GetConnection();
				}
				else
				{
					connection = null;
				}
				SqlConnection sqlConnection = connection as SqlConnection;
				SqlConnection sqlConnection1 = new SqlConnection(SessionFactory.ConnectionString);
				if (sqlConnection == null || sqlConnection.Database != sqlConnection1.Database)
				{
					SessionFactory.Initialize();
				}
				sqlConnection1.Dispose();
				return SessionFactory._sessionFactory;
			}
		}

		public SessionFactory()
		{
		}

		private static NHibernate.Cfg.Configuration BuildConfiguration()
		{
			MsSqlConfiguration msSqlConfiguration = MsSqlConfiguration.MsSql2012.ConnectionString(SessionFactory.ConnectionString).ShowSql();
			return Fluently.Configure().Database(msSqlConfiguration).Mappings((MappingConfiguration m) => m.FluentMappings.AddFromAssemblyOf<ClienteMap>()).ExposeConfiguration((NHibernate.Cfg.Configuration cfg) => (new SchemaUpdate(cfg)).Execute(false, true)).BuildConfiguration();
		}

		private static void BuildSessionFactory(bool withDelete = false)
		{
			SessionFactory._sessionFactory = SessionFactory.ConfigurationFile(withDelete).BuildSessionFactory();
		}

		private static FluentConfiguration ConfigurationFile(bool withDelete)
		{
			NHibernate.Cfg.Configuration configuration;
			ConfigurationFileCache configurationFileCache = new ConfigurationFileCache(SessionFactory.ConnectionString);
			if (withDelete)
			{
				configurationFileCache.DeleteCacheFile();
			}
			NHibernate.Cfg.Configuration configuration1 = configurationFileCache.LoadConfigurationFromFile();
			configuration1 = SessionFactory.FixConfiguration(configuration1);
			if (configuration1 != null)
			{
				configuration = configuration1;
				configuration.SetProperty("connection.connection_string", SessionFactory.ConnectionString);
			}
			else
			{
				configuration = SessionFactory.BuildConfiguration();
				configurationFileCache.SaveConfigurationToFile(configuration);
			}
			return Fluently.Configure(configuration);
		}

		private static NHibernate.Cfg.Configuration FixConfiguration(NHibernate.Cfg.Configuration cachedConfiguration)
		{
			NHibernate.Cfg.Configuration configuration;
			if (cachedConfiguration == null)
			{
				return cachedConfiguration;
			}
			Type type = typeof(ClienteDb);
			if (cachedConfiguration.ClassMappings.Any<PersistentClass>((PersistentClass x) => x.EntityName == type.FullName))
			{
				configuration = cachedConfiguration;
			}
			else
			{
				configuration = null;
			}
			cachedConfiguration = configuration;
			return cachedConfiguration;
		}

		public static void Initialize()
		{
			if (SessionFactory.ConnectionString == null)
			{
				throw new ArgumentNullException();
			}
			try
			{
				SessionFactory.BuildSessionFactory(false);
			}
			catch (Exception exception)
			{
				SessionFactory.BuildSessionFactory(true);
			}
		}

		public static ISession OpenSession(string connectionString)
		{
			SessionFactory.ConnectionString = connectionString;
			ISessionFactory session = SessionFactory.Session;
			if (session != null)
			{
				return session.OpenSession();
			}
			return null;
		}
	}
}