using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using LCU.API.Internal.MemberPreferencesApi.Services;
using LCU.Library.Internal.MemberPreferencesApiModels.Entities;
using LCU.Library.Internal.MemberPreferencesApiModels.Enums;
using LCU.Library.Internal.MemberPreferencesApiModels;
using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Mvc;
using Moq;
using NUnit.Framework;
using LCU.API.Internal.MemberPreferencesApi.Controllers;
using LCU.Library.Internal.MemberPreferencesApiModels.Requests;

namespace LCU.API.Internal.MemberPreferencesApi.UnitTests.Controllers
{
    public class MemberPreferenceControllerTest
    {
        private MemberPreferenceController _controller;
        private Mock<IMemberPreferenceService> _mockMemberPreferenceService;

        [SetUp]
        public void Setup()
        {
            _mockMemberPreferenceService = new Mock<IMemberPreferenceService>();
            _controller = new MemberPreferenceController(_mockMemberPreferenceService.Object);
        }

        [Test]
        public async Task Get_OK()
        {
            _mockMemberPreferenceService
                .Setup(service => service.GetMemberPreferencesAsync("99")).ReturnsAsync(
                    new List<MemberPreference>()
                    {
                        new MemberPreference()
                        {
                            Id = 1,
                            UserId = "99",
                            Preference = PreferenceType.ENotification,
                            Value = "true"
                        }
                    }).Verifiable();

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

            var okResult = result as OkObjectResult;
            Assert.NotNull(okResult);
            Assert.AreEqual(200, okResult.StatusCode);

            var okValue = okResult.Value as IReadOnlyCollection<MemberPreference>;
            Assert.NotNull(okValue);
            Assert.IsNotEmpty(okValue);
            Assert.AreEqual(1, okValue.First().Id);
            _mockMemberPreferenceService.Verify();
        }

        [Test]
        public async Task Get_Missing()
        {
            _mockMemberPreferenceService
                .Setup(service => service.GetMemberPreferencesAsync("99")).ReturnsAsync(
                    new List<MemberPreference>()).Verifiable();

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

            var okResult = result as OkObjectResult;
            Assert.NotNull(okResult);
            Assert.AreEqual(200, okResult.StatusCode);

            var okValue = okResult.Value as IReadOnlyCollection<MemberPreference>;
            Assert.NotNull(okValue);
            Assert.IsEmpty(okValue);
            _mockMemberPreferenceService.Verify();
        }

        [Test]
        public async Task Get_Failure()
        {
            _mockMemberPreferenceService
                .Setup(service => service.GetMemberPreferencesAsync("99"))
                .Throws(new InvalidCastException()).Verifiable();

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

            var badResult = result as StatusCodeResult;
            Assert.NotNull(badResult);
            Assert.AreEqual(500, badResult.StatusCode);

            _mockMemberPreferenceService.Verify();
        }

        [Test]
        public void Get_Types_OK()
        {
            IReadOnlyCollection<string> values = Enum.GetValues(typeof(PreferenceType))
                .Cast<PreferenceType>()
                .Select(v => v.ToString())
                .ToList();

            _mockMemberPreferenceService
                .Setup(service => service.GetAvailableTypes()).Returns(values);

            var result = _controller.GetAvailableTypes();
            Assert.NotNull(result);

            var okResult = result as OkObjectResult;
            Assert.NotNull(okResult);
            Assert.AreEqual(200, okResult.StatusCode);

            var okValue = okResult.Value as IReadOnlyCollection<string>;
            Assert.NotNull(okValue);
            Assert.IsNotEmpty(okValue);
        }

        [Test]
        public async Task Post_OK()
        {
            var results = new MemberOptInSettings();
            var request = new MemberPreferenceRequest
            {
                Preference = PreferenceType.ENotification,
                Value = "True",
                UserId = "99",
                LegalReference = "None"
            };
            _mockMemberPreferenceService
                .Setup(service => service.SaveMemberPreferenceAsync(It.IsAny<MemberPreferenceRequest>()))
                .ReturnsAsync(results);

            var result = await _controller.CreateMemberPreference(request, "test","Associate");
            Assert.NotNull(result);

            var okResult = result as CreatedAtActionResult;
            Assert.NotNull(okResult);
            Assert.AreEqual(201, okResult.StatusCode);

            Assert.AreEqual("99", okResult.RouteValues["userId"]);
            _mockMemberPreferenceService.Verify(x => x.SaveMemberPreferenceAsync(It.IsAny<MemberPreferenceRequest>()),
                Times.Once);
        }

        [Test]
        public async Task Post_Bad_Request()
        {
            // arrange
            var request = new MemberPreferenceRequest()
            {
                Preference = PreferenceType.ENotification,
                Value = null,
                UserId = "99",
                LegalReference = "None"
            };
            _controller.ModelState.AddModelError("Value", "The value field is required.");

            // act
            var result = await _controller.CreateMemberPreference(request, "test", "Associate");
            Assert.NotNull(result);
            var badRequestResult = result as BadRequestObjectResult;

            // assert
            Assert.NotNull(badRequestResult);
            Assert.AreEqual(StatusCodes.Status400BadRequest, badRequestResult.StatusCode);
        }

        [Test]
        public async Task Post_Error()
        {
            // arrange
            var request = new MemberPreferenceRequest()
            {
                Preference = PreferenceType.ENotification,
                Value = "True",
                UserId = "99",
                LegalReference = "None"
            };

            _mockMemberPreferenceService
                .Setup(service => service.SaveMemberPreferenceAsync(It.IsAny<MemberPreferenceRequest>()))
                .ThrowsAsync(new ArithmeticException());

            // act
            var result = await _controller.CreateMemberPreference(request, "test", "Associate");
            var badResult = result as StatusCodeResult;
            Assert.NotNull(badResult);
            Assert.AreEqual(500, badResult.StatusCode);

            _mockMemberPreferenceService.Verify(x => x.SaveMemberPreferenceAsync(It.IsAny<MemberPreferenceRequest>()),
                Times.Once);
        }

        [Test]
        public async Task Post_Member_Has_Hold()
        {
            var request = new MemberPreferenceRequest()
            {
                Preference = PreferenceType.ENotification,
                Value = "True",
                UserId = "99",
                LegalReference = "None"
            };

            _mockMemberPreferenceService
                .Setup(service => service.SaveMemberPreferenceAsync(It.IsAny<MemberPreferenceRequest>()))
                .ThrowsAsync(new Exception());

            var result = await _controller.CreateMemberPreference(request, "test", "Associate");
            Assert.NotNull(result);

            var objectResult = result as StatusCodeResult;
            Assert.NotNull(objectResult);
            Assert.AreEqual(StatusCodes.Status500InternalServerError, objectResult.StatusCode);
        }

        [Test]
        public async Task Post_Bad_Request_NoHeaders()
        {
            // arrange
            var request = new MemberPreferenceRequest()
            {
                Preference = PreferenceType.ENotification,
                Value = "Electronic",
                UserId = "99",
                LegalReference = "None"
            };

            // act
            var result = await _controller.CreateMemberPreference(request, null, null);
            Assert.NotNull(result);
            var badRequestResult = result as BadRequestObjectResult;

            // assert
            Assert.NotNull(badRequestResult);
            Assert.AreEqual(StatusCodes.Status400BadRequest, badRequestResult.StatusCode);
        }
    }
}