Exam

using NUnit.Framework;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using GardenConsoleAPI.Business;
using GardenConsoleAPI.Business.Contracts;
using GardenConsoleAPI.DataAccess;
using GardenConsoleAPI.Data.Models;

namespace GardenConsoleAPI.IntegrationTests.NUnit
{
    public class IntegrationTests
    {
        private TestPlantsDbContext dbContext;
        private IPlantsManager plantsManager;

        [SetUp]
        public void SetUp()
        {
            this.dbContext = new TestPlantsDbContext();
            this.plantsManager = new PlantsManager(new PlantsRepository(this.dbContext));
        }

        [TearDown]
        public void TearDown()
        {
            this.dbContext.Database.EnsureDeleted();
            this.dbContext.Dispose();
        }

        [Test]
        public async Task AddPlantAsync_ShouldAddNewPlant()
        {
            // Arrange
            var plant = new Plant
            {
                CatalogNumber = "001",
                Name = "Rose",
                Type = "Flower",
                FoodType = "Nectar"
            };

            // Act
            await this.plantsManager.AddPlantAsync(plant);

            // Assert
            var retrievedPlant = await this.plantsManager.GetSpecificAsync("001");
            Assert.IsNotNull(retrievedPlant);
            Assert.AreEqual("Rose", retrievedPlant.Name);
        }

        [Test]
        public async Task AddPlantAsync_TryToAddPlantWithInvalidCredentials_ShouldThrowException()
        {
            // Arrange
            var invalidPlant = new Plant(); // Not providing required properties

            // Act & Assert
            Assert.ThrowsAsync<Exception>(async () => await this.plantsManager.AddPlantAsync(invalidPlant));
        }

        [Test]
        public async Task DeletePlantAsync_WithValidCatalogNumber_ShouldRemovePlantFromDb()
        {
            // Arrange
            var plant = new Plant
            {
                CatalogNumber = "001",
                Name = "Rose",
                Type = "Flower",
                FoodType = "Nectar"
            };
            await this.plantsManager.AddPlantAsync(plant);

            // Act
            await this.plantsManager.DeletePlantAsync("001");

            // Assert
            Assert.ThrowsAsync<KeyNotFoundException>(async () => await this.plantsManager.GetSpecificAsync("001"));
        }

        [Test]
        public async Task DeletePlantAsync_TryToDeleteWithNullOrWhiteSpaceCatalogNumber_ShouldThrowException()
        {
            // Arrange & Act & Assert
            Assert.ThrowsAsync<ArgumentNullException>(async () => await this.plantsManager.DeletePlantAsync(null));
            Assert.ThrowsAsync<ArgumentNullException>(async () => await this.plantsManager.DeletePlantAsync(""));
            Assert.ThrowsAsync<ArgumentNullException>(async () => await this.plantsManager.DeletePlantAsync(" "));
        }

        [Test]
        public async Task GetAllAsync_WhenPlantsExist_ShouldReturnAllPlants()
        {
            // Arrange
            var plant1 = new Plant { CatalogNumber = "001", Name = "Rose", Type = "Flower", FoodType = "Nectar" };
            var plant2 = new Plant { CatalogNumber = "002", Name = "Carrot", Type = "Vegetable", FoodType = "Roots" };
            await this.plantsManager.AddPlantAsync(plant1);
            await this.plantsManager.AddPlantAsync(plant2);

            // Act
            var plants = await this.plantsManager.GetAllAsync();

            // Assert
            Assert.IsNotNull(plants);
            Assert.AreEqual(2, plants.Count());
            Assert.IsTrue(plants.Any(p => p.CatalogNumber == "001"));
            Assert.IsTrue(plants.Any(p => p.CatalogNumber == "002"));
        }

        [Test]
        public async Task GetAllAsync_WhenNoPlantsExist_ShouldThrowKeyNotFoundException()
        {
            // Arrange & Act & Assert
            Assert.ThrowsAsync<KeyNotFoundException>(async () => await this.plantsManager.GetAllAsync());
        }

        [Test]
        public async Task SearchByFoodTypeAsync_WithExistingFoodType_ShouldReturnMatchingPlants()
        {
            // Arrange
            var plant1 = new Plant { CatalogNumber = "001", Name = "Rose", Type = "Flower", FoodType = "Nectar" };
            var plant2 = new Plant { CatalogNumber = "002", Name = "Carrot", Type = "Vegetable", FoodType = "Roots" };
            await this.plantsManager.AddPlantAsync(plant1);
            await this.plantsManager.AddPlantAsync(plant2);

            // Act
            var plants = await this.plantsManager.SearchByFoodTypeAsync("Roots");

            // Assert
            Assert.IsNotNull(plants);
            Assert.AreEqual(1, plants.Count());
            Assert.AreEqual("Carrot", plants.First().Name);
        }

        [Test]
        public async Task SearchByFoodTypeAsync_WithNonExistingFoodType_ShouldThrowKeyNotFoundException()
        {
            // Arrange & Act & Assert
            Assert.ThrowsAsync<KeyNotFoundException>(async () => await this.plantsManager.SearchByFoodTypeAsync("Seeds"));
        }

        [Test]
        public async Task GetSpecificAsync_WithValidCatalogNumber_ShouldReturnPlant()
        {
            // Arrange
            var plant = new Plant { CatalogNumber = "001", Name = "Rose", Type = "Flower", FoodType = "Nectar" };
            await this.plantsManager.AddPlantAsync(plant);

            // Act
            var retrievedPlant = await this.plantsManager.GetSpecificAsync("001");

            // Assert
            Assert.IsNotNull(retrievedPlant);
            Assert.AreEqual("Rose", retrievedPlant.Name);
        }

        [Test]
        public async Task GetSpecificAsync_WithInvalidCatalogNumber_ShouldThrowKeyNotFoundException()
        {
            // Arrange & Act & Assert
            Assert.ThrowsAsync<KeyNotFoundException>(async () => await this.plantsManager.GetSpecificAsync("999"));
        }

        [Test]
        public async Task UpdateAsync_WithValidPlant_ShouldUpdatePlant()
        {
            // Arrange
            var plant = new Plant { CatalogNumber = "001", Name = "Rose", Type = "Flower", FoodType = "Nectar" };
            await this.plantsManager.AddPlantAsync(plant);

            // Act
            plant.Name = "Lily";
            await this.plantsManager.UpdateAsync(plant);

            // Assert
            var retrievedPlant = await this.plantsManager.GetSpecificAsync("001");
            Assert.IsNotNull(retrievedPlant);
            Assert.AreEqual("Lily", retrievedPlant.Name);
        }

        [Test]
        public async Task UpdateAsync_WithInvalidPlant_ShouldThrowValidationException()
        {
            // Arrange
            var invalidPlant = new Plant(); // Not providing required properties

            // Act & Assert
            Assert.ThrowsAsync<Exception>(async () => await this.plantsManager.UpdateAsync(invalidPlant));
        }
    }
}