using FabApprovalWorkerService.Models;
using FabApprovalWorkerService.Services;

using Microsoft.Extensions.Logging;

using Moq;

namespace FabApprovalWorkerServiceTests;
internal class ECNServiceTests {
    Mock<ILogger<ECNService>> _mockLogger;
    Mock<IDalService> _mockDalService;

    ECNService _ecnService;

    [SetUp]
    public void Setup() {
        _mockLogger = new Mock<ILogger<ECNService>>();
        _mockDalService = new Mock<IDalService>();
    }

    [Test]
    public void EcnServiceWithNullLoggerShouldThrowException() {
        Assert.Throws<ArgumentNullException>(() => new ECNService(null, _mockDalService.Object));
    }

    [Test]
    public void EcnServiceWithNullDalServiceShouldThrowException() {
        Assert.Throws<ArgumentNullException>(() => new ECNService(_mockLogger.Object, null));
    }

    [Test]
    public void GetExpiringTECNsWithDbErrorShouldThrowException() {
        _mockDalService.Setup(d => d.QueryAsync<ECN>(It.IsAny<string>())).ThrowsAsync(new Exception());

        _ecnService = new ECNService(_mockLogger.Object, _mockDalService.Object);

        Assert.ThrowsAsync<Exception>(async Task () => await _ecnService.GetExpiringTECNs());
    }

    [Test]
    public void GetExpiredTECNsWithDbErrorShouldThrowException() {
        _mockDalService.Setup(d => d.QueryAsync<ECN>(It.IsAny<string>())).ThrowsAsync(new Exception());

        _ecnService = new ECNService(_mockLogger.Object, _mockDalService.Object);

        Assert.ThrowsAsync<Exception>(async Task () => await _ecnService.GetExpiredTECNsInPastDay());
    }

    [Test]
    public async Task GetExpiringTECNsWithNoResultsFromDbShouldReturnEmpty() {
        IEnumerable<ECN> emptyEcns = new List<ECN>();

        _mockDalService.Setup(d => d.QueryAsync<ECN>(It.IsAny<string>())).Returns(Task.FromResult(emptyEcns));

        _ecnService = new ECNService(_mockLogger.Object, _mockDalService.Object);

        IEnumerable<ECN> actual = await _ecnService.GetExpiringTECNs();

        Assert.That(actual, Is.Empty);
    }

    [Test]
    public async Task GetExpiredTECNsWithNoResultsFromDbShouldReturnEmpty() {
        IEnumerable<ECN> emptyEcns = new List<ECN>();

        _mockDalService.Setup(d => d.QueryAsync<ECN>(It.IsAny<string>())).Returns(Task.FromResult(emptyEcns));

        _ecnService = new ECNService(_mockLogger.Object, _mockDalService.Object);

        IEnumerable<ECN> actual = await _ecnService.GetExpiredTECNsInPastDay();

        Assert.That(actual, Is.Empty);
    }

    [Test]
    public async Task GetExpiringTECNsWithNoExtensionFromDbShouldReturnSameResults() {
        IEnumerable<ECN> ecns = new List<ECN>() {
            new ECN() {
                ECNNumber = 1,
                OriginatorID = 1,
                Title = "title1",
                IsTECN = true,
                ExpirationDate = DateTime.Now.AddDays(1)
            },
            new ECN() {
                ECNNumber = 2,
                OriginatorID = 1,
                Title = "title2",
                IsTECN = true,
                ExpirationDate = DateTime.Now.AddDays(2)
            },
            new ECN() {
                ECNNumber = 3,
                OriginatorID = 1,
                Title = "title3",
                IsTECN = true,
                ExpirationDate = DateTime.Now.AddDays(3)
            },
        };

        _mockDalService.Setup(d => d.QueryAsync<ECN>(It.IsAny<string>())).Returns(Task.FromResult(ecns));

        _ecnService = new ECNService(_mockLogger.Object, _mockDalService.Object);

        IEnumerable<ECN> actual = await _ecnService.GetExpiringTECNs();

        Assert.That(actual.Count(), Is.EqualTo(3));
    }

    [Test]
    public async Task GetExpiredTECNsWithNoExtensionFromDbShouldReturnSameResults() {
        IEnumerable<ECN> ecns = new List<ECN>() {
            new ECN() {
                ECNNumber = 1,
                OriginatorID = 1,
                Title = "title1",
                IsTECN = true,
                ExpirationDate = DateTime.Now.Date.AddHours(2)
            },
            new ECN() {
                ECNNumber = 2,
                OriginatorID = 1,
                Title = "title2",
                IsTECN = true,
                ExpirationDate = DateTime.Now.Date.AddHours(20)
            },
            new ECN() {
                ECNNumber = 3,
                OriginatorID = 1,
                Title = "title3",
                IsTECN = true,
                ExpirationDate = DateTime.Now.Date.AddHours(12)
            },
        };

        _mockDalService.Setup(d => d.QueryAsync<ECN>(It.IsAny<string>())).Returns(Task.FromResult(ecns));

        _ecnService = new ECNService(_mockLogger.Object, _mockDalService.Object);

        IEnumerable<ECN> actual = await _ecnService.GetExpiredTECNsInPastDay();

        Assert.That(actual.Count(), Is.EqualTo(3));
    }

    [Test]
    public async Task GetExpiringTECNsWithExtensionsFromDbShouldReturnSameResults() {
        IEnumerable<ECN> ecns = new List<ECN>() {
            new ECN() {
                ECNNumber = 1,
                OriginatorID = 1,
                Title = "title1",
                IsTECN = true,
                ExpirationDate = DateTime.Now.AddDays(1)
            },
            new ECN() {
                ECNNumber = 2,
                OriginatorID = 1,
                Title = "title2",
                IsTECN = true,
                ExpirationDate = DateTime.Now.AddDays(2)
            },
            new ECN() {
                ECNNumber = 3,
                OriginatorID = 1,
                Title = "title3",
                IsTECN = true,
                ExpirationDate = DateTime.Now.AddDays(3),
                ExtensionDate = DateTime.Now.AddDays(10)
            },
        };

        _mockDalService.Setup(d => d.QueryAsync<ECN>(It.IsAny<string>())).Returns(Task.FromResult(ecns));

        _ecnService = new ECNService(_mockLogger.Object, _mockDalService.Object);

        IEnumerable<ECN> actual = await _ecnService.GetExpiringTECNs();

        Assert.That(actual.Count(), Is.EqualTo(2));
    }

    [Test]
    public async Task GetExpiredTECNsWithExtensionsFromDbShouldReturnSameResults() {
        IEnumerable<ECN> ecns = new List<ECN>() {
            new ECN() {
                ECNNumber = 1,
                OriginatorID = 1,
                Title = "title1",
                IsTECN = true,
                ExpirationDate = DateTime.Now.Date.AddHours(2)
            },
            new ECN() {
                ECNNumber = 2,
                OriginatorID = 1,
                Title = "title2",
                IsTECN = true,
                ExpirationDate = DateTime.Now.Date.AddHours(20)
            },
            new ECN() {
                ECNNumber = 3,
                OriginatorID = 1,
                Title = "title3",
                IsTECN = true,
                ExpirationDate = DateTime.Now.Date.AddHours(12),
                ExtensionDate = DateTime.Now.Date.AddDays(10)
            },
        };

        _mockDalService.Setup(d => d.QueryAsync<ECN>(It.IsAny<string>())).Returns(Task.FromResult(ecns));

        _ecnService = new ECNService(_mockLogger.Object, _mockDalService.Object);

        IEnumerable<ECN> actual = await _ecnService.GetExpiredTECNsInPastDay();

        Assert.That(actual.Count(), Is.EqualTo(2));
    }

    [Test]
    public void GetTECNNotificationUserEmailsDbErrorShouldThrowException() {
        _mockDalService.Setup(d => d.QueryAsync<string>(It.IsAny<string>())).Throws(new Exception());

        _ecnService = new ECNService(_mockLogger.Object, _mockDalService.Object);

        Assert.ThrowsAsync<Exception>(async Task () => await _ecnService.GetTECNNotificationUserEmails());
    }

    [Test]
    public async Task GetTECNNotificationUserEmailsShouldReturnExpectedUserEmails() {
        IEnumerable<string> userEmails = new List<string>() {
            "fake1@email.com",
            "fake2@email.com"
        };

        _mockDalService.Setup(d => d.QueryAsync<string>(It.IsAny<string>())).Returns(Task.FromResult(userEmails));

        _ecnService = new ECNService(_mockLogger.Object, _mockDalService.Object);

        IEnumerable<string> actualEmails = await _ecnService.GetTECNNotificationUserEmails();

        Assert.That(actualEmails.Count(), Is.EqualTo(2));
    }

    [Test]
    public void GetEcnByNumberWithInvalidNumberShouldThrowException() {
        _ecnService = new ECNService(_mockLogger.Object, _mockDalService.Object);

        Assert.ThrowsAsync<ArgumentException>(async Task () => await _ecnService.GetEcnByNumber(0));

        Assert.ThrowsAsync<ArgumentException>(async Task () => await _ecnService.GetEcnByNumber(-4));
    }

    [Test]
    public void GetEcnByNumberDbErrorShouldThrowException() {
        _mockDalService.Setup(d => d.QueryAsync<ECN>(It.IsAny<string>())).Throws(new Exception());

        _ecnService = new ECNService(_mockLogger.Object, _mockDalService.Object);

        Assert.ThrowsAsync<Exception>(async Task () => await _ecnService.GetEcnByNumber(2));
    }

    [Test]
    public void GetEcnByNumberEcnNotFoundShouldThrowException() {
        IEnumerable<ECN> expectedEcns = new List<ECN>();

        _mockDalService.Setup(d => d.QueryAsync<ECN>(It.IsAny<string>())).Returns(Task.FromResult(expectedEcns));

        _ecnService = new ECNService(_mockLogger.Object, _mockDalService.Object);

        Assert.ThrowsAsync<Exception>(async Task () => await _ecnService.GetEcnByNumber(8));
    }

    [Test]
    public async Task GetEcnByNumberShouldReturnExpectedEcn() {
        IEnumerable<ECN> expectedEcns = new List<ECN>() {
            new ECN() {
                ECNNumber = 1,
                OriginatorID = 1,
                Title = "title",
                ExpirationDate = DateTime.Now
            }
        };

        _mockDalService.Setup(d => d.QueryAsync<ECN>(It.IsAny<string>())).Returns(Task.FromResult(expectedEcns));

        _ecnService = new ECNService(_mockLogger.Object, _mockDalService.Object);

        ECN actualEcn = await _ecnService.GetEcnByNumber(9);

        Assert.That(expectedEcns.First(), Is.EqualTo(actualEcn));
    }

    [Test]
    public void EcnIsExpiredNullEcnShouldThrowException() {
        _ecnService = new ECNService(_mockLogger.Object, _mockDalService.Object);

        Assert.Throws<ArgumentNullException>(() => _ecnService.EcnIsExpired(null));
    }

    [Test]
    public void EcnIsExpiredShouldReturnTrueWhenBeforeToday() {
        ECN ecn = new ECN() {
            ECNNumber = 1,
            OriginatorID = 1,
            Title = "title",
            ExpirationDate = DateTime.Now.Date.AddDays(-2),
            IsTECN = true
        };

        _ecnService = new ECNService(_mockLogger.Object, _mockDalService.Object);

        bool isExpired = _ecnService.EcnIsExpired(ecn);

        Assert.True(isExpired);
    }

    [Test]
    public void EcnIsExpiredShouldReturnTrueWhenToday() {
        ECN ecn = new ECN() {
            ECNNumber = 1,
            OriginatorID = 1,
            Title = "title",
            ExpirationDate = DateTime.Now.Date,
            IsTECN = true
        };

        _ecnService = new ECNService(_mockLogger.Object, _mockDalService.Object);

        bool isExpired = _ecnService.EcnIsExpired(ecn);

        Assert.True(isExpired);
    }

    [Test]
    public void EcnIsExpiredShouldReturnFalseWhenAfterToday() {
        ECN ecn = new ECN() {
            ECNNumber = 1,
            OriginatorID = 1,
            Title = "title",
            ExpirationDate = DateTime.Now.Date.AddDays(2),
            IsTECN = true
        };

        _ecnService = new ECNService(_mockLogger.Object, _mockDalService.Object);

        bool isExpired = _ecnService.EcnIsExpired(ecn);

        Assert.False(isExpired);
    }

    [Test]
    public void EcnIsExpiredShouldReturnFalseWhenExtended() {
        ECN ecn = new ECN() {
            ECNNumber = 1,
            OriginatorID = 1,
            Title = "title",
            ExpirationDate = DateTime.Now.Date.AddDays(-2),
            ExtensionDate = DateTime.Now.Date.AddDays(5),
            IsTECN = true
        };

        _ecnService = new ECNService(_mockLogger.Object, _mockDalService.Object);

        bool isExpired = _ecnService.EcnIsExpired(ecn);

        Assert.False(isExpired);
    }

    [Test]
    public void EcnIsExpiredShouldReturnTrueWhenExtensionIsBeforeToday() {
        ECN ecn = new ECN() {
            ECNNumber = 1,
            OriginatorID = 1,
            Title = "title",
            ExpirationDate = DateTime.Now.Date.AddDays(-10),
            ExtensionDate = DateTime.Now.Date.AddDays(-5),
            IsTECN = true
        };

        _ecnService = new ECNService(_mockLogger.Object, _mockDalService.Object);

        bool isExpired = _ecnService.EcnIsExpired(ecn);

        Assert.True(isExpired);
    }

    [Test]
    public void EcnIsExpiredShouldReturnFalseWhenNotTecn() {
        ECN ecn = new ECN() {
            ECNNumber = 1,
            OriginatorID = 1,
            Title = "title",
            ExpirationDate = DateTime.Now.Date.AddDays(-2),
            IsTECN = false
        };

        _ecnService = new ECNService(_mockLogger.Object, _mockDalService.Object);

        bool isExpired = _ecnService.EcnIsExpired(ecn);

        Assert.False(isExpired);
    }

    [Test]
    public void EcnIsExpiredShouldReturnFalseWhenClosed() {
        ECN ecn = new ECN() {
            ECNNumber = 1,
            OriginatorID = 1,
            Title = "title",
            ExpirationDate = DateTime.Now.Date.AddDays(-2),
            IsTECN = false,
            CloseDate = DateTime.Now.AddDays(-2)
        };

        _ecnService = new ECNService(_mockLogger.Object, _mockDalService.Object);

        bool isExpired = _ecnService.EcnIsExpired(ecn);

        Assert.False(isExpired);
    }

    [Test]
    public void EcnIsExpiredShouldReturnTrueWhenNotClosed() {
        ECN ecn = new ECN() {
            ECNNumber = 1,
            OriginatorID = 1,
            Title = "title",
            ExpirationDate = DateTime.Now.Date.AddDays(-2),
            IsTECN = true
        };

        _ecnService = new ECNService(_mockLogger.Object, _mockDalService.Object);

        bool isExpired = _ecnService.EcnIsExpired(ecn);

        Assert.True(isExpired);
    }
}