using Microsoft.AspNetCore.Mvc;
using LCU.Library.Internal.LoanRateModels.Entities;
using LCU.API.Internal.LoanRate.Controllers;
using LCU.API.Internal.LoanRate.Services;
namespace LCU.API.Internal.LoanRateTests.ControllerTests;

public class RateControllerTest
{
    private readonly Mock<IRateService> _mockRateService;
    private readonly RateController _controller;

    public RateControllerTest()
    {
        _mockRateService = new Mock<IRateService>();
        _controller = new RateController(_mockRateService.Object);
    }

    [Fact]
    public async void Rate_Get_OK()
    {
        var rateId = 1;
        var rates = new List<Rate>
        {
            new()
            {
                RateId = rateId
            }
        };

        _mockRateService.Setup(x => x.GetAsync()).ReturnsAsync(rates).Verifiable();

        var result = await _controller.Get();
        Assert.NotNull(result);

        Assert.IsType<OkObjectResult>(result);
        var status = result as OkObjectResult;
        Assert.NotNull(status);
        Assert.Equal(200, status.StatusCode);

        var RateResult = status.Value as List<Rate>;
        Assert.NotNull(RateResult);
        Assert.Single(RateResult);
        Assert.Equal(rateId, RateResult.First().RateId);
        _mockRateService.Verify();
    }

    [Fact]
    public async void Rate_Get_NoContent()
    {
        var rates = new List<Rate>();

        _mockRateService.Setup(x => x.GetAsync()).ReturnsAsync(rates).Verifiable();

        var result = await _controller.Get();
        Assert.NotNull(result);

        Assert.IsType<NoContentResult>(result);
        var status = result as NoContentResult;
        Assert.NotNull(status);
        Assert.Equal(204, status.StatusCode);
        _mockRateService.Verify();
    }

    [Fact]
    public async void Rate_Get_InternalServerError()
    {
        _mockRateService.Setup(x => x.GetAsync())
            .Throws(new Exception("Test")).Verifiable();

        var result = await _controller.Get();
        Assert.NotNull(result);

        Assert.IsType<StatusCodeResult>(result);
        var status = result as StatusCodeResult;
        Assert.NotNull(status);
        Assert.Equal(500, status.StatusCode);
        _mockRateService.Verify();
    }

    [Fact]
    public async void Rate_GetById_OK()
    {
        var rateId = 1;
        var rate = new Rate
        {
            RateId = rateId
        };

        _mockRateService.Setup(x => x.GetByIdAsync(rateId))
            .ReturnsAsync(rate).Verifiable();

        var result = await _controller.GetById(rateId);
        Assert.NotNull(result);

        Assert.IsType<OkObjectResult>(result);
        var status = result as OkObjectResult;
        Assert.NotNull(status);
        Assert.Equal(200, status.StatusCode);

        var RateResult = status.Value as Rate;
        Assert.NotNull(RateResult);
        Assert.Equal(rateId, RateResult.RateId);
        _mockRateService.Verify();
    }

    [Fact]
    public async void Rate_GetById_NoContent()
    {
        var rateId = 1;
        Rate? rate = null;

        _mockRateService.Setup(x => x.GetByIdAsync(rateId))
            .ReturnsAsync(rate).Verifiable();

        var result = await _controller.GetById(rateId);
        Assert.NotNull(result);

        Assert.IsType<NoContentResult>(result);
        var status = result as NoContentResult;
        Assert.NotNull(status);
        Assert.Equal(204, status.StatusCode);
        _mockRateService.Verify();
    }

    [Fact]
    public async void Rate_GetById_BadRequest()
    {
        var rateId = 0;

        var result = await _controller.GetById(rateId);
        Assert.NotNull(result);

        Assert.IsType<BadRequestObjectResult>(result);
        var status = result as BadRequestObjectResult;
        Assert.NotNull(status);
        Assert.Equal(400, status.StatusCode);
    }

    [Fact]
    public async void Rate_GetById_InternalServerError()
    {
        var rateId = 1;
        _mockRateService.Setup(x => x.GetByIdAsync(rateId))
            .Throws(new Exception("Test")).Verifiable();

        var result = await _controller.GetById(rateId);
        Assert.NotNull(result);

        Assert.IsType<StatusCodeResult>(result);
        var status = result as StatusCodeResult;
        Assert.NotNull(status);
        Assert.Equal(500, status.StatusCode);
        _mockRateService.Verify();
    }

    [Fact]
    public async void Rate_GetListById_OK()
    {
        var rateIds = new List<int>
        {
            1,
            2,
            3
        };
        var rates = new List<Rate>
        {
            new() { RateId = rateIds[0] },
            new() { RateId = rateIds[1] },
            new() { RateId = rateIds[2] }
        };

        _mockRateService.Setup(x => x.GetRangeByIdAsync(rateIds))
            .ReturnsAsync(rates).Verifiable();

        var result = await _controller.GetListById(rateIds);
        Assert.NotNull(result);

        Assert.IsType<OkObjectResult>(result);
        var status = result as OkObjectResult;
        Assert.NotNull(status);
        Assert.Equal(200, status.StatusCode);

        var rateResult = status.Value as List<Rate>;
        Assert.NotNull(rateResult);
        Assert.Equal(rateIds[0], rateResult[0].RateId);
        Assert.Equal(rateIds[1], rateResult[1].RateId);
        Assert.Equal(rateIds[2], rateResult[2].RateId);
        _mockRateService.Verify();
    }

    [Fact]
    public async void Rate_GetListById_NoContent()
    {
        var rateIds = new List<int>
        {
            1,
            2,
            3
        };
        List<Rate>? rates = null;

        _mockRateService.Setup(x => x.GetRangeByIdAsync(rateIds))
            .ReturnsAsync(rates).Verifiable();

        var result = await _controller.GetListById(rateIds);
        Assert.NotNull(result);

        Assert.IsType<NoContentResult>(result);
        var status = result as NoContentResult;
        Assert.NotNull(status);
        Assert.Equal(204, status.StatusCode);
        _mockRateService.Verify();
    }

    [Fact]
    public async void Rate_GetListById_BadRequest()
    {
        List<int>? rateIds = null;

        var result = await _controller.GetListById(rateIds);
        Assert.NotNull(result);

        Assert.IsType<BadRequestObjectResult>(result);
        var status = result as BadRequestObjectResult;
        Assert.NotNull(status);
        Assert.Equal(400, status.StatusCode);
    }

    [Fact]
    public async void Rate_GetListById_InternalServerError()
    {
        var rateIds = new List<int>
        {
            1,
            2,
            3
        };
        _mockRateService.Setup(x => x.GetRangeByIdAsync(rateIds))
            .Throws(new Exception("Test")).Verifiable();

        var result = await _controller.GetListById(rateIds);
        Assert.NotNull(result);

        Assert.IsType<StatusCodeResult>(result);
        var status = result as StatusCodeResult;
        Assert.NotNull(status);
        Assert.Equal(500, status.StatusCode);
        _mockRateService.Verify();
    }

    [Fact]
    public async void Rate_Post_CreatedAtAction()
    {
        var rateId = 1;
        var Value = Guid.NewGuid().ToString();
        var rate = new Rate
        {
            Value = 5.59M
        };
        var rateReturned = new Rate
        {
            RateId = rateId,
            Value = 5.59M
        };

        _mockRateService.Setup(x => x.SaveAsync(rate))
            .ReturnsAsync(rateReturned).Verifiable();

        var result = await _controller.Post(rate);
        Assert.NotNull(result);

        Assert.IsType<CreatedAtActionResult>(result);
        var status = result as CreatedAtActionResult;
        Assert.NotNull(status);
        Assert.Equal(201, status.StatusCode);

        var resultValue = status.Value as Rate;
        Assert.NotNull(result);
        Assert.NotNull(resultValue);
        Assert.Equal(rateReturned.RateId, resultValue.RateId);
        Assert.Equal(rateReturned.Value, resultValue.Value);
        _mockRateService.Verify();
    }

    [Fact]
    public async void Rate_Post_BadRequest()
    {
        Rate? rate = null;

        var result = await _controller.Post(rate);
        Assert.NotNull(result);

        Assert.IsType<BadRequestObjectResult>(result);
        var status = result as BadRequestObjectResult;
        Assert.NotNull(status);
        Assert.Equal(400, status.StatusCode);
    }

    [Fact]
    public async void Rate_Post_InternalServerError()
    {
        var rate = new Rate
        {
            RateId = 1
        };
        _mockRateService.Setup(x => x.SaveAsync(rate))
            .Throws(new Exception("Test")).Verifiable();

        var result = await _controller.Post(rate);
        Assert.NotNull(result);

        Assert.IsType<StatusCodeResult>(result);
        var status = result as StatusCodeResult;
        Assert.NotNull(status);
        Assert.Equal(500, status.StatusCode);
        _mockRateService.Verify();
    }

    [Fact]
    public async void Rate_SaveRange_Ok()
    {
        var rates = new List<Rate>
        {
            new() { Value = 5.60M },
            new() { Value = 5.59M },
            new() { Value = 5.61M }
        };

        _mockRateService.Setup(x => x.SaveRangeAsync(rates));

        var result = await _controller.SaveRange(rates);
        Assert.NotNull(result);

        Assert.IsType<OkResult>(result);
        var status = result as OkResult;
        Assert.NotNull(status);
        Assert.Equal(200, status.StatusCode);
        _mockRateService.Verify();
    }

    [Fact]
    public async void Rate_SaveRange_BadRequest()
    {
        List<Rate>? rates = null;

        var result = await _controller.SaveRange(rates);
        Assert.NotNull(result);

        Assert.IsType<BadRequestObjectResult>(result);
        var status = result as BadRequestObjectResult;
        Assert.NotNull(status);
        Assert.Equal(400, status.StatusCode);
    }

    [Fact]
    public async void Rate_SaveRange_InternalServerError()
    {
        var rates = new List<Rate>
        {
            new() { Value = 5.60M },
            new() { Value = 5.59M },
            new() { Value = 5.61M }
        };
        _mockRateService.Setup(x => x.SaveRangeAsync(rates))
            .Throws(new Exception("Test")).Verifiable();

        var result = await _controller.SaveRange(rates);
        Assert.NotNull(result);

        Assert.IsType<StatusCodeResult>(result);
        var status = result as StatusCodeResult;
        Assert.NotNull(status);
        Assert.Equal(500, status.StatusCode);
        _mockRateService.Verify();
    }

    [Fact]
    public async void Rate_Put_OK()
    {
        var rateId = 1;
        var value = 5.60M;
        var rate = new Rate
        {
            RateId = rateId,
            Value = value
        };
        var rateReturned = new Rate
        {
            RateId = rateId,
            Value = value
        };

        _mockRateService.Setup(x => x.UpdateAsync(rate))
            .ReturnsAsync(rateReturned).Verifiable();

        var result = await _controller.Put(rate);
        Assert.NotNull(result);

        Assert.IsType<OkObjectResult>(result);
        var status = result as OkObjectResult;
        Assert.NotNull(status);
        Assert.Equal(200, status.StatusCode);

        var rateResult = status.Value as Rate;
        Assert.NotNull(rateResult);
        Assert.Equal(rate.Value, rateResult.Value);
        _mockRateService.Verify();
    }

    [Fact]
    public async void Rate_Put_Status406NotAcceptable()
    {
        var rate = new Rate
        {
            RateId = 1
        };

        var result = await _controller.Put(rate);
        Assert.NotNull(result);

        Assert.IsType<StatusCodeResult>(result);
        var status = result as StatusCodeResult;
        Assert.NotNull(status);
        Assert.Equal(406, status.StatusCode);
    }

    [Fact]
    public async void Rate_Put_BadRequest_NoIds()
    {
        var rate = new Rate
        {
            Value = 5.59M
        };

        var result = await _controller.Put(rate);
        Assert.NotNull(result);

        Assert.IsType<BadRequestObjectResult>(result);
        var status = result as BadRequestObjectResult;
        Assert.NotNull(status);
        Assert.Equal(400, status.StatusCode);
        _mockRateService.Verify(x => x.GetAsync(), Times.Never);
    }

    [Fact]
    public async void Rate_Put_BadRequest()
    {
        Rate? rate = null;

        var result = await _controller.Put(rate);
        Assert.NotNull(result);

        Assert.IsType<BadRequestObjectResult>(result);
        var status = result as BadRequestObjectResult;
        Assert.NotNull(status);
        Assert.Equal(400, status.StatusCode);
    }

    [Fact]
    public async void Rate_Put_InternalServerError()
    {
        var rate = new Rate
        {
            RateId = 1
        };
        _mockRateService.Setup(x => x.UpdateAsync(rate))
            .Throws(new Exception("Test")).Verifiable();

        var result = await _controller.Put(rate);
        Assert.NotNull(result);

        Assert.IsType<StatusCodeResult>(result);
        var status = result as StatusCodeResult;
        Assert.NotNull(status);
        Assert.Equal(500, status.StatusCode);
        _mockRateService.Verify();
    }

    [Fact]
    public async void Rate_UpdateRange_OK()
    {
        var values = new List<decimal>
        {
            5.60M,
            5.61M,
            5.62M
        };
        var rates = new List<Rate>
        {
            new() 
            { 
                RateId = 1,
                Value = values[0] 
            },
            new() 
            {
                RateId = 2,
                Value = values[1] 
            },
            new() 
            {
                RateId = 3,
                Value = values[2] 
            }
        };

        var ratesReturned = new List<Rate>
        {
            new()
            {
                RateId = 1,
                Value = values[0]
            },
            new()
            {
                RateId = 2,
                Value = values[1]
            },
            new()
            {
                RateId = 3,
                Value = values[2]
            }
        };

        _mockRateService.Setup(x => x.UpdateRangeAsync(rates))
            .ReturnsAsync(ratesReturned).Verifiable();

        var result = await _controller.UpdateRange(rates);
        Assert.NotNull(result);

        Assert.IsType<OkObjectResult>(result);
        var status = result as OkObjectResult;
        Assert.NotNull(status);
        Assert.Equal(200, status.StatusCode);

        var rateResult = status.Value as List<Rate>;
        Assert.NotNull(rateResult);
        Assert.Equal(rates[0].Value, rateResult[0].Value);
        Assert.Equal(rates[1].Value, rateResult[1].Value);
        Assert.Equal(rates[2].Value, rateResult[2].Value);
        _mockRateService.Verify();
    }

    [Fact]
    public async void Rate_UpdateRange_BadRequest_NoIds()
    {
        var rates = new List<Rate>
        {
            new ()
            {
                Value = 5.60M
            },
            new ()
            {
                Value = 5.61M
            }
        };

        var result = await _controller.UpdateRange(rates);
        Assert.NotNull(result);

        Assert.IsType<BadRequestObjectResult>(result);
        var status = result as BadRequestObjectResult;
        Assert.NotNull(status);
        Assert.Equal(400, status.StatusCode);
        _mockRateService.Verify(x => x.GetAsync(), Times.Never);
    }

    [Fact]
    public async void Rate_UpdateRange_BadRequest()
    {
        List<Rate>? rates = null;

        var result = await _controller.UpdateRange(rates);
        Assert.NotNull(result);

        Assert.IsType<BadRequestObjectResult>(result);
        var status = result as BadRequestObjectResult;
        Assert.NotNull(status);
        Assert.Equal(400, status.StatusCode);
    }

    [Fact]
    public async void Rate_UpdateRange_InternalServcerError()
    {
        var rates = new List<Rate>
        {
            new ()
            {
                RateId = 1,
                Value = 5.60M
            },
            new ()
            {
                RateId = 2,
                Value = 5.61M
            }
        };
        _mockRateService.Setup(x => x.UpdateRangeAsync(rates))
            .Throws(new Exception("Test")).Verifiable();

        var result = await _controller.UpdateRange(rates);
        Assert.NotNull(result);

        Assert.IsType<StatusCodeResult>(result);
        var status = result as StatusCodeResult;
        Assert.NotNull(status);
        Assert.Equal(500, status.StatusCode);
        _mockRateService.Verify();
    }

    [Fact]
    public async void Rate_Delete_OK()
    {
        var rateId = 1;

        _mockRateService.Setup(x => x.DeleteAsync(rateId)).Verifiable();

        var result = await _controller.Delete(rateId);
        Assert.NotNull(result);

        Assert.IsType<OkResult>(result);
        var status = result as OkResult;
        Assert.NotNull(status);
        Assert.Equal(200, status.StatusCode);
        _mockRateService.Verify();
    }

    [Fact]
    public async void Rate_Delete_BadRequest()
    {
        var rateId = 0;

        var result = await _controller.Delete(rateId);
        Assert.NotNull(result);

        Assert.IsType<BadRequestObjectResult>(result);
        var status = result as BadRequestObjectResult;
        Assert.NotNull(status);
        Assert.Equal(400, status.StatusCode);
    }

    [Fact]
    public async void Rate_Delete_InternalServerError()
    {
        var rateId = 1;
        _mockRateService.Setup(x => x.DeleteAsync(rateId))
            .Throws(new Exception("Test")).Verifiable();

        var result = await _controller.Delete(rateId);
        Assert.NotNull(result);

        Assert.IsType<StatusCodeResult>(result);
        var status = result as StatusCodeResult;
        Assert.NotNull(status);
        Assert.Equal(500, status.StatusCode);
        _mockRateService.Verify();
    }

    [Fact]
    public async void Rate_DeleteRange_OK()
    {
        var rateIds = new List<int>
        {
            1,
            1,
            1
        };

        _mockRateService.Setup(x => x.DeleteRangeAsync(rateIds)).Verifiable();

        var result = await _controller.DeleteRange(rateIds);
        Assert.NotNull(result);

        Assert.IsType<OkResult>(result);
        var status = result as OkResult;
        Assert.NotNull(status);
        Assert.Equal(200, status.StatusCode);
        _mockRateService.Verify();
    }

    [Fact]
    public async void Rate_DeleteRange_BadRequest()
    {
        var rateIds = new List<int>();

        var result = await _controller.DeleteRange(rateIds);
        Assert.NotNull(result);

        Assert.IsType<BadRequestObjectResult>(result);
        var status = result as BadRequestObjectResult;
        Assert.NotNull(status);
        Assert.Equal(400, status.StatusCode);
    }

    [Fact]
    public async void Rate_DeleteRange_InternalServerError()
    {
        var rateIds = new List<int>
        {
            1
        };
        _mockRateService.Setup(x => x.DeleteRangeAsync(rateIds))
            .Throws(new Exception("Test")).Verifiable();

        var result = await _controller.DeleteRange(rateIds);
        Assert.NotNull(result);

        Assert.IsType<StatusCodeResult>(result);
        var status = result as StatusCodeResult;
        Assert.NotNull(status);
        Assert.Equal(500, status.StatusCode);
        _mockRateService.Verify();
    }
}