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 GetList_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.GetList();

            // 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);
        }

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

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

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

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

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

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

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

        [Test]
        public void GetElementById_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.GetElementById(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(It.IsAny<string>()), Times.Once);
        }

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

        [Test]
        public void GetElementById_NotFoundSalary_ThrowException_Test()
        {
            // Arrange
            var id = "nonexistent";
            _salaryStorageContact.Setup(x => x.GetElementById(id)).Returns((SalaryDataModel)null);

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

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

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

        [Test]
        public void AddElement_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.AddElement(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);
        }

        [Test]
        public void AddElement_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));

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

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

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

        [Test]
        public void AddElement_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()));

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

        [Test]
        public void UpdateElement_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.UpdateElement(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);
        }

        [Test]
        public void UpdateElement_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"));

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

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

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

        [Test]
        public void UpdateElement_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()));

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

        [Test]
        public void DeleteElement_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.DeleteElement(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 DeleteElement_RecordNotFound_ThrowException_Test()
        {
            // Arrange
            var id = "nonexistent";
            _salaryStorageContact.Setup(x => x.GetElementById(id)).Returns((SalaryDataModel)null);

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

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

        [Test]
        public void DeleteElement_InvalidId_ThrowException_Test()
        {
            // Act & Assert
            Assert.That(() => _salaryBusinessLogicContract.DeleteElement("invalid"), Throws.TypeOf<ValidationException>());
            _salaryStorageContact.Verify(x => x.DeleteElement(It.IsAny<string>()), Times.Never);
        }

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

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