using Moq;
using NUnit.Framework;
using System;
using System.Collections.Generic;
using System.Linq;
using CandyHouseBase.DataModels;
using CandyHouseBase.Exceptions;
using CandyHouseBase.Extensions;
using CandyHouseBase.Implementations;
using CandyHouseBase.Interfaces.BusinessLogicsContracts;
using CandyHouseBase.Interfaces.StoragesContracts;
using Microsoft.Extensions.Logging;

namespace CandyHouseTests.BusinessLogicsContractsTests
{
    [TestFixture]
    internal class SalaryBusinessLogicContractTests
    {
        private SalaryBusinessLogicContract _salaryBusinessLogicContract;
        private Mock<ISalaryStorageContact> _salaryStorageContact;
        private Mock<IPekarStorageContact> _pekarStorageContact;

        [OneTimeSetUp]
        public void OneTimeSetUp()
        {
            _salaryStorageContact = new Mock<ISalaryStorageContact>();
            _pekarStorageContact = new Mock<IPekarStorageContact>();
            _salaryBusinessLogicContract = new SalaryBusinessLogicContract(
                _salaryStorageContact.Object,
                _pekarStorageContact.Object,
                new Mock<ILogger>().Object
            );
        }

        [SetUp]
        public void SetUp()
        {
            _salaryStorageContact.Reset();
            _pekarStorageContact.Reset();
        }

        [Test]
        public void GetAllSalaries_ReturnsListOfRecords_Test()
        {
            // Arrange
            var pekarId = Guid.NewGuid().ToString();
            var salaries = new List<SalaryDataModel>
            {
                new SalaryDataModel(
                    Guid.NewGuid().ToString(),
                    pekarId,
                    DateTime.Now.AddMonths(-1),
                    1000.00m,
                    200.00m,
                    1200.00m
                ),
                new SalaryDataModel(
                    Guid.NewGuid().ToString(),
                    pekarId,
                    DateTime.Now,
                    1500.00m,
                    300.00m,
                    1800.00m
                )
            };
            _salaryStorageContact.Setup(x => x.GetList()).Returns(salaries);
            _pekarStorageContact.Setup(x => x.GetElementById(pekarId)).Returns(new PekarDataModel(pekarId, "Ivan Ivanov", "Baker", 1.5m, new List<ProductDataModel>()));

            // Act
            var list = _salaryBusinessLogicContract.GetAllSalaries();

            // Assert
            Assert.That(list, Is.Not.Null);
            Assert.That(list, Is.EquivalentTo(salaries));
            Assert.That(list.All(s => Guid.TryParse(s.Id, out _) && Guid.TryParse(s.PekarId, out _) && s.BaseRate >= 0 && s.BonusRate >= 0 && s.TotalSalary >= 0), Is.True);
            _salaryStorageContact.Verify(x => x.GetList(), Times.Once);
        }

        [Test]
        public void GetAllSalaries_ReturnsEmptyList_Test()
        {
            // Arrange
            _salaryStorageContact.Setup(x => x.GetList()).Returns(new List<SalaryDataModel>());

            // Act
            var list = _salaryBusinessLogicContract.GetAllSalaries();

            // Assert
            Assert.That(list, Is.Not.Null);
            Assert.That(list, Has.Count.EqualTo(0));
            _salaryStorageContact.Verify(x => x.GetList(), Times.Once);
        }

        [Test]
        public void GetAllSalaries_ReturnsNull_ThrowException_Test()
        {
            // Arrange
            _salaryStorageContact.Setup(x => x.GetList()).Returns((List<SalaryDataModel>)null);

            // Act & Assert
            Assert.That(() => _salaryBusinessLogicContract.GetAllSalaries(), Throws.TypeOf<NullListException>());
            _salaryStorageContact.Verify(x => x.GetList(), Times.Once);
        }

        [Test]
        public void GetAllSalaries_StorageThrowError_ThrowException_Test()
        {
            // Arrange
            _salaryStorageContact.Setup(x => x.GetList()).Throws(new StorageException(new InvalidOperationException()));

            // Act & Assert
            Assert.That(() => _salaryBusinessLogicContract.GetAllSalaries(), Throws.TypeOf<StorageException>());
            _salaryStorageContact.Verify(x => x.GetList(), Times.Once);
        }

        [Test]
        public void GetSalaryByData_ReturnsSalaryById_Test()
        {
            // Arrange
            var id = Guid.NewGuid().ToString();
            var pekarId = Guid.NewGuid().ToString();
            var salary = new SalaryDataModel(
                id,
                pekarId,
                DateTime.Now,
                1000.00m,
                200.00m,
                1200.00m
            );
            _salaryStorageContact.Setup(x => x.GetElementById(id)).Returns(salary);
            _pekarStorageContact.Setup(x => x.GetElementById(pekarId)).Returns(new PekarDataModel(pekarId, "Ivan Ivanov", "Baker", 1.5m, new List<ProductDataModel>()));

            // Act
            var element = _salaryBusinessLogicContract.GetSalaryByData(id);

            // Assert
            Assert.That(element, Is.Not.Null);
            Assert.That(element.Id, Is.EqualTo(id));
            Assert.That(Guid.TryParse(element.Id, out _), Is.True);
            Assert.That(Guid.TryParse(element.PekarId, out _), Is.True);
            Assert.That(element.BaseRate >= 0);
            Assert.That(element.BonusRate >= 0);
            Assert.That(element.TotalSalary >= 0);
            _salaryStorageContact.Verify(x => x.GetElementById(id), Times.Once);
            _pekarStorageContact.Verify(x => x.GetElementById(pekarId), Times.Once);
        }

        [Test]
        public void GetSalaryByData_EmptyId_ThrowException_Test()
        {
            // Act & Assert
            Assert.That(() => _salaryBusinessLogicContract.GetSalaryByData(null), Throws.TypeOf<ArgumentNullException>());
            Assert.That(() => _salaryBusinessLogicContract.GetSalaryByData(string.Empty), Throws.TypeOf<ArgumentNullException>());
            _salaryStorageContact.Verify(x => x.GetElementById(It.IsAny<string>()), Times.Never);
        }

        [Test]
        public void GetSalaryByData_InvalidId_ThrowException_Test()
        {
            // Arrange
            var id = "invalid";

            // Act & Assert
            Assert.That(() => _salaryBusinessLogicContract.GetSalaryByData(id), Throws.TypeOf<ValidationException>());
            _salaryStorageContact.Verify(x => x.GetElementById(id), Times.Never);
        }

        [Test]
        public void GetSalaryByData_NotFoundSalary_ThrowException_Test()
        {
            // Arrange
            var id = Guid.NewGuid().ToString();
            _salaryStorageContact.Setup(x => x.GetElementById(id)).Returns((SalaryDataModel)null);

            // Act & Assert
            Assert.That(() => _salaryBusinessLogicContract.GetSalaryByData(id), Throws.TypeOf<ElementNotFoundException>());
            _salaryStorageContact.Verify(x => x.GetElementById(id), Times.Once);
        }

        [Test]
        public void GetSalaryByData_PekarNotFound_ThrowException_Test()
        {
            // Arrange
            var id = Guid.NewGuid().ToString();
            var pekarId = Guid.NewGuid().ToString();
            var salary = new SalaryDataModel(id, pekarId, DateTime.Now, 1000.00m, 200.00m, 1200.00m);
            _salaryStorageContact.Setup(x => x.GetElementById(id)).Returns(salary);
            _pekarStorageContact.Setup(x => x.GetElementById(pekarId)).Returns((PekarDataModel)null);

            // Act & Assert
            Assert.That(() => _salaryBusinessLogicContract.GetSalaryByData(id), Throws.TypeOf<ElementNotFoundException>());
            _salaryStorageContact.Verify(x => x.GetElementById(id), Times.Once);
            _pekarStorageContact.Verify(x => x.GetElementById(pekarId), Times.Once);
        }

        [Test]
        public void GetSalaryByData_StorageThrowError_ThrowException_Test()
        {
            // Arrange
            _salaryStorageContact.Setup(x => x.GetElementById(It.IsAny<string>())).Throws(new StorageException(new InvalidOperationException()));

            // Act & Assert
            Assert.That(() => _salaryBusinessLogicContract.GetSalaryByData(Guid.NewGuid().ToString()), Throws.TypeOf<StorageException>());
            _salaryStorageContact.Verify(x => x.GetElementById(It.IsAny<string>()), Times.Once);
        }

        [Test]
        public void InsertSalary_CorrectRecord_Test()
        {
            // Arrange
            var pekarId = Guid.NewGuid().ToString();
            var flag = false;
            var salary = new SalaryDataModel(
                Guid.NewGuid().ToString(),
                pekarId,
                DateTime.Now,
                1000.00m,
                200.00m,
                1200.00m
            );
            _salaryStorageContact.Setup(x => x.AddElement(It.IsAny<SalaryDataModel>()))
                .Callback((SalaryDataModel x) =>
                {
                    flag = x.Id == salary.Id && x.PekarId == salary.PekarId && x.Period == salary.Period &&
                           x.BaseRate == salary.BaseRate && x.BonusRate == salary.BonusRate && x.TotalSalary == salary.TotalSalary;
                });
            _pekarStorageContact.Setup(x => x.GetElementById(pekarId)).Returns(new PekarDataModel(pekarId, "Ivan Ivanov", "Baker", 1.5m, new List<ProductDataModel>()));

            // Act
            _salaryBusinessLogicContract.InsertSalary(salary);

            // Assert
            _salaryStorageContact.Verify(x => x.AddElement(It.IsAny<SalaryDataModel>()), Times.Once);
            Assert.That(flag);
            Assert.That(Guid.TryParse(salary.Id, out _), Is.True);
            Assert.That(Guid.TryParse(salary.PekarId, out _), Is.True);
            Assert.That(salary.BaseRate >= 0);
            Assert.That(salary.BonusRate >= 0);
            Assert.That(salary.TotalSalary >= 0);
            _pekarStorageContact.Verify(x => x.GetElementById(pekarId), Times.Once);
        }

        [Test]
        public void InsertSalary_PekarNotFound_ThrowException_Test()
        {
            // Arrange
            var salary = new SalaryDataModel(
                Guid.NewGuid().ToString(),
                Guid.NewGuid().ToString(),
                DateTime.Now,
                1000.00m,
                200.00m,
                1200.00m
            );
            _pekarStorageContact.Setup(x => x.GetElementById(salary.PekarId)).Returns((PekarDataModel)null);

            // Act & Assert
            Assert.That(() => _salaryBusinessLogicContract.InsertSalary(salary), Throws.TypeOf<ElementNotFoundException>());
            _salaryStorageContact.Verify(x => x.AddElement(It.IsAny<SalaryDataModel>()), Times.Never);
            _pekarStorageContact.Verify(x => x.GetElementById(salary.PekarId), Times.Once);
        }

        [Test]
        public void InsertSalary_RecordWithExistsData_ThrowException_Test()
        {
            // Arrange
            var salary = new SalaryDataModel(
                Guid.NewGuid().ToString(),
                Guid.NewGuid().ToString(),
                DateTime.Now,
                1000.00m,
                200.00m,
                1200.00m
            );
            _salaryStorageContact.Setup(x => x.AddElement(It.IsAny<SalaryDataModel>())).Throws(new ElementExistsException("ID", salary.Id));
            _pekarStorageContact.Setup(x => x.GetElementById(salary.PekarId)).Returns(new PekarDataModel(salary.PekarId, "Ivan Ivanov", "Baker", 1.5m, new List<ProductDataModel>()));

            // Act & Assert
            Assert.That(() => _salaryBusinessLogicContract.InsertSalary(salary), Throws.TypeOf<ElementExistsException>());
            _salaryStorageContact.Verify(x => x.AddElement(It.IsAny<SalaryDataModel>()), Times.Once);
            _pekarStorageContact.Verify(x => x.GetElementById(salary.PekarId), Times.Once);
        }

        [Test]
        public void InsertSalary_NullRecord_ThrowException_Test()
        {
            // Act & Assert
            Assert.That(() => _salaryBusinessLogicContract.InsertSalary(null), Throws.TypeOf<ArgumentNullException>());
            _salaryStorageContact.Verify(x => x.AddElement(It.IsAny<SalaryDataModel>()), Times.Never);
            _pekarStorageContact.Verify(x => x.GetElementById(It.IsAny<string>()), Times.Never);
        }

        [Test]
        public void InsertSalary_InvalidRecord_ThrowException_Test()
        {
            // Act & Assert
            Assert.That(() => _salaryBusinessLogicContract.InsertSalary(new SalaryDataModel(
                "", 
                "", 
                DateTime.Now,
                -1000.00m,
                -200.00m, 
                -1200.00m 
            )), Throws.TypeOf<ValidationException>());
            _salaryStorageContact.Verify(x => x.AddElement(It.IsAny<SalaryDataModel>()), Times.Never);
            _pekarStorageContact.Verify(x => x.GetElementById(It.IsAny<string>()), Times.Never);
        }

        [Test]
        public void InsertSalary_StorageThrowError_ThrowException_Test()
        {
            // Arrange
            var salary = new SalaryDataModel(
                Guid.NewGuid().ToString(),
                Guid.NewGuid().ToString(),
                DateTime.Now,
                1000.00m,
                200.00m,
                1200.00m
            );
            _salaryStorageContact.Setup(x => x.AddElement(It.IsAny<SalaryDataModel>())).Throws(new StorageException(new InvalidOperationException()));
            _pekarStorageContact.Setup(x => x.GetElementById(salary.PekarId)).Returns(new PekarDataModel(salary.PekarId, "Ivan Ivanov", "Baker", 1.5m, new List<ProductDataModel>()));

            // Act & Assert
            Assert.That(() => _salaryBusinessLogicContract.InsertSalary(salary), Throws.TypeOf<StorageException>());
            _salaryStorageContact.Verify(x => x.AddElement(It.IsAny<SalaryDataModel>()), Times.Once);
            _pekarStorageContact.Verify(x => x.GetElementById(salary.PekarId), Times.Once);
        }

        [Test]
        public void UpdateSalary_CorrectRecord_Test()
        {
            // Arrange
            var pekarId = Guid.NewGuid().ToString();
            var flag = false;
            var salary = new SalaryDataModel(
                Guid.NewGuid().ToString(),
                pekarId,
                DateTime.Now,
                1000.00m,
                200.00m,
                1200.00m
            );
            _salaryStorageContact.Setup(x => x.UpdateElement(It.IsAny<SalaryDataModel>()))
                .Callback((SalaryDataModel x) =>
                {
                    flag = x.Id == salary.Id && x.PekarId == salary.PekarId && x.Period == salary.Period &&
                           x.BaseRate == salary.BaseRate && x.BonusRate == salary.BonusRate && x.TotalSalary == salary.TotalSalary;
                });
            _pekarStorageContact.Setup(x => x.GetElementById(pekarId)).Returns(new PekarDataModel(pekarId, "Ivan Ivanov", "Baker", 1.5m, new List<ProductDataModel>()));

            // Act
            _salaryBusinessLogicContract.UpdateSalary(salary);

            // Assert
            _salaryStorageContact.Verify(x => x.UpdateElement(It.IsAny<SalaryDataModel>()), Times.Once);
            Assert.That(flag);
            Assert.That(Guid.TryParse(salary.Id, out _), Is.True);
            Assert.That(Guid.TryParse(salary.PekarId, out _), Is.True);
            Assert.That(salary.BaseRate >= 0);
            Assert.That(salary.BonusRate >= 0);
            Assert.That(salary.TotalSalary >= 0);
            _pekarStorageContact.Verify(x => x.GetElementById(pekarId), Times.Once);
        }

        [Test]
        public void UpdateSalary_PekarNotFound_ThrowException_Test()
        {
            // Arrange
            var salary = new SalaryDataModel(
                Guid.NewGuid().ToString(),
                Guid.NewGuid().ToString(),
                DateTime.Now,
                1000.00m,
                200.00m,
                1200.00m
            );
            _pekarStorageContact.Setup(x => x.GetElementById(salary.PekarId)).Returns((PekarDataModel)null);

            // Act & Assert
            Assert.That(() => _salaryBusinessLogicContract.UpdateSalary(salary), Throws.TypeOf<ElementNotFoundException>());
            _salaryStorageContact.Verify(x => x.UpdateElement(It.IsAny<SalaryDataModel>()), Times.Never);
            _pekarStorageContact.Verify(x => x.GetElementById(salary.PekarId), Times.Once);
        }

        [Test]
        public void UpdateSalary_RecordNotFound_ThrowException_Test()
        {
            // Arrange
            var salary = new SalaryDataModel(
                Guid.NewGuid().ToString(),
                Guid.NewGuid().ToString(),
                DateTime.Now,
                1000.00m,
                200.00m,
                1200.00m
            );
            _salaryStorageContact.Setup(x => x.UpdateElement(It.IsAny<SalaryDataModel>())).Throws(new ElementNotFoundException("Salary not found"));
            _pekarStorageContact.Setup(x => x.GetElementById(salary.PekarId)).Returns(new PekarDataModel(salary.PekarId, "Ivan Ivanov", "Baker", 1.5m, new List<ProductDataModel>()));

            // Act & Assert
            Assert.That(() => _salaryBusinessLogicContract.UpdateSalary(salary), Throws.TypeOf<ElementNotFoundException>());
            _salaryStorageContact.Verify(x => x.UpdateElement(It.IsAny<SalaryDataModel>()), Times.Once);
            _pekarStorageContact.Verify(x => x.GetElementById(salary.PekarId), Times.Once);
        }

        [Test]
        public void UpdateSalary_NullRecord_ThrowException_Test()
        {
            // Act & Assert
            Assert.That(() => _salaryBusinessLogicContract.UpdateSalary(null), Throws.TypeOf<ArgumentNullException>());
            _salaryStorageContact.Verify(x => x.UpdateElement(It.IsAny<SalaryDataModel>()), Times.Never);
            _pekarStorageContact.Verify(x => x.GetElementById(It.IsAny<string>()), Times.Never);
        }

        [Test]
        public void UpdateSalary_InvalidRecord_ThrowException_Test()
        {
            // Act & Assert
            Assert.That(() => _salaryBusinessLogicContract.UpdateSalary(new SalaryDataModel(
                "", 
                "", 
                DateTime.Now,
                -1000.00m,
                -200.00m, 
                -1200.00m 
            )), Throws.TypeOf<ValidationException>());
            _salaryStorageContact.Verify(x => x.UpdateElement(It.IsAny<SalaryDataModel>()), Times.Never);
            _pekarStorageContact.Verify(x => x.GetElementById(It.IsAny<string>()), Times.Never);
        }

        [Test]
        public void UpdateSalary_StorageThrowError_ThrowException_Test()
        {
            // Arrange
            var salary = new SalaryDataModel(
                Guid.NewGuid().ToString(),
                Guid.NewGuid().ToString(),
                DateTime.Now,
                1000.00m,
                200.00m,
                1200.00m
            );
            _salaryStorageContact.Setup(x => x.UpdateElement(It.IsAny<SalaryDataModel>())).Throws(new StorageException(new InvalidOperationException()));
            _pekarStorageContact.Setup(x => x.GetElementById(salary.PekarId)).Returns(new PekarDataModel(salary.PekarId, "Ivan Ivanov", "Baker", 1.5m, new List<ProductDataModel>()));

            // Act & Assert
            Assert.That(() => _salaryBusinessLogicContract.UpdateSalary(salary), Throws.TypeOf<StorageException>());
            _salaryStorageContact.Verify(x => x.UpdateElement(It.IsAny<SalaryDataModel>()), Times.Once);
            _pekarStorageContact.Verify(x => x.GetElementById(salary.PekarId), Times.Once);
        }

        [Test]
        public void DeleteSalary_CorrectId_Test()
        {
            // Arrange
            var id = Guid.NewGuid().ToString();
            var pekarId = Guid.NewGuid().ToString();
            var salary = new SalaryDataModel(
                id,
                pekarId,
                DateTime.Now,
                1000.00m,
                200.00m,
                1200.00m
            );
            var flag = false;
            _salaryStorageContact.Setup(x => x.GetElementById(id)).Returns(salary);
            _salaryStorageContact.Setup(x => x.DeleteElement(id)).Callback(() => { flag = true; });
            _pekarStorageContact.Setup(x => x.GetElementById(pekarId)).Returns(new PekarDataModel(pekarId, "Ivan Ivanov", "Baker", 1.5m, new List<ProductDataModel>()));

            // Act
            _salaryBusinessLogicContract.DeleteSalary(id);

            // Assert
            _salaryStorageContact.Verify(x => x.DeleteElement(id), Times.Once);
            Assert.That(flag);
            Assert.That(Guid.TryParse(salary.Id, out _), Is.True);
            Assert.That(Guid.TryParse(salary.PekarId, out _), Is.True);
            Assert.That(salary.BaseRate >= 0);
            Assert.That(salary.BonusRate >= 0);
            Assert.That(salary.TotalSalary >= 0);
        }

        [Test]
        public void DeleteSalary_RecordNotFound_ThrowException_Test()
        {
            // Arrange
            var id = Guid.NewGuid().ToString();
            _salaryStorageContact.Setup(x => x.GetElementById(id)).Returns((SalaryDataModel)null);

            // Act & Assert
            Assert.That(() => _salaryBusinessLogicContract.DeleteSalary(id), Throws.TypeOf<ElementNotFoundException>());
            _salaryStorageContact.Verify(x => x.GetElementById(id), Times.Once);
        }

        [Test]
        public void DeleteSalary_NullOrEmptyId_ThrowException_Test()
        {
            // Act & Assert
            Assert.That(() => _salaryBusinessLogicContract.DeleteSalary(null), Throws.TypeOf<ArgumentNullException>());
            Assert.That(() => _salaryBusinessLogicContract.DeleteSalary(string.Empty), Throws.TypeOf<ArgumentNullException>());
            _salaryStorageContact.Verify(x => x.DeleteElement(It.IsAny<string>()), Times.Never);
        }

        [Test]
        public void DeleteSalary_InvalidId_ThrowException_Test()
        {
            // Arrange
            var id = "invalid";

            // Act & Assert
            Assert.That(() => _salaryBusinessLogicContract.DeleteSalary(id), Throws.TypeOf<ValidationException>());
            _salaryStorageContact.Verify(x => x.DeleteElement(id), Times.Never);
            _salaryStorageContact.Verify(x => x.GetElementById(id), Times.Never);
        }

        [Test]
        public void DeleteSalary_StorageThrowError_ThrowException_Test()
        {
            // Arrange
            var id = Guid.NewGuid().ToString();
            var pekarId = Guid.NewGuid().ToString();
            var salary = new SalaryDataModel(id, pekarId, DateTime.Now, 1000.00m, 200.00m, 1200.00m);
            _salaryStorageContact.Setup(x => x.GetElementById(id)).Returns(salary);
            _salaryStorageContact.Setup(x => x.DeleteElement(id)).Throws(new StorageException(new InvalidOperationException()));
            _pekarStorageContact.Setup(x => x.GetElementById(pekarId)).Returns(new PekarDataModel(pekarId, "Ivan Ivanov", "Baker", 1.5m, new List<ProductDataModel>()));

            // Act & Assert
            Assert.That(() => _salaryBusinessLogicContract.DeleteSalary(id), Throws.TypeOf<StorageException>());
            _salaryStorageContact.Verify(x => x.GetElementById(id), Times.Once);
            _salaryStorageContact.Verify(x => x.DeleteElement(id), Times.Once);
        }
    }
}