using Gestor.Infrastructure.Configuration;
using Gestor.Infrastructure.Repository.Generic;
using NHibernate;
using NHibernate.Linq;
using System;
using System.Data;
using System.Linq;
using System.Runtime.CompilerServices;
using System.Threading;

namespace Gestor.Infrastructure.UnitOfWork.Generic
{
	public class GenericUnitOfWork : IDisposable, IGenericUnitOfWork
	{
		public bool HasSession
		{
			get
			{
				return this.Session != null;
			}
		}

		public ISession Session
		{
			get;
		}

		private ITransaction Transaction
		{
			get;
		}

		protected GenericUnitOfWork(string connectionString, bool withTransaction = true)
		{
			bool state;
			ITransaction transaction;
			int num = 0;
			while (true)
			{
				if (num < 3)
				{
					try
					{
						this.Session = SessionFactory.OpenSession(connectionString);
						if (withTransaction)
						{
							ISession session = this.Session;
							if (session != null)
							{
								transaction = session.BeginTransaction(IsolationLevel.ReadUncommitted);
							}
							else
							{
								transaction = null;
							}
							this.Transaction = transaction;
						}
						else if (this.Session != null)
						{
							ISession session1 = this.Session;
							if (session1 != null)
							{
								state = session1.Connection.State != ConnectionState.Open;
							}
							else
							{
								state = true;
							}
							if (state)
							{
								this.Session.Connection.Open();
							}
						}
						break;
					}
					catch (ArgumentNullException argumentNullException)
					{
						throw;
					}
					catch (Exception exception)
					{
						if (SessionFactory.Retry)
						{
							Thread.Sleep(1000);
						}
						else
						{
							this.Session = null;
							break;
						}
					}
					num++;
				}
				else
				{
					this.Session = null;
					break;
				}
			}
		}

		public void Commit()
		{
			if (this.Transaction != null && this.Transaction.IsActive)
			{
				this.Transaction.Commit();
			}
		}

		public void Dispose()
		{
			ISession session = this.Session;
			if (session != null)
			{
				session.Dispose();
			}
			else
			{
			}
			ITransaction transaction = this.Transaction;
			if (transaction == null)
			{
				return;
			}
			transaction.Dispose();
		}

		public IQueryable<TEntity> Query<TEntity>()
		where TEntity : class
		{
			return this.Session.Query<TEntity>();
		}

		public IGenericRepository<TEntity> Repository<TEntity>()
		where TEntity : class
		{
			return new GenericRepository<TEntity>(this.Session);
		}

		public void Rollback()
		{
			if (this.Transaction != null && this.Transaction.IsActive)
			{
				this.Transaction.Rollback();
			}
		}
	}
}