using Microsoft.EntityFrameworkCore;
using SmallSoftwareContracts.DataModels;
using SmallSoftwareContracts.Enums;
using SmallSoftwareContracts.Exceptions;
using SmallSoftwareDatabase.Implementations;
using SmallSoftwareDatabase.Models;
using SmallSoftwareTests.Infrastructure;
using static NUnit.Framework.Internal.OSPlatform;

namespace SmallSoftwareTests.StoragesContracts;
[TestFixture]
internal class SoftwareStorageContractTests : BaseStorageContractTest
{
    private SoftwareStorageContract _softwareStorageContract;
    private Manufacturer _manufacturer;

    [SetUp]
    public void SetUp()
    {
        _softwareStorageContract = new SoftwareStorageContract(SmallSoftwareDbContext);
        _manufacturer = SmallSoftwareDbContext.InsertManufacturerToDatabaseAndReturn();
    }

    [TearDown]
    public void TearDown()
    {
        SmallSoftwareDbContext.RemoveSoftwaresFromDatabase();
        SmallSoftwareDbContext.RemoveManufacturersFromDatabase();
    }

    [Test]
    public void Try_GetList_WhenHaveRecords_Test()
    {
        var software = SmallSoftwareDbContext.InsertSoftwareToDatabaseAndReturn(_manufacturer.Id, softwareName: "name 1");
        SmallSoftwareDbContext.InsertSoftwareToDatabaseAndReturn(_manufacturer.Id, softwareName: "name 2");
        SmallSoftwareDbContext.InsertSoftwareToDatabaseAndReturn(_manufacturer.Id, softwareName: "name 3");
        var list = _softwareStorageContract.GetList();
        Assert.That(list, Is.Not.Null);
        Assert.That(list, Has.Count.EqualTo(3));
        AssertElement(list.First(x => x.Id == software.Id), software);
    }

    [Test]
    public void Try_GetList_WhenNoRecords_Test()
    {
        var list = _softwareStorageContract.GetList();
        Assert.That(list, Is.Not.Null);
        Assert.That(list, Is.Empty);
    }

    [Test]
    public void Try_GetList_OnlyActual_Test()
    {
        SmallSoftwareDbContext.InsertSoftwareToDatabaseAndReturn(_manufacturer.Id, softwareName: "name 1", isDeleted: true);
        SmallSoftwareDbContext.InsertSoftwareToDatabaseAndReturn(_manufacturer.Id, softwareName: "name 2", isDeleted: false);
        SmallSoftwareDbContext.InsertSoftwareToDatabaseAndReturn(_manufacturer.Id, softwareName: "name 3", isDeleted: false);
        var list = _softwareStorageContract.GetList(onlyActive: true);
        Assert.That(list, Is.Not.Null);
        Assert.Multiple(() =>
        {
            Assert.That(list, Has.Count.EqualTo(2));
            Assert.That(!list.Any(x => x.IsDeleted));
        });
    }

    [Test]
    public void Try_GetList_IncludeNoActual_Test()
    {
        SmallSoftwareDbContext.InsertSoftwareToDatabaseAndReturn(_manufacturer.Id, softwareName: "name 1", isDeleted: true);
        SmallSoftwareDbContext.InsertSoftwareToDatabaseAndReturn(_manufacturer.Id, softwareName: "name 2", isDeleted: true);
        SmallSoftwareDbContext.InsertSoftwareToDatabaseAndReturn(_manufacturer.Id, softwareName: "name 3", isDeleted: false);
        var list = _softwareStorageContract.GetList(onlyActive: false);
        Assert.That(list, Is.Not.Null);
        Assert.Multiple(() =>
        {
            Assert.That(list, Has.Count.EqualTo(3));
            Assert.That(list.Count(x => x.IsDeleted), Is.EqualTo(2));
            Assert.That(list.Count(x => !x.IsDeleted), Is.EqualTo(1));
        });
    }

    [Test]
    public void Try_GetList_ByManufacturer_Test()
    {
        var manufacruer = SmallSoftwareDbContext.InsertManufacturerToDatabaseAndReturn(manufacturerName: "name 2");
        SmallSoftwareDbContext.InsertSoftwareToDatabaseAndReturn(_manufacturer.Id, softwareName: "name 1", isDeleted: true);
        SmallSoftwareDbContext.InsertSoftwareToDatabaseAndReturn(_manufacturer.Id, softwareName: "name 2", isDeleted: false);
        SmallSoftwareDbContext.InsertSoftwareToDatabaseAndReturn(manufacruer.Id, softwareName: "name 3", isDeleted: false);
        var list = _softwareStorageContract.GetList(manufacturerId: _manufacturer.Id, onlyActive: false);
        Assert.That(list, Is.Not.Null);
        Assert.Multiple(() =>
        {
            Assert.That(list, Has.Count.EqualTo(2));
            Assert.That(list.All(x => x.ManufacturerId == _manufacturer.Id));
        });
    }

    [Test]
    public void Try_GetList_ByManufacturerOnlyActual_Test()
    {
        var manufacruer = SmallSoftwareDbContext.InsertManufacturerToDatabaseAndReturn(manufacturerName: "name 2");
        SmallSoftwareDbContext.InsertSoftwareToDatabaseAndReturn(_manufacturer.Id, softwareName: "name 1", isDeleted: true);
        SmallSoftwareDbContext.InsertSoftwareToDatabaseAndReturn(_manufacturer.Id, softwareName: "name 2", isDeleted: false);
        SmallSoftwareDbContext.InsertSoftwareToDatabaseAndReturn(manufacruer.Id, softwareName: "name 3", isDeleted: false);
        var list = _softwareStorageContract.GetList(manufacturerId: _manufacturer.Id, onlyActive: true);
        Assert.That(list, Is.Not.Null);
        Assert.Multiple(() =>
        {
            Assert.That(list, Has.Count.EqualTo(1));
            Assert.That(list.All(x => x.ManufacturerId == _manufacturer.Id && !x.IsDeleted));
        });
    }

    [Test]
    public void Try_GetHistoryBySoftwareId_WhenHaveRecords_Test()
    {
        var software = SmallSoftwareDbContext.InsertSoftwareToDatabaseAndReturn(_manufacturer.Id);
        SmallSoftwareDbContext.InsertSoftwareHistoryToDatabaseAndReturn(software.Id, 20, DateTime.UtcNow.AddDays(-1));
        SmallSoftwareDbContext.InsertSoftwareHistoryToDatabaseAndReturn(software.Id, 30, DateTime.UtcNow.AddMinutes(-10));
        SmallSoftwareDbContext.InsertSoftwareHistoryToDatabaseAndReturn(software.Id, 40, DateTime.UtcNow.AddDays(1));
        var list = _softwareStorageContract.GetHistoryBySoftwareId(software.Id);
        Assert.That(list, Is.Not.Null);
        Assert.That(list, Has.Count.EqualTo(3));
    }

    [Test]
    public void Try_GetHistoryBySoftwareId_WhenNoRecords_Test()
    {
        var software = SmallSoftwareDbContext.InsertSoftwareToDatabaseAndReturn(_manufacturer.Id);
        SmallSoftwareDbContext.InsertSoftwareHistoryToDatabaseAndReturn(software.Id, 20, DateTime.UtcNow.AddDays(-1));
        SmallSoftwareDbContext.InsertSoftwareHistoryToDatabaseAndReturn(software.Id, 30, DateTime.UtcNow.AddMinutes(-10));
        SmallSoftwareDbContext.InsertSoftwareHistoryToDatabaseAndReturn(software.Id, 40, DateTime.UtcNow.AddDays(1));
        var list = _softwareStorageContract.GetHistoryBySoftwareId(Guid.NewGuid().ToString());
        Assert.That(list, Is.Not.Null);
        Assert.That(list, Has.Count.EqualTo(0));
    }

    [Test]
    public void Try_GetElementById_WhenHaveRecord_Test()
    {
        var software = SmallSoftwareDbContext.InsertSoftwareToDatabaseAndReturn(_manufacturer.Id);
        AssertElement(_softwareStorageContract.GetElementById(software.Id), software);
    }

    [Test]
    public void Try_GetElementById_WhenNoRecord_Test()
    {
        SmallSoftwareDbContext.InsertSoftwareToDatabaseAndReturn(_manufacturer.Id);
        Assert.That(() => _softwareStorageContract.GetElementById(Guid.NewGuid().ToString()), Is.Null);
    }

    [Test]
    public void Try_GetElementById_WhenRecordWasDeleted_Test()
    {
        var software = SmallSoftwareDbContext.InsertSoftwareToDatabaseAndReturn(_manufacturer.Id, isDeleted: true);
        Assert.That(() => _softwareStorageContract.GetElementById(software.Id), Is.Null);
    }

    [Test]
    public void Try_GetElementByName_WhenHaveRecord_Test()
    {
        var software = SmallSoftwareDbContext.InsertSoftwareToDatabaseAndReturn(_manufacturer.Id);
        AssertElement(_softwareStorageContract.GetElementByName(software.SoftwareName), software);
    }

    [Test]
    public void Try_GetElementByName_WhenNoRecord_Test()
    {
        SmallSoftwareDbContext.InsertSoftwareToDatabaseAndReturn(_manufacturer.Id);
        Assert.That(() => _softwareStorageContract.GetElementByName("name"), Is.Null);
    }

    [Test]
    public void Try_GetElementByName_WhenRecordWasDeleted_Test()
    {
        var software = SmallSoftwareDbContext.InsertSoftwareToDatabaseAndReturn(_manufacturer.Id, isDeleted: true);
        Assert.That(() => _softwareStorageContract.GetElementById(software.SoftwareName), Is.Null);
    }

    [Test]
    public void Try_AddElement_Test()
    {
        var software = CreateModel(Guid.NewGuid().ToString(), _manufacturer.Id, isDeleted: false);
        _softwareStorageContract.AddElement(software);
        AssertElement(SmallSoftwareDbContext.GetSoftwareFromDatabaseById(software.Id), software);
    }

    [Test]
    public void Try_AddElement_WhenIsDeletedIsTrue_Test()
    {
        var software = CreateModel(Guid.NewGuid().ToString(), _manufacturer.Id, isDeleted: true);
        Assert.That(() => _softwareStorageContract.AddElement(software), Throws.Nothing);
        AssertElement(SmallSoftwareDbContext.GetSoftwareFromDatabaseById(software.Id), CreateModel(software.Id, _manufacturer.Id, isDeleted: false));
    }

    [Test]
    public void Try_AddElement_WhenHaveRecordWithSameId_Test()
    {
        var software = CreateModel(Guid.NewGuid().ToString(), _manufacturer.Id);
        SmallSoftwareDbContext.InsertSoftwareToDatabaseAndReturn(_manufacturer.Id, software.Id, softwareName: "name unique");
        Assert.That(() => _softwareStorageContract.AddElement(software), Throws.TypeOf<ElementExistsException>());
    }

    [Test]
    public void Try_AddElement_WhenHaveRecordWithSameName_Test()
    {
        var software = CreateModel(Guid.NewGuid().ToString(), _manufacturer.Id, "name unique", isDeleted: false);
        SmallSoftwareDbContext.InsertSoftwareToDatabaseAndReturn(_manufacturer.Id, softwareName: software.SoftwareName, isDeleted: false);
        Assert.That(() => _softwareStorageContract.AddElement(software), Throws.TypeOf<ElementExistsException>());
    }

    [Test]
    public void Try_AddElement_WhenHaveRecordWithSameNameButOneWasDeleted_Test()
    {
        var software = CreateModel(Guid.NewGuid().ToString(), _manufacturer.Id, "name unique", isDeleted: false);
        SmallSoftwareDbContext.InsertSoftwareToDatabaseAndReturn(_manufacturer.Id, softwareName: software.SoftwareName, isDeleted: true);
        Assert.That(() => _softwareStorageContract.AddElement(software), Throws.Nothing);
    }

    [Test]
    public void Try_UpdElement_Test()
    {
        var software = CreateModel(Guid.NewGuid().ToString(), _manufacturer.Id, isDeleted: false);
        SmallSoftwareDbContext.InsertSoftwareToDatabaseAndReturn(_manufacturer.Id, id: software.Id, isDeleted: false);
        _softwareStorageContract.UpdElement(software);
        AssertElement(SmallSoftwareDbContext.GetSoftwareFromDatabaseById(software.Id), software);
    }

    [Test]
    public void Try_UpdElement_WhenIsDeletedIsTrue_Test()
    {
        var software = CreateModel(Guid.NewGuid().ToString(), _manufacturer.Id, isDeleted: true);
        SmallSoftwareDbContext.InsertSoftwareToDatabaseAndReturn(_manufacturer.Id, software.Id, isDeleted: false);
        _softwareStorageContract.UpdElement(software);
        AssertElement(SmallSoftwareDbContext.GetSoftwareFromDatabaseById(software.Id), CreateModel(software.Id, _manufacturer.Id, isDeleted: false));
    }

    [Test]
    public void Try_UpdElement_WhenNoRecordWithThisId_Test()
    {
        Assert.That(() => _softwareStorageContract.UpdElement(CreateModel(Guid.NewGuid().ToString(), _manufacturer.Id)), Throws.TypeOf<ElementNotFoundException>());
    }

    [Test]
    public void Try_UpdElement_WhenHaveRecordWithSameName_Test()
    {
        var software = CreateModel(Guid.NewGuid().ToString(), _manufacturer.Id, "name unique", isDeleted: false);
        SmallSoftwareDbContext.InsertSoftwareToDatabaseAndReturn(_manufacturer.Id, software.Id, softwareName: "name");
        SmallSoftwareDbContext.InsertSoftwareToDatabaseAndReturn(_manufacturer.Id, softwareName: software.SoftwareName);
        Assert.That(() => _softwareStorageContract.UpdElement(software), Throws.TypeOf<ElementExistsException>());
    }

    [Test]
    public void Try_UpdElement_WhenHaveRecordWithSameNameButOneWasDeleted_Test()
    {
        var software = CreateModel(Guid.NewGuid().ToString(), _manufacturer.Id, "name unique", isDeleted: false);
        SmallSoftwareDbContext.InsertSoftwareToDatabaseAndReturn(_manufacturer.Id, software.Id, softwareName: "name");
        SmallSoftwareDbContext.InsertSoftwareToDatabaseAndReturn(_manufacturer.Id, softwareName: software.SoftwareName, isDeleted: true);
        Assert.That(() => _softwareStorageContract.UpdElement(software), Throws.Nothing);
    }

    [Test]
    public void Try_UpdElement_WhenRecordWasDeleted_Test()
    {
        var software = CreateModel(Guid.NewGuid().ToString(), _manufacturer.Id);
        SmallSoftwareDbContext.InsertSoftwareToDatabaseAndReturn(_manufacturer.Id, software.Id, isDeleted: true);
        Assert.That(() => _softwareStorageContract.UpdElement(software), Throws.TypeOf<ElementNotFoundException>());
    }

    [Test]
    public void Try_DelElement_Test()
    {
        var software = SmallSoftwareDbContext.InsertSoftwareToDatabaseAndReturn(_manufacturer.Id, isDeleted: false);
        _softwareStorageContract.DelElement(software.Id);
        var element = SmallSoftwareDbContext.GetSoftwareFromDatabaseById(software.Id);
        Assert.Multiple(() =>
        {
            Assert.That(element, Is.Not.Null);
            Assert.That(element!.IsDeleted);
        });
    }

    [Test]
    public void Try_DelElement_WhenNoRecordWithThisId_Test()
    {
        Assert.That(() => _softwareStorageContract.DelElement(Guid.NewGuid().ToString()), Throws.TypeOf<ElementNotFoundException>());
    }

    [Test]
    public void Try_DelElement_WhenRecordWasDeleted_Test()
    {
        var software = SmallSoftwareDbContext.InsertSoftwareToDatabaseAndReturn(_manufacturer.Id, isDeleted: true);
        Assert.That(() => _softwareStorageContract.DelElement(software.Id), Throws.TypeOf<ElementNotFoundException>());
    }

    private static void AssertElement(SoftwareDataModel? actual, Software expected)
    {
        Assert.That(actual, Is.Not.Null);
        Assert.Multiple(() =>
        {
            Assert.That(actual.Id, Is.EqualTo(expected.Id));
            Assert.That(actual.ManufacturerId, Is.EqualTo(expected.ManufacturerId));
            Assert.That(actual.SoftwareName, Is.EqualTo(expected.SoftwareName));
            Assert.That(actual.SoftwareType, Is.EqualTo(expected.SoftwareType));
            Assert.That(actual.Price, Is.EqualTo(expected.Price));
            Assert.That(actual.IsDeleted, Is.EqualTo(expected.IsDeleted));
        });
    }

    private static SoftwareDataModel CreateModel(string id, string manufacturerId, string softwareName = "test", SoftwareType softwareType = SoftwareType.Windows, double price = 1, bool isDeleted = false)
        => new(id, softwareName, softwareType, manufacturerId, price, isDeleted);

    private static void AssertElement(Software? actual, SoftwareDataModel expected)
    {
        Assert.That(actual, Is.Not.Null);
        Assert.Multiple(() =>
        {
            Assert.That(actual.Id, Is.EqualTo(expected.Id));
            Assert.That(actual.ManufacturerId, Is.EqualTo(expected.ManufacturerId));
            Assert.That(actual.SoftwareName, Is.EqualTo(expected.SoftwareName));
            Assert.That(actual.SoftwareType, Is.EqualTo(expected.SoftwareType));
            Assert.That(actual.Price, Is.EqualTo(expected.Price));
            Assert.That(actual.IsDeleted, Is.EqualTo(expected.IsDeleted));
        });
    }

}