using System.Collections;
using NHibernate;
using NHibernate.SqlCommand;
using NHibernate.Type;
using NSubstitute;
using NUnit.Framework;
using Sentric.BackOffice.Infrastructure.Data.Orm.NHibernate;
using Should;

[TestFixture]
public class CompositeInterceptorTests
{
    [Test]
    public void Should_call_after_transaction_begin()
    {
        var interceptor1 = Substitute.For<IInterceptor>();
        var interceptor2 = Substitute.For<IInterceptor>();
        var transaction = Substitute.For<ITransaction>();

        var interceptor = new CompositeInterceptor(new[] { interceptor1, interceptor2 });
        interceptor.AfterTransactionBegin(transaction);

        interceptor1.Received().AfterTransactionBegin(transaction);
        interceptor2.Received().AfterTransactionBegin(transaction);
    }

    [Test]
    public void Should_call_after_transaction_completion()
    {
        var interceptor1 = Substitute.For<IInterceptor>();
        var interceptor2 = Substitute.For<IInterceptor>();
        var transaction = Substitute.For<ITransaction>();

        var interceptor = new CompositeInterceptor(new[] { interceptor1, interceptor2 });
        interceptor.AfterTransactionCompletion(transaction);

        interceptor1.Received().AfterTransactionCompletion(transaction);
        interceptor2.Received().AfterTransactionCompletion(transaction);
    }

    [Test]
    public void Should_call_before_transaction_completion()
    {
        var interceptor1 = Substitute.For<IInterceptor>();
        var interceptor2 = Substitute.For<IInterceptor>();
        var transaction = Substitute.For<ITransaction>();

        var interceptor = new CompositeInterceptor(new[] { interceptor1, interceptor2 });
        interceptor.BeforeTransactionCompletion(transaction);

        interceptor1.Received().BeforeTransactionCompletion(transaction);
        interceptor2.Received().BeforeTransactionCompletion(transaction);
    }

    [Test]
    public void Should_call_finddirty_on_all_interceptors()
    {
        var interceptor1 = Substitute.For<IInterceptor>();
        var interceptor2 = Substitute.For<IInterceptor>();
        var interceptor3 = Substitute.For<IInterceptor>();

        var entity = new object();
        var id = new object();
        var currentState = new object[] { 0 };
        var previousState = new object[] { 0 };
        var propertyNames = new[] { "Id" };
        var types = new[] { Substitute.For<IType>() };

        interceptor1.FindDirty(entity, id, currentState, previousState, propertyNames, types).Returns(new [] { 1, 2 });
        interceptor2.FindDirty(entity, id, currentState, previousState, propertyNames, types).Returns(new[] { 2, 3 });
        interceptor3.FindDirty(entity, id, currentState, previousState, propertyNames, types).Returns((int[])null);

        var interceptor = new CompositeInterceptor(new[] { interceptor1, interceptor2 });
        interceptor.FindDirty(entity, id, currentState, previousState, propertyNames, types)
            .ShouldEqual(new [] { 1, 2, 3 });
    }

    [Test]
    public void Should_return_null_when_finddirty_returns_no_results()
    {
        var interceptor1 = Substitute.For<IInterceptor>();
        var interceptor2 = Substitute.For<IInterceptor>();

        var entity = new object();
        var id = new object();
        var currentState = new object[] { 0 };
        var previousState = new object[] { 0 };
        var propertyNames = new[] { "Id" };
        var types = new[] { Substitute.For<IType>() };

        interceptor1.FindDirty(entity, id, currentState, previousState, propertyNames, types).Returns((int[])null);
        interceptor2.FindDirty(entity, id, currentState, previousState, propertyNames, types).Returns(new int[] { });

        var interceptor = new CompositeInterceptor(new[] { interceptor1, interceptor2 });

        interceptor.FindDirty(entity, id, currentState, 
            previousState, propertyNames, types).ShouldBeNull();
    }
    
    [Test]
    public void Should_call_getentity_first_interceptor_valid()
    {
        var interceptor1 = Substitute.For<IInterceptor>();
        var interceptor2 = Substitute.For<IInterceptor>();

        var entityName = string.Empty;
        var id = new object();

        interceptor1.GetEntity(entityName, id).Returns(new object());

        var interceptor = new CompositeInterceptor(new[] { interceptor1, interceptor2 });
        interceptor.GetEntity(entityName, id);

        interceptor1.Received().GetEntity(entityName, id);
        interceptor2.DidNotReceive().GetEntity(entityName, id);
    }

    [Test]
    public void Should_call_getentity_second_interceptor_valid()
    {
        var interceptor1 = Substitute.For<IInterceptor>();
        var interceptor2 = Substitute.For<IInterceptor>();

        var entityName = string.Empty;
        var id = new object();

        interceptor2.GetEntity(entityName, id).Returns(new object());

        var interceptor = new CompositeInterceptor(new[] { interceptor1, interceptor2 });
        interceptor.GetEntity(entityName, id);

        interceptor1.Received().GetEntity(entityName, id);
        interceptor2.Received().GetEntity(entityName, id);
    }

    [Test]
    public void Should_call_get_entity_name_first_interceptor_valid()
    {
        var interceptor1 = Substitute.For<IInterceptor>();
        var interceptor2 = Substitute.For<IInterceptor>();

        var entity = new object();

        interceptor1.GetEntityName(entity).Returns(string.Empty);

        var interceptor = new CompositeInterceptor(new[] { interceptor1, interceptor2 });
        interceptor.GetEntityName(entity);

        interceptor1.Received().GetEntityName(entity);
        interceptor2.DidNotReceive().GetEntityName(entity);
    }

    [Test]
    public void Should_call_get_entity_name_second_interceptor_valid()
    {
        var interceptor1 = Substitute.For<IInterceptor>();
        var interceptor2 = Substitute.For<IInterceptor>();

        var entity = new object();

        interceptor1.GetEntityName(entity).Returns((string)null);
        interceptor2.GetEntityName(entity).Returns(string.Empty);

        var interceptor = new CompositeInterceptor(new[] { interceptor1, interceptor2 });
        interceptor.GetEntityName(entity);

        interceptor1.Received().GetEntityName(entity);
        interceptor2.Received().GetEntityName(entity);
    }

    [Test]
    public void Should_call_instantiate_first_interceptor_valid()
    {
        var interceptor1 = Substitute.For<IInterceptor>();
        var interceptor2 = Substitute.For<IInterceptor>();

        var entityName = string.Empty;
        const EntityMode entityMode = EntityMode.Map;
        var id = new object();

        interceptor1.Instantiate(entityName, entityMode, id).Returns(new object());

        var interceptor = new CompositeInterceptor(new[] { interceptor1, interceptor2 });
        interceptor.Instantiate(entityName, entityMode, id);

        interceptor1.Received().Instantiate(entityName, entityMode, id);
        interceptor2.DidNotReceive().Instantiate(entityName, entityMode, id);
    }

    [Test]
    public void Should_call_instantiate_second_interceptor_valid()
    {
        var interceptor1 = Substitute.For<IInterceptor>();
        var interceptor2 = Substitute.For<IInterceptor>();

        var entityName = string.Empty;
        const EntityMode entityMode = EntityMode.Map;
        var id = new object();

        interceptor2.Instantiate(entityName, entityMode, id).Returns(new object());

        var interceptor = new CompositeInterceptor(new[] { interceptor1, interceptor2 });
        interceptor.Instantiate(entityName, entityMode, id);

        interceptor1.Received().Instantiate(entityName, entityMode, id);
        interceptor2.Received().Instantiate(entityName, entityMode, id);
    }

    [Test]
    public void Should_call_istransient_first_interceptor_valid()
    {
        var interceptor1 = Substitute.For<IInterceptor>();
        var interceptor2 = Substitute.For<IInterceptor>();

        var entity = new object();

        interceptor1.IsTransient(entity).Returns(true);

        var interceptor = new CompositeInterceptor(new[] { interceptor1, interceptor2 });
        interceptor.IsTransient(entity);

        interceptor1.Received().IsTransient(entity);
        interceptor2.DidNotReceive().IsTransient(entity);
    }

    [Test]
    public void Should_call_istransient_second_interceptor_valid()
    {
        var interceptor1 = Substitute.For<IInterceptor>();
        var interceptor2 = Substitute.For<IInterceptor>();

        var entity = new object();

        interceptor2.IsTransient(entity).Returns(true);

        var interceptor = new CompositeInterceptor(new[] { interceptor1, interceptor2 });
        interceptor.IsTransient(entity);

        interceptor1.Received().IsTransient(entity);
        interceptor2.Received().IsTransient(entity);
    }

    [Test]
    public void Should_call_oncollectionrecreate()
    {
        var interceptor1 = Substitute.For<IInterceptor>();
        var interceptor2 = Substitute.For<IInterceptor>();

        var collection = new object();
        var key = new object();

        var interceptor = new CompositeInterceptor(new[] { interceptor1, interceptor2 });
        interceptor.OnCollectionRecreate(collection, key);

        interceptor1.Received().OnCollectionRecreate(collection, key);
        interceptor2.Received().OnCollectionRecreate(collection, key);
    }

    [Test]
    public void Should_call_oncollectionremove()
    {
        var interceptor1 = Substitute.For<IInterceptor>();
        var interceptor2 = Substitute.For<IInterceptor>();

        var collection = new object();
        var key = new object();

        var interceptor = new CompositeInterceptor(new[] { interceptor1, interceptor2 });
        interceptor.OnCollectionRemove(collection, key);

        interceptor1.Received().OnCollectionRemove(collection, key);
        interceptor2.Received().OnCollectionRemove(collection, key);
    }

    [Test]
    public void Should_call_oncollectionupdate()
    {
        var interceptor1 = Substitute.For<IInterceptor>();
        var interceptor2 = Substitute.For<IInterceptor>();

        var collection = new object();
        var key = new object();

        var interceptor = new CompositeInterceptor(new[] { interceptor1, interceptor2 });
        interceptor.OnCollectionUpdate(collection, key);

        interceptor1.Received().OnCollectionUpdate(collection, key);
        interceptor2.Received().OnCollectionUpdate(collection, key);
    }

    [Test]
    public void Should_call_ondelete()
    {
        var interceptor1 = Substitute.For<IInterceptor>();
        var interceptor2 = Substitute.For<IInterceptor>();

        var entity = new object();
        var id = new object();
        var state = new object[] { 0 };
        var propertyNames = new[] { "Id" };
        var types = new[] { Substitute.For<IType>() };

        var interceptor = new CompositeInterceptor(new[] { interceptor1, interceptor2 });
        interceptor.OnDelete(entity, id, state, propertyNames, types);

        interceptor1.Received().OnDelete(entity, id, state, propertyNames, types);
        interceptor2.Received().OnDelete(entity, id, state, propertyNames, types);
    }

    [Test]
    public void Should_call_onflushdirty_false()
    {
        var interceptor1 = Substitute.For<IInterceptor>();
        var interceptor2 = Substitute.For<IInterceptor>();

        var entity = new object();
        var id = new object();
        var currentState = new object[] { 0 };
        var previousState = new object[] { 0 };
        var propertyNames = new[] { "Id" };
        var types = new[] { Substitute.For<IType>() };

        interceptor1.OnFlushDirty(entity, id, currentState, previousState, propertyNames, types).Returns(false);
        interceptor2.OnFlushDirty(entity, id, currentState, previousState, propertyNames, types).Returns(false);

        var interceptor = new CompositeInterceptor(new[] { interceptor1, interceptor2 });
        interceptor.OnFlushDirty(entity, id, currentState, previousState, propertyNames, types).ShouldBeFalse();

        interceptor1.Received().OnFlushDirty(entity, id, currentState, previousState, propertyNames, types);
        interceptor2.Received().OnFlushDirty(entity, id, currentState, previousState, propertyNames, types);
    }

    [Test]
    public void Should_call_onflushdirty_true()
    {
        var interceptor1 = Substitute.For<IInterceptor>();
        var interceptor2 = Substitute.For<IInterceptor>();

        var entity = new object();
        var id = new object();
        var currentState = new object[] { 0 };
        var previousState = new object[] { 0 };
        var propertyNames = new[] { "Id" };
        var types = new[] { Substitute.For<IType>() };

        interceptor1.OnFlushDirty(entity, id, currentState, previousState, propertyNames, types).Returns(false);
        interceptor2.OnFlushDirty(entity, id, currentState, previousState, propertyNames, types).Returns(true);

        var interceptor = new CompositeInterceptor(new[] { interceptor1, interceptor2 });
        interceptor.OnFlushDirty(entity, id, currentState, previousState, propertyNames, types).ShouldBeTrue();

        interceptor1.Received().OnFlushDirty(entity, id, currentState, previousState, propertyNames, types);
        interceptor2.Received().OnFlushDirty(entity, id, currentState, previousState, propertyNames, types);
    }

    [Test]
    public void Should_call_onload_false()
    {
        var interceptor1 = Substitute.For<IInterceptor>();
        var interceptor2 = Substitute.For<IInterceptor>();

        var entity = new object();
        var id = new object();
        var state = new object[] { 0 };
        var propertyNames = new[] { "Id" };
        var types = new[] { Substitute.For<IType>() };

        interceptor1.OnLoad(entity, id, state, propertyNames, types).Returns(false);
        interceptor2.OnLoad(entity, id, state, propertyNames, types).Returns(false);

        var interceptor = new CompositeInterceptor(new[] { interceptor1, interceptor2 });
        interceptor.OnLoad(entity, id, state, propertyNames, types).ShouldBeFalse();

        interceptor1.Received().OnLoad(entity, id, state, propertyNames, types);
        interceptor2.Received().OnLoad(entity, id, state, propertyNames, types);
    }

    [Test]
    public void Should_call_onload_true()
    {
        var interceptor1 = Substitute.For<IInterceptor>();
        var interceptor2 = Substitute.For<IInterceptor>();

        var entity = new object();
        var id = new object();
        var state = new object[] { 0 };
        var propertyNames = new[] { "Id" };
        var types = new[] { Substitute.For<IType>() };

        interceptor1.OnLoad(entity, id, state, propertyNames, types).Returns(false);
        interceptor2.OnLoad(entity, id, state, propertyNames, types).Returns(true);

        var interceptor = new CompositeInterceptor(new[] { interceptor1, interceptor2 });
        interceptor.OnLoad(entity, id, state, propertyNames, types).ShouldBeTrue();

        interceptor1.Received().OnLoad(entity, id, state, propertyNames, types);
        interceptor2.Received().OnLoad(entity, id, state, propertyNames, types);
    }

    [Test]
    public void Should_call_onpreparestatement()
    {
        var interceptor1 = Substitute.For<IInterceptor>();
        var interceptor2 = Substitute.For<IInterceptor>();

        var sql = new SqlString();
        var sql1 = SqlString.Parse("SELECT name FROM sys.tables");
        var sql2 = SqlString.Parse("SELECT name FROM sys.tables UNION SELECT name FROM sys.columns");

        interceptor1.OnPrepareStatement(sql).Returns(sql1);
        interceptor2.OnPrepareStatement(sql1).Returns(sql2);

        var interceptor = new CompositeInterceptor(new[] { interceptor1, interceptor2 });
        interceptor.OnPrepareStatement(sql).ShouldEqual(sql2);

        interceptor1.Received().OnPrepareStatement(sql);
        interceptor2.Received().OnPrepareStatement(sql1);
    }

    [Test]
    public void Should_call_onsave_false()
    {
        var interceptor1 = Substitute.For<IInterceptor>();
        var interceptor2 = Substitute.For<IInterceptor>();

        var entity = new object();
        var id = new object();
        var state = new object[] { 0 };
        var propertyNames = new[] { "Id" };
        var types = new[] { Substitute.For<IType>() };

        interceptor1.OnSave(entity, id, state, propertyNames, types).Returns(false);
        interceptor2.OnSave(entity, id, state, propertyNames, types).Returns(false);

        var interceptor = new CompositeInterceptor(new[] { interceptor1, interceptor2 });
        interceptor.OnSave(entity, id, state, propertyNames, types).ShouldBeFalse();

        interceptor1.Received().OnSave(entity, id, state, propertyNames, types);
        interceptor2.Received().OnSave(entity, id, state, propertyNames, types);
    }

    [Test]
    public void Should_call_onsave_true()
    {
        var interceptor1 = Substitute.For<IInterceptor>();
        var interceptor2 = Substitute.For<IInterceptor>();

        var entity = new object();
        var id = new object();
        var state = new object[] { 0 };
        var propertyNames = new[] { "Id" };
        var types = new[] { Substitute.For<IType>() };

        interceptor1.OnSave(entity, id, state, propertyNames, types).Returns(false);
        interceptor2.OnSave(entity, id, state, propertyNames, types).Returns(true);

        var interceptor = new CompositeInterceptor(new[] { interceptor1, interceptor2 });
        interceptor.OnSave(entity, id, state, propertyNames, types).ShouldBeTrue();

        interceptor1.Received().OnSave(entity, id, state, propertyNames, types);
        interceptor2.Received().OnSave(entity, id, state, propertyNames, types);
    }

    [Test]
    public void Should_call_postflush()
    {
        var interceptor1 = Substitute.For<IInterceptor>();
        var interceptor2 = Substitute.For<IInterceptor>();

        var entities = Substitute.For<ICollection>();

        var interceptor = new CompositeInterceptor(new[] { interceptor1, interceptor2 });
        interceptor.PostFlush(entities);

        interceptor1.Received().PostFlush(entities);
        interceptor2.Received().PostFlush(entities);
    }

    [Test]
    public void Should_call_preflush()
    {
        var interceptor1 = Substitute.For<IInterceptor>();
        var interceptor2 = Substitute.For<IInterceptor>();

        var entities = Substitute.For<ICollection>();

        var interceptor = new CompositeInterceptor(new[] { interceptor1, interceptor2 });
        interceptor.PreFlush(entities);

        interceptor1.Received().PreFlush(entities);
        interceptor2.Received().PreFlush(entities);
    }

    [Test]
    public void Should_call_setsession()
    {
        var interceptor1 = Substitute.For<IInterceptor>();
        var interceptor2 = Substitute.For<IInterceptor>();

        var session = Substitute.For<ISession>();

        var interceptor = new CompositeInterceptor(new[] { interceptor1, interceptor2 });
        interceptor.SetSession(session);

        interceptor1.Received().SetSession(session);
        interceptor2.Received().SetSession(session);
    }
}