using Diligent.WebAPI.Contracts.DTOs.Ad;
using Diligent.WebAPI.Contracts.DTOs.Applicant;
using Diligent.WebAPI.Contracts.DTOs.Pattern;
using Diligent.WebAPI.Contracts.Exceptions;
using Diligent.WebAPI.Data.Entities;
using NSubstitute.ReturnsExtensions;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace Diligent.WebAPI.Tests.Controllers
{
    public class PatternsControllerTests
    {
        private IPatternService _patternService = Substitute.For<IPatternService>();
        private List<PatternResponseDto> _patterns = new List<PatternResponseDto>();
        private PatternResponseDto _pattern;

        public PatternsControllerTests()
        {
            _pattern = new PatternResponseDto
            {
                Id = 1205,
                CreatedAt = DateTime.Now,
                Message = "Poruka",
                Title = "Title",
                SelectionLevel = new Contracts.DTOs.SelectionLevel.SelectionLevelResposneDto
                {
                    Id = 2345,
                    Name = "Zakazan termin"
                }
            };

            _patterns.Add(_pattern);
        }

        [Fact]
        public async Task GetAll_ShouldReturn200OK_WhenCalled()
        {
            _patternService.GetAllAsync().Returns(_patterns);
            PatternsController patternsController = new(_patternService);
            var result = await patternsController.GetAll();
            (result as OkObjectResult).StatusCode.Should().Be(200);
        }

        [Fact]
        public async Task GetById_ShouldReturn200OK_WhenPatternExists()
        {
            _patternService.GetByIdAsync(Arg.Any<int>()).Returns(_pattern);
            PatternsController patternsController = new(_patternService);
            var result = await patternsController.GetById(1205);
            (result as OkObjectResult).StatusCode.Should().Be(200);
        }

        [Fact]
        public async Task GetById_ShouldThrowEntityNotFoundException_WhenPatternDontExist()
        {
            _patternService.When(x => x.GetByIdAsync(Arg.Any<int>())).Do(x => { throw new EntityNotFoundException(); });

            PatternsController patternsController = new(_patternService);

            await Assert.ThrowsAsync<EntityNotFoundException>(() => patternsController.GetById(1000));
        }

        [Fact]
        public async Task GetFilteredPatterns_ShouldReturn200OK_WhenCalled()
        {
            _patternService.GetFilteredPatternsAsync(new FilterPatternDto
            {
                FromDate = new DateTime(2022, 11, 30),
                ToDate = DateTime.Now,
                SelectionLevels = null
            }).Returns(_patterns);

            PatternsController patternsController = new(_patternService);

            var result = await patternsController.GetFilteredPatterns(new FilterPatternDto
            {
                FromDate = new DateTime(2022, 11, 30),
                ToDate = DateTime.Now,
                SelectionLevels = null
            });

            (result as OkObjectResult).StatusCode.Should().Be(200);
        }

        [Fact]
        public async Task GetCorrespondingPatternApplicants_ShouldReturn200OK_WhenCalled()
        {
            var patternApplicants = new List<PatternApplicantViewDto>
            {
                new PatternApplicantViewDto
                {
                    ApplicantId = 1,
                    Email = "ermin.bronja@dilig.net",
                    FirstName = "Ermin",
                    LastName = "Bronja"
                }
            };

            _patternService.GetCorrespondingPatternApplicants(1205).Returns(patternApplicants);

            PatternsController patternsController = new(_patternService);

            var result = await patternsController.GetCorrespondingPatternApplicants(1205);

            (result as OkObjectResult).StatusCode.Should().Be(200);
        }

        [Fact]
        public async Task GetCorrespondingPatternApplicants_ShouldThrowEntityNotFoundException_WhenPatternDontExist()
        {
            _patternService.When(x => x.GetCorrespondingPatternApplicants(Arg.Any<int>())).Do(x => { throw new EntityNotFoundException(); });

            PatternsController patternsController = new(_patternService);

            await Assert.ThrowsAsync<EntityNotFoundException>(() => patternsController.GetCorrespondingPatternApplicants(1000));
        }

        [Fact]
        public async Task CreatePattern_ShouldReturn201Created_WhenPatternCreated()
        {
            var patternCreateDto = new PatternCreateDto
            {
                CreatedAt = DateTime.Now,
                Message = "Poruka",
                SelectionLevelId = 5,
                Title = "Čeka na zakazivanju"
            };

            _patternService.CreateAsync(patternCreateDto);

            PatternsController patternsController = new(_patternService);

            var result = await patternsController.Create(patternCreateDto);

            (result as StatusCodeResult).StatusCode.Should().Be(201);
        }

        [Fact]
        public async Task CreatePattern_ShouldThrowEntityNotFoundException_WhenPatternAlreadyExist()
        {
            _patternService.When(x => x.CreateAsync(Arg.Any<PatternCreateDto>())).Do(x => { throw new EntityNotFoundException(); });

            PatternsController patternsController = new(_patternService);

            await Assert.ThrowsAsync<EntityNotFoundException>(() => patternsController.Create(new PatternCreateDto { Title = "Title", CreatedAt = DateTime.Now, Message = "Poruka", SelectionLevelId = 2345}));
        }

        [Fact]
        public async Task ScheduleInterview_ShouldReturn200OK_WhenInterviewScheduled()
        {
            var scheduleInterviewDto = new ScheduleInterviewDto
            {
                Emails = new List<string>
                {
                    "ermin.bronja@dilig.net"
                },
                PatternId = 1205
            };

            _patternService.ScheduleIntrviewAsync(scheduleInterviewDto).ReturnsNull();

            PatternsController patternsController = new(_patternService);

            var result = await patternsController.ScheduleInterview(scheduleInterviewDto);

            var res = result as StatusCodeResult;
            Assert.Equal(res, null);
        }

        [Fact]
        public async Task ScheduleInterview_ShouldThrowEntityNotFoundException_WhenPatternDoesNotExist()
        {
            _patternService.When(x => x.ScheduleIntrviewAsync(Arg.Any<ScheduleInterviewDto>())).Do(x => { throw new EntityNotFoundException(); });

            PatternsController patternsController = new(_patternService);

            await Assert.ThrowsAsync<EntityNotFoundException>(() => patternsController.ScheduleInterview(new ScheduleInterviewDto
            {
                Emails = new List<string>
                {
                    "ermin.bronja@dilig.net"
                },
                PatternId = 1205
            }));
        }

        [Fact]
        public async Task UpdatePattern_ShouldReturn200OK_WhenPatternUpdated()
        {
            var updatePatternDto = new PatternUpdateDto
            {
                CreatedAt = DateTime.Now,
                Message = "Poruka 1",
                SelectionLevelId = 500,
                Title = "Naslov"
            };

            _patternService.UpdateAsync(updatePatternDto, 1205);

            PatternsController patternsController = new(_patternService);

            var result = await patternsController.Update(updatePatternDto, 1205);

            (result as StatusCodeResult).StatusCode.Should().Be(200);
        }

        [Fact]
        public async Task UpdatePattern_ShouldThrowEntityNotFoundException_WhenPatternDoesNotExist()
        {
            var patternUpdateDto = new PatternUpdateDto
            {
                CreatedAt = DateTime.Now,
                SelectionLevelId = 2345,
                Message = "Poruka",
                Title = "Title"
            };

            _patternService.When(x => x.UpdateAsync(Arg.Any<PatternUpdateDto>(), Arg.Any<int>())).Do(x => { throw new EntityNotFoundException(); });

            PatternsController patternsController = new(_patternService);

            await Assert.ThrowsAsync<EntityNotFoundException>(() => patternsController.Update(patternUpdateDto, 1205));
        }

        [Fact]
        public async Task DeletePattern_ShouldReturn204NoContent_WhenPatternDeleted()
        {
            PatternsController patternsController = new(_patternService);

            var result = await patternsController.DeletePattern(1205);

            (result as StatusCodeResult).StatusCode.Should().Be(204);
        }

        [Fact]
        public async Task Delete_ShouldThrowEntityNotFoundException_WhenPatternDoesNotExist()
        {
            _patternService.When(x => x.DeleteAsync(Arg.Any<int>())).Do(x => { throw new EntityNotFoundException(); });

            PatternsController patternsController = new(_patternService);

            await Assert.ThrowsAsync<EntityNotFoundException>(() => patternsController.DeletePattern(1205));
        }
    }
}