Install-Package NUnit;
Install-Package NUnit3TestAdapter;
Install-Package Microsoft.Net.Test.Sdk;
Install-Package Moq;

using Moq;
using NUnit.Framework;
using NUnit.Framework.Legacy;

namespace ConsoleApp21
{ 
    [TestFixture]
    public class CalculatorTests
    {
        private Calculator calculator;

        [SetUp]
        public void SetUp()
        {
            calculator = new Calculator();
        }

        [Test]
        public void Add_TwoNumbers_ReturnsSum()
        {
            int a = 5, b = 3;
            int result=calculator.Add(a, b);
            Assert.That(result, Is.EqualTo(8));
        }

        [Test]
        public void Subtract_TwoNumbers_ReturnsDifference()
        {
            int result = calculator.Subtract(10, 5);
            Assert.That(result, Is.EqualTo(5));
        }

        [Test]
        public void Divide_ByZero_ThrowDividedByZeroException()
        {
            Assert.Throws<DivideByZeroException>(() =>
            {
                calculator.Divide(10, 0);
            });
        }

        [TearDown]
        public void TearDown()
        {
            calculator = null;
        }
    }

    public class Calculator
    {
        public int Add(int a, int b) => a + b;
        public int Subtract(int a,int b)=> a - b;
        public int Divide(int a, int b) => a / b;

        public int Multiply(int a, int b) => a * b;

    }

    [TestFixture]
    public class AdvancedTests
    {
        [Test]
        public void StringAssert_Example()
        {
            string actual = "hello world";
            StringAssert.Contains("hello", actual);
            StringAssert.StartsWith("hello", actual);
            StringAssert.EndsWith("world", actual);
        }

        [Test]
        public void CollectionAssert_Example()
        {
            var expected = new List<int> { 1, 2, 3 };
            var actual = new List<int> { 1, 2, 3 };

            CollectionAssert.AreEqual(expected, actual);
            CollectionAssert.AllItemsAreUnique(actual);
            CollectionAssert.IsSubsetOf(new List<int> { 1, 2 }, actual);
        }

        [Test]
        public void MultipleAssert_Example()
        {
            var person = new Person { Name = "Fred", Age = 16 };
            Assert.Multiple(() =>
            {
                Assert.That(person.Name, Is.EqualTo("Fred"));
                Assert.That(person.Age,Is.GreaterThan(14));
                Assert.That(person.Age,Is.LessThan(17));
            });
        }
    }

    public class Person
    {
        public string Name { get; set; }
        public int Age { get; set;  }
    }


    [TestFixture]
    public class ParameterizedTests
    {
        [TestCase(1,1,2)]
        [TestCase(2,3,5)]
        [TestCase(-1,-1,-2)]
        [TestCase(0,0,0)]
        public void Add_VariousNumbers_ReturnsCorrectNum(int a,int b,int expected)
        {
            var calculator=new Calculator();
            int result=calculator.Add(a,b); 
            Assert.That(result, Is.EqualTo(expected));
        }

        [TestCaseSource(nameof(TestData))]
        public void Multiply_VariousNumbers_ReturnsCorrectProduct(int a,int b,int expected)
        {
            var calculator = new Calculator();
            int result = calculator.Multiply(a, b);
            Assert.That(result, Is.EqualTo(expected));
        }

        private static object[] TestData =
        {
            new object[]{2,3,6},
            new object[]{5,0,0},
            new object[]{-2,4,-8}
        };
    }

    [TestFixture]
    public class AsyncTests
    {
        [Test]
        public async Task GetDataAsync_ReturnsExpectedData()
        {
            var service = new DataService();
            var result = await service.GetDataAsync();
            Assert.That(result, Is.EqualTo("hello world"));
        }

        [Test]
        public async Task CalculateAsync_WithValidInput_ReturnsCorrectValue()
        {
            var service = new DataService();
            int result = await service.CalculateSumAsync(5, 3);
            Assert.That(result, Is.EqualTo(8));
        }
    }

    public class DataService
    {
        public async Task<string> GetDataAsync()
        {
            await Task.Delay(100);
            return "hello world";
        }

        public async Task<int> CalculateSumAsync(int a,int b)
        {
            await Task.Delay(50);
            return a + b;
        }
    }


    [TestFixture]
    public class MockingTests
    {
        [Test]
        public void UserService_GetUser_ReturnsUserFromRepository()
        {
            var mockRepo = new Mock<IUserRepository>();
            var expectedUser = new User { Id = 1, Name = "Fred" };
            mockRepo.Setup(repo => repo.GetUser(1)).Returns(expectedUser);
            var userService = new UserService(mockRepo.Object);
            var result = userService.GetUser(1);
            Assert.That(result, Is.EqualTo(expectedUser));
            mockRepo.Verify(repo => repo.GetUser(1), Times.Once);
        }

        [Test]
        public void EmailService_SendEmail_CallsRepository()
        {
            var mockRepo = new Mock<IEmailRepository>();
            var emailService = new EmailService(mockRepo.Object);
            var email = "test@example.com";
            var message = "hello";
            emailService.SendEmail(email, message);
            mockRepo.Verify(repo => repo.SaveMail(It.Is<string>(x => x == email),
                It.Is<string>(m => m.Contains("hello"))),
                Times.Once);
        }
    }

    public interface IUserRepository
    {
        User GetUser(int id);
    }

    public interface IEmailRepository
    {
        void SaveMail(string email, string message);
    }

    public class UserService
    {
        private readonly IUserRepository repository;
        public UserService(IUserRepository repositoryValue)
        {
            repository = repositoryValue;
        }

        public User GetUser(int id)
        {
           return  repository.GetUser(id);
        }
    }

    public class EmailService
    {
        private readonly IEmailRepository repository;
        public EmailService(IEmailRepository repositoryValue)
        {
            repository = repositoryValue;
        }

        public void SendEmail(string email,string message)
        {
            repository.SaveMail(email, message);
        }
    }


    public class User
    {
        public int Id { get; set; }
        public string Name { get; set; }
    }
}