using MiniSoftContracts.Data_Models;
using MiniSoftContracts.Exceptions;
using MiniSoftDatabase.Models;
using MiniSoftDatabase;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using MiniSoftDatabase.Implementations;
using Microsoft.EntityFrameworkCore;

namespace MiniSoftTests.StorageContractsTests
{
    internal class DeveloperStorageContractTest : BaseStorageContractTest
    {
        private DeveloperStorageContract _developerStorageContract;

        [SetUp]
        public void SetUp()
        {
            _developerStorageContract = new DeveloperStorageContract(MiniSoftDbContext);
        }

        [TearDown]
        public void TearDown()
        {
            MiniSoftDbContext.Database.ExecuteSqlRaw("TRUNCATE \"Softwares\" CASCADE;");
            MiniSoftDbContext.Database.ExecuteSqlRaw("TRUNCATE \"Developers\" CASCADE;");
        }

        [Test]
        public void Try_GetList_WhenHaveRecords_Test()
        {
            var Developer = InsertDeveloperToDatabaseAndReturn(Guid.NewGuid().ToString(), "name 1");
            InsertDeveloperToDatabaseAndReturn(Guid.NewGuid().ToString(), "name 2");
            InsertDeveloperToDatabaseAndReturn(Guid.NewGuid().ToString(), "name 3");
            var list = _developerStorageContract.GetList();
            Assert.That(list, Is.Not.Null);
            Assert.That(list, Has.Count.EqualTo(3));
            AssertElement(list.First(x => x.Id == Developer.Id), Developer);
        }

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

        [Test]
        public void Try_GetElementById_WhenHaveRecord_Test()
        {
            var Developer = InsertDeveloperToDatabaseAndReturn(Guid.NewGuid().ToString());
            AssertElement(_developerStorageContract.GetElementById(Developer.Id), Developer);
        }

        [Test]
        public void Try_GetElementById_WhenNoRecord_Test()
        {
            InsertDeveloperToDatabaseAndReturn(Guid.NewGuid().ToString());
            Assert.That(() => _developerStorageContract.GetElementById(Guid.NewGuid().ToString()), Is.Null);
        }

        [Test]
        public void Try_GetElementByName_WhenHaveRecord_Test()
        {
            var Developer = InsertDeveloperToDatabaseAndReturn(Guid.NewGuid().ToString());
            AssertElement(_developerStorageContract.GetElementByName(Developer.DeveloperName), Developer);
        }

        [Test]
        public void Try_GetElementByName_WhenNoRecord_Test()
        {
            InsertDeveloperToDatabaseAndReturn(Guid.NewGuid().ToString());
            Assert.That(() => _developerStorageContract.GetElementByName("name"), Is.Null);
        }

        [Test]
        public void Try_GetElementByOldName_WhenHaveRecord_Test()
        {
            var Developer = InsertDeveloperToDatabaseAndReturn(Guid.NewGuid().ToString());
            AssertElement(_developerStorageContract.GetElementByOldName(Developer.PrevDeveloperName!), Developer);
            AssertElement(_developerStorageContract.GetElementByOldName(Developer.PrevPrevDeveloperName!), Developer);
        }

        [Test]
        public void Try_GetElementByOldName_WhenNoRecord_Test()
        {
            InsertDeveloperToDatabaseAndReturn(Guid.NewGuid().ToString());
            Assert.That(() => _developerStorageContract.GetElementByOldName("name"), Is.Null);
        }

        [Test]
        public void Try_AddElement_Test()
        {
            var Developer = CreateModel(Guid.NewGuid().ToString());
            _developerStorageContract.AddElement(Developer);
            AssertElement(GetDeveloperFromDatabase(Developer.Id), Developer);
        }

        [Test]
        public void Try_AddElement_WhenHaveRecordWithSameId_Test()
        {
            var Developer = CreateModel(Guid.NewGuid().ToString(), "name unique");
            InsertDeveloperToDatabaseAndReturn(Developer.Id);
            Assert.That(() => _developerStorageContract.AddElement(Developer), Throws.TypeOf<ElementExistsException>());
        }

        [Test]
        public void Try_AddElement_WhenHaveRecordWithSameDeveloperName_Test()
        {
            var Developer = CreateModel(Guid.NewGuid().ToString(), "name unique");
            InsertDeveloperToDatabaseAndReturn(Guid.NewGuid().ToString(), DeveloperName: Developer.DeveloperName);
            Assert.That(() => _developerStorageContract.AddElement(Developer), Throws.TypeOf<ElementExistsException>());
        }

        [Test]
        public void Try_UpdateElement_Test()
        {
            var Developer = CreateModel(Guid.NewGuid().ToString(), "name new", "test", "prev");
            InsertDeveloperToDatabaseAndReturn(Developer.Id, DeveloperName: Developer.PrevDeveloperName!, prevDeveloperName: Developer.PrevPrevDeveloperName!);
            _developerStorageContract.UpdateElement(CreateModel(Developer.Id, "name new", "some name", "some name"));
            AssertElement(GetDeveloperFromDatabase(Developer.Id), Developer);
        }

        [Test]
        public void Try_UpdateElement_WhenNoChangeDeveloperName_Test()
        {
            var Developer = CreateModel(Guid.NewGuid().ToString(), "name new", "test", "prev");
            InsertDeveloperToDatabaseAndReturn(Developer.Id, DeveloperName: Developer.DeveloperName!, prevDeveloperName: Developer.PrevDeveloperName!, prevPrevDeveloperName: Developer.PrevPrevDeveloperName!);
            _developerStorageContract.UpdateElement(Developer);
            AssertElement(GetDeveloperFromDatabase(Developer.Id), Developer);
        }

        [Test]
        public void Try_UpdateElement_WhenNoRecordWithThisId_Test()
        {
            Assert.That(() => _developerStorageContract.UpdateElement(CreateModel(Guid.NewGuid().ToString())), Throws.TypeOf<ElementNotFoundException>());
        }

        [Test]
        public void Try_UpdateElement_WhenHaveRecordWithSameDeveloperName_Test()
        {
            var Developer = CreateModel(Guid.NewGuid().ToString(), "name unique");
            InsertDeveloperToDatabaseAndReturn(Developer.Id, DeveloperName: "some name");
            InsertDeveloperToDatabaseAndReturn(Guid.NewGuid().ToString(), DeveloperName: Developer.DeveloperName);
            Assert.That(() => _developerStorageContract.UpdateElement(Developer), Throws.TypeOf<ElementExistsException>());
        }

        [Test]
        public void Try_DeleteElement_WhenNoSoftwares_Test()
        {
            var Developer = InsertDeveloperToDatabaseAndReturn(Guid.NewGuid().ToString());
            _developerStorageContract.DeleteElement(Developer.Id);
            var element = GetDeveloperFromDatabase(Developer.Id);
            Assert.That(element, Is.Null);
        }

        [Test]
        public void Try_DeleteElement_WhenHaveSoftwares_Test()
        {
            var Developer = InsertDeveloperToDatabaseAndReturn(Guid.NewGuid().ToString());
            MiniSoftDbContext.Softwares.Add(new Software() { Id = Guid.NewGuid().ToString(), SoftwareName = "name", DeveloperId = Developer.Id, Price = 10, IsDeleted = false });
            MiniSoftDbContext.SaveChanges();
            Assert.That(() => _developerStorageContract.DeleteElement(Developer.Id), Throws.TypeOf<StorageException>());
        }

        [Test]
        public void Try_DeleteElement_WhenNoRecordWithThisId_Test()
        {
            Assert.That(() => _developerStorageContract.DeleteElement(Guid.NewGuid().ToString()), Throws.TypeOf<ElementNotFoundException>());
        }

        private Developer InsertDeveloperToDatabaseAndReturn(string id, string DeveloperName = "test", string prevDeveloperName = "prev", string prevPrevDeveloperName = "prevPrev")
        {
            var Developer = new Developer() { Id = id, DeveloperName = DeveloperName, PrevDeveloperName = prevDeveloperName, PrevPrevDeveloperName = prevPrevDeveloperName };
            MiniSoftDbContext.Developers.Add(Developer);
            MiniSoftDbContext.SaveChanges();
            return Developer;
        }

        private static void AssertElement(DeveloperDataModel? actual, Developer expected)
        {
            Assert.That(actual, Is.Not.Null);
            Assert.Multiple(() =>
            {
                Assert.That(actual.Id, Is.EqualTo(expected.Id));
                Assert.That(actual.DeveloperName, Is.EqualTo(expected.DeveloperName));
                Assert.That(actual.PrevDeveloperName, Is.EqualTo(expected.PrevDeveloperName));
                Assert.That(actual.PrevPrevDeveloperName, Is.EqualTo(expected.PrevPrevDeveloperName));
            });
        }

        private static DeveloperDataModel CreateModel(string id, string DeveloperName = "test", string prevDeveloperName = "prev", string prevPrevDeveloperName = "prevPrev")
            => new(id, DeveloperName, prevDeveloperName, prevPrevDeveloperName);

        private Developer? GetDeveloperFromDatabase(string id) => MiniSoftDbContext.Developers.FirstOrDefault(x => x.Id == id);

        private static void AssertElement(Developer? actual, DeveloperDataModel expected)
        {
            Assert.That(actual, Is.Not.Null);
            Assert.Multiple(() =>
            {
                Assert.That(actual.Id, Is.EqualTo(expected.Id));
                Assert.That(actual.DeveloperName, Is.EqualTo(expected.DeveloperName));
                Assert.That(actual.PrevDeveloperName, Is.EqualTo(expected.PrevDeveloperName));
                Assert.That(actual.PrevPrevDeveloperName, Is.EqualTo(expected.PrevPrevDeveloperName));
            });
        }
    }
}