using MagicCarpetBusinessLogic.Implementations;
using MagicCarpetContracts.BuisnessLogicContracts;
using MagicCarpetContracts.DataModels;
using MagicCarpetContracts.Exceptions;
using MagicCarpetContracts.StoragesContracts;
using Microsoft.Extensions.Logging;
using Moq;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace MagicCarpetTests.BusinessLogicContractsTests;

[TestFixture]
internal class ClientBusinessLogicContractTests
{
    private IClientBusinessLogicContract _clientBusinessLogicContract;
    private Mock<IClientStorageContract> _clientStorageContract;

    [OneTimeSetUp]
    public void OneTimeSetUp()
    {
        _clientStorageContract = new Mock<IClientStorageContract>();
        _clientBusinessLogicContract = new ClientBusinessLogicContract(_clientStorageContract.Object, new Mock<ILogger>().Object);
    }

    [TearDown]
    public void TearDown()
    {
        _clientStorageContract.Reset();
    }

    [Test]
    public void GetAllCLients_ReturnListOfRecords_Test()
    {
        //Arrange
        var listOriginal = new List<ClientDataModel>()
        {
            new(Guid.NewGuid().ToString(), "fio 1", "+7-111-111-11-11", 0),
            new(Guid.NewGuid().ToString(), "fio 2", "+7-555-444-33-23", 10),
            new(Guid.NewGuid().ToString(), "fio 3", "+7-777-777-7777", 0),
        };
        _clientStorageContract.Setup(x => x.GetList()).Returns(listOriginal);
        //Act
        var list = _clientBusinessLogicContract.GetAllClients();
        //Assert
        Assert.That(list, Is.Not.Null);
        Assert.That(list, Is.EquivalentTo(listOriginal));
    }

    [Test]
    public void GetAllClients_ReturnEmptyList_Test()
    {
        //Arrange
        _clientStorageContract.Setup(x => x.GetList()).Returns([]);
        //Act
        var list = _clientBusinessLogicContract.GetAllClients();
        //Assert
        Assert.That(list, Is.Not.Null);
        Assert.That(list, Has.Count.EqualTo(0));
        _clientStorageContract.Verify(x => x.GetList(), Times.Once);
    }

    [Test]
    public void GetAllClients_ReturnNull_ThrowException_Test()
    {
        //Act&Assert
        Assert.That(() => _clientBusinessLogicContract.GetAllClients(), Throws.TypeOf<NullListException>());
        _clientStorageContract.Verify(x => x.GetList(), Times.Once);
    }

    [Test]
    public void GetAllClients_StorageThrowError_ThrowException_Test()
    {
        //Arrange
        _clientStorageContract.Setup(x => x.GetList()).Throws(new StorageException(new InvalidOperationException()));
        //Act&Assert
        Assert.That(() => _clientBusinessLogicContract.GetAllClients(), Throws.TypeOf<StorageException>());
        _clientStorageContract.Verify(x => x.GetList(), Times.Once);
    }

    [Test]
    public void GetClientByData_GetById_ReturnRecord_Test()
    {
        //Arrange
        var id = Guid.NewGuid().ToString();
        var record = new ClientDataModel(id, "fio", "+7-111-111-11-11", 0);
        _clientStorageContract.Setup(x => x.GetElementById(id)).Returns(record);
        //Act
        var element = _clientBusinessLogicContract.GetClientByData(id);
        //Assert
        Assert.That(element, Is.Not.Null);
        Assert.That(element.Id, Is.EqualTo(id));
        _clientStorageContract.Verify(x => x.GetElementById(It.IsAny<string>()), Times.Once);
    }

    [Test]
    public void GetClientByData_GetByFio_ReturnRecord_Test()
    {
        //Arrange
        var fio = "fio";
        var record = new ClientDataModel(Guid.NewGuid().ToString(), fio, "+7-111-111-11-11", 0);
        _clientStorageContract.Setup(x => x.GetElementByFIO(fio)).Returns(record);
        //Act
        var element = _clientBusinessLogicContract.GetClientByData(fio);
        //Assert
        Assert.That(element, Is.Not.Null);
        Assert.That(element.FIO, Is.EqualTo(fio));
        _clientStorageContract.Verify(x => x.GetElementByFIO(It.IsAny<string>()), Times.Once);
    }

    [Test]
    public void GetClientByData_GetByPhoneNumber_ReturnRecord_Test()
    {
        //Arrange
        var phoneNumber = "+7-111-111-11-11";
        var record = new ClientDataModel(Guid.NewGuid().ToString(), "fio", phoneNumber, 0);
        _clientStorageContract.Setup(x => x.GetElementByPhoneNumber(phoneNumber)).Returns(record);
        //Act
        var element = _clientBusinessLogicContract.GetClientByData(phoneNumber);
        //Assert
        Assert.That(element, Is.Not.Null);
        Assert.That(element.PhoneNumber, Is.EqualTo(phoneNumber));
        _clientStorageContract.Verify(x => x.GetElementByPhoneNumber(It.IsAny<string>()), Times.Once);
    }

    [Test]
    public void GetClientByData_EmptyData_ThrowException_Test()
    {
        //Act&Assert
        Assert.That(() => _clientBusinessLogicContract.GetClientByData(null), Throws.TypeOf<ArgumentNullException>());
        Assert.That(() => _clientBusinessLogicContract.GetClientByData(string.Empty), Throws.TypeOf<ArgumentNullException>());
        _clientStorageContract.Verify(x => x.GetElementById(It.IsAny<string>()), Times.Never);
        _clientStorageContract.Verify(x => x.GetElementByPhoneNumber(It.IsAny<string>()), Times.Never);
        _clientStorageContract.Verify(x => x.GetElementByFIO(It.IsAny<string>()), Times.Never);
    }

    [Test]
    public void GetClientByData_GetById_NotFoundRecord_ThrowException_Test()
    {
        //Act&Assert
        Assert.That(() => _clientBusinessLogicContract.GetClientByData(Guid.NewGuid().ToString()), Throws.TypeOf<ElementNotFoundException>());
        _clientStorageContract.Verify(x => x.GetElementById(It.IsAny<string>()), Times.Once);
        _clientStorageContract.Verify(x => x.GetElementByPhoneNumber(It.IsAny<string>()), Times.Never);
        _clientStorageContract.Verify(x => x.GetElementByFIO(It.IsAny<string>()), Times.Never);
    }

    [Test]
    public void GetClientByData_GetByFio_NotFoundRecord_ThrowException_Test()
    {
        //Act&Assert
        Assert.That(() => _clientBusinessLogicContract.GetClientByData("fio"), Throws.TypeOf<ElementNotFoundException>());
        _clientStorageContract.Verify(x => x.GetElementById(It.IsAny<string>()), Times.Never);
        _clientStorageContract.Verify(x => x.GetElementByFIO(It.IsAny<string>()), Times.Once);
        _clientStorageContract.Verify(x => x.GetElementByPhoneNumber(It.IsAny<string>()), Times.Never);
    }

    [Test]
    public void GetClientByData_GetByPhoneNumber_NotFoundRecord_ThrowException_Test()
    {
        //Act&Assert
        Assert.That(() => _clientBusinessLogicContract.GetClientByData("+7-111-111-11-12"), Throws.TypeOf<ElementNotFoundException>());
        _clientStorageContract.Verify(x => x.GetElementById(It.IsAny<string>()), Times.Never);
        _clientStorageContract.Verify(x => x.GetElementByFIO(It.IsAny<string>()), Times.Never);
        _clientStorageContract.Verify(x => x.GetElementByPhoneNumber(It.IsAny<string>()), Times.Once);
    }

    [Test]
    public void GetClientByData_StorageThrowError_ThrowException_Test()
    {
        //Arrange
        _clientStorageContract.Setup(x => x.GetElementById(It.IsAny<string>())).Throws(new StorageException(new InvalidOperationException()));
        _clientStorageContract.Setup(x => x.GetElementByFIO(It.IsAny<string>())).Throws(new StorageException(new InvalidOperationException()));
        _clientStorageContract.Setup(x => x.GetElementByPhoneNumber(It.IsAny<string>())).Throws(new StorageException(new InvalidOperationException()));
        //Act&Assert
        Assert.That(() => _clientBusinessLogicContract.GetClientByData(Guid.NewGuid().ToString()), Throws.TypeOf<StorageException>());
        Assert.That(() => _clientBusinessLogicContract.GetClientByData("fio"), Throws.TypeOf<StorageException>());
        Assert.That(() => _clientBusinessLogicContract.GetClientByData("+7-111-111-11-12"), Throws.TypeOf<StorageException>());
        _clientStorageContract.Verify(x => x.GetElementById(It.IsAny<string>()), Times.Once);
        _clientStorageContract.Verify(x => x.GetElementByFIO(It.IsAny<string>()), Times.Once);
        _clientStorageContract.Verify(x => x.GetElementByPhoneNumber(It.IsAny<string>()), Times.Once);
    }

    [Test]
    public void InsertClient_CorrectRecord_Test()
    {
        //Arrange
        var flag = false;
        var record = new ClientDataModel(Guid.NewGuid().ToString(), "fio", "+7-111-111-11-11", 10);
        _clientStorageContract.Setup(x => x.AddElement(It.IsAny<ClientDataModel>()))
            .Callback((ClientDataModel x) =>
            {
                flag = x.Id == record.Id && x.FIO == record.FIO &&
                    x.PhoneNumber == record.PhoneNumber && x.DiscountSize == record.DiscountSize;
            });
        //Act
        _clientBusinessLogicContract.InsertClient(record);
        //Assert
        _clientStorageContract.Verify(x => x.AddElement(It.IsAny<ClientDataModel>()), Times.Once);
        Assert.That(flag);
    }

    [Test]
    public void InsertClient_RecordWithExistsData_ThrowException_Test()
    {
        //Arrange
        _clientStorageContract.Setup(x => x.AddElement(It.IsAny<ClientDataModel>())).Throws(new ElementExistsException("Data", "Data"));
        //Act&Assert
        Assert.That(() => _clientBusinessLogicContract.InsertClient(new(Guid.NewGuid().ToString(), "fio", "+7-111-111-11-11", 0)), Throws.TypeOf<ElementExistsException>());
        _clientStorageContract.Verify(x => x.AddElement(It.IsAny<ClientDataModel>()), Times.Once);
    }

    [Test]
    public void InsertClient_NullRecord_ThrowException_Test()
    {
        //Act&Assert
        Assert.That(() => _clientBusinessLogicContract.InsertClient(null), Throws.TypeOf<ArgumentNullException>());
        _clientStorageContract.Verify(x => x.AddElement(It.IsAny<ClientDataModel>()), Times.Never);
    }

    [Test]
    public void InsertClient_InvalidRecord_ThrowException_Test()
    {
        //Act&Assert
        Assert.That(() => _clientBusinessLogicContract.InsertClient(new ClientDataModel("id", "fio", "+7-111-111-11-11", 10)), Throws.TypeOf<ValidationException>());
        _clientStorageContract.Verify(x => x.AddElement(It.IsAny<ClientDataModel>()), Times.Never);
    }

    [Test]
    public void InsertClient_StorageThrowError_ThrowException_Test()
    {
        //Arrange
        _clientStorageContract.Setup(x => x.AddElement(It.IsAny<ClientDataModel>())).Throws(new StorageException(new InvalidOperationException()));
        //Act&Assert
        Assert.That(() => _clientBusinessLogicContract.InsertClient(new(Guid.NewGuid().ToString(), "fio", "+7-111-111-11-11", 0)), Throws.TypeOf<StorageException>());
        _clientStorageContract.Verify(x => x.AddElement(It.IsAny<ClientDataModel>()), Times.Once);
    }

    [Test]
    public void UpdateClient_CorrectRecord_Test()
    {
        //Arrange
        var flag = false;
        var record = new ClientDataModel(Guid.NewGuid().ToString(), "fio", "+7-111-111-11-11", 0);
        _clientStorageContract.Setup(x => x.UpdElement(It.IsAny<ClientDataModel>()))
            .Callback((ClientDataModel x) =>
            {
                flag = x.Id == record.Id && x.FIO == record.FIO &&
                    x.PhoneNumber == record.PhoneNumber && x.DiscountSize == record.DiscountSize;
            });
        //Act
        _clientBusinessLogicContract.UpdateClient(record);
        //Assert
        _clientStorageContract.Verify(x => x.UpdElement(It.IsAny<ClientDataModel>()), Times.Once);
        Assert.That(flag);
    }

    [Test]
    public void UpdateClient_RecordWithIncorrectData_ThrowException_Test()
    {
        //Arrange
        _clientStorageContract.Setup(x => x.UpdElement(It.IsAny<ClientDataModel>())).Throws(new ElementNotFoundException(""));
        //Act&Assert
        Assert.That(() => _clientBusinessLogicContract.UpdateClient(new(Guid.NewGuid().ToString(), "fio", "+7-111-111-11-11", 0)), Throws.TypeOf<ElementNotFoundException>());
        _clientStorageContract.Verify(x => x.UpdElement(It.IsAny<ClientDataModel>()), Times.Once);
    }

    [Test]
    public void UpdateClient_RecordWithExistsData_ThrowException_Test()
    {
        //Arrange
        _clientStorageContract.Setup(x => x.UpdElement(It.IsAny<ClientDataModel>())).Throws(new ElementExistsException("Data", "Data"));
        //Act&Assert
        Assert.That(() => _clientBusinessLogicContract.UpdateClient(new(Guid.NewGuid().ToString(), "fio", "+7-111-111-11-11", 0)), Throws.TypeOf<ElementExistsException>());
        _clientStorageContract.Verify(x => x.UpdElement(It.IsAny<ClientDataModel>()), Times.Once);
    }

    [Test]
    public void UpdateClient_NullRecord_ThrowException_Test()
    {
        //Act&Assert
        Assert.That(() => _clientBusinessLogicContract.UpdateClient(null), Throws.TypeOf<ArgumentNullException>());
        _clientStorageContract.Verify(x => x.UpdElement(It.IsAny<ClientDataModel>()), Times.Never);
    }

    [Test]
    public void UpdateClient_InvalidRecord_ThrowException_Test()
    {
        //Act&Assert
        Assert.That(() => _clientBusinessLogicContract.UpdateClient(new ClientDataModel("id", "fio", "+7-111-111-11-11", 10)), Throws.TypeOf<ValidationException>());
        _clientStorageContract.Verify(x => x.UpdElement(It.IsAny<ClientDataModel>()), Times.Never);
    }

    [Test]
    public void UpdateClient_StorageThrowError_ThrowException_Test()
    {
        //Arrange
        _clientStorageContract.Setup(x => x.UpdElement(It.IsAny<ClientDataModel>())).Throws(new StorageException(new InvalidOperationException()));
        //Act&Assert
        Assert.That(() => _clientBusinessLogicContract.UpdateClient(new(Guid.NewGuid().ToString(), "fio", "+7-111-111-11-11", 0)), Throws.TypeOf<StorageException>());
        _clientStorageContract.Verify(x => x.UpdElement(It.IsAny<ClientDataModel>()), Times.Once);
    }

    [Test]
    public void DeleteClient_CorrectRecord_Test()
    {
        //Arrange
        var id = Guid.NewGuid().ToString();
        var flag = false;
        _clientStorageContract.Setup(x => x.DelElement(It.Is((string x) => x == id))).Callback(() => { flag = true; });
        //Act
        _clientBusinessLogicContract.DeleteClient(id);
        //Assert
        _clientStorageContract.Verify(x => x.DelElement(It.IsAny<string>()), Times.Once);
        Assert.That(flag);
    }

    [Test]
    public void DeleteClient_RecordWithIncorrectId_ThrowException_Test()
    {
        //Arrange
        _clientStorageContract.Setup(x => x.DelElement(It.IsAny<string>())).Throws(new ElementNotFoundException(""));
        //Act&Assert
        Assert.That(() => _clientBusinessLogicContract.DeleteClient(Guid.NewGuid().ToString()), Throws.TypeOf<ElementNotFoundException>());
        _clientStorageContract.Verify(x => x.DelElement(It.IsAny<string>()), Times.Once);
    }

    [Test]
    public void DeleteClient_IdIsNullOrEmpty_ThrowException_Test()
    {
        //Act&Assert
        Assert.That(() => _clientBusinessLogicContract.DeleteClient(null), Throws.TypeOf<ArgumentNullException>());
        Assert.That(() => _clientBusinessLogicContract.DeleteClient(string.Empty), Throws.TypeOf<ArgumentNullException>());
        _clientStorageContract.Verify(x => x.DelElement(It.IsAny<string>()), Times.Never);
    }

    [Test]
    public void DeleteClient_IdIsNotGuid_ThrowException_Test()
    {
        //Act&Assert
        Assert.That(() => _clientBusinessLogicContract.DeleteClient("id"), Throws.TypeOf<ValidationException>());
        _clientStorageContract.Verify(x => x.DelElement(It.IsAny<string>()), Times.Never);
    }

    [Test]
    public void DeleteClient_StorageThrowError_ThrowException_Test()
    {
        //Arrange
        _clientStorageContract.Setup(x => x.DelElement(It.IsAny<string>())).Throws(new StorageException(new InvalidOperationException()));
        //Act&Assert
        Assert.That(() => _clientBusinessLogicContract.DeleteClient(Guid.NewGuid().ToString()), Throws.TypeOf<StorageException>());
        _clientStorageContract.Verify(x => x.DelElement(It.IsAny<string>()), Times.Once);
    }
}