using System.Collections.Generic;
using FluentAssertions;
using FluentAssertions.Execution;
using NUnit.Framework;

namespace FluentAssertionTests
{
  public abstract class Car
  {
    protected Car(string licensePlate)
    {
      LicensePlate = licensePlate;
    }

    public string LicensePlate { get; }
  }

  public class Peugeot : Car
  {
    public Peugeot(string licensePlate, string peugeotNumber)
      : base(licensePlate)
    {
      PeugeotNumber = peugeotNumber;
    }

    public string PeugeotNumber { get; }
  }

  [TestFixture]
  public class Tests
  {
    private Car _expected;
    private IEnumerable<Car> _expectedIEnumerable;
    private Car _actual;
    private IEnumerable<Car> _actualIEnumerable;

    /// <summary>
    ///   I expect all the statements in this scope to fail, but they all succeed.
    /// </summary>
    [Test]
    public void TestCase1()
    {
      using(new AssertionScope())
      {
        _expectedIEnumerable.Should().BeEquivalentTo(_actualIEnumerable);
        new[] { _expected }.Should().BeEquivalentTo(_actualIEnumerable);
        _expected.Should().BeEquivalentTo(_actual);
      }
    }

    /// <summary>
    ///   All the statements fail, as I expect.
    /// </summary>
    [Test]
    public void TestCase2()
    {
      using(new AssertionScope())
      {
        new[] { _expected }.Should().BeEquivalentTo(new[] { _actual });
        _expectedIEnumerable.Should().BeEquivalentTo(new[] { _actual });
      }
    }

    /// <summary>
    ///   In order to let TestCase1 fail, the RespectingRuntimeTypes option has to be enabled. Can this be the default instead
    ///   of compile time type?
    /// </summary>
    [Test]
    public void TestCase3()
    {
      using(new AssertionScope())
      {
        _expectedIEnumerable.Should().BeEquivalentTo(_actualIEnumerable, o => o.RespectingRuntimeTypes());
        new[] { _expected }.Should().BeEquivalentTo(_actualIEnumerable, o => o.RespectingRuntimeTypes());
        _expected.Should().BeEquivalentTo(_actual, o => o.RespectingRuntimeTypes());
      }
    }

    /// <summary>
    ///   I expect BeEquivalentTo and NotBeEquivalentTo to be mutually exclusive. But this test succeeds.
    /// </summary>
    [Test]
    public void TestCase4()
    {
      using(new AssertionScope())
      {
        _expectedIEnumerable.Should().BeEquivalentTo(_actualIEnumerable);
        _expectedIEnumerable.Should().NotBeEquivalentTo(_actualIEnumerable);
      }
    }

    /// <summary>
    ///   There is no ObjectAssertions NotBeEquivalentTo method. Can this be added?
    /// </summary>
    [Test]
    public void TestCase5()
    {
      using(new AssertionScope())
      {
        _expected.Should().BeEquivalentTo(_actual);
        //_expected.Should().NotBeEquivalentTo(_actual);
      }
    }

    /// <summary>
    ///   Here I expect both statements to fail, only the second one fails.
    /// </summary>
    [Test]
    public void TestCase6()
    {
      using(new AssertionScope())
      {
        new Peugeot("AA-AA-AA", "123").Should().BeEquivalentTo(_actual);
        _expected.Should().BeEquivalentTo(new Peugeot("AA-AA-AA", "456"));
      }
    }

    [OneTimeSetUp]
    public void OneTimeSetUp()
    {
      _expected = new Peugeot("AA-AA-AA", "123");
      _expectedIEnumerable = new[] { _expected };
      _actual = new Peugeot("AA-AA-AA", "456");
      _actualIEnumerable = new[] { _actual };
    }
  }
}