using Diligent.WebAPI.Business.Interfaces;
using Diligent.WebAPI.Data.Entities;
using Diligent.WebAPI.Data.HelperModels;
using Diligent.WebAPI.Host.Exceptions;
using Diligent.WebAPI.Host.Mediator.Chat.Handlers;
using Diligent.WebAPI.Host.Mediator.Rooms.Commands;
using Diligent.WebAPI.Host.Mediator.Rooms.Queries;
using Microsoft.AspNetCore.Http;
using Moq;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace Tests
{
    [TestFixture]
    public class RoomTests
    {
        private Mock<IRoomRepository> _roomRepositoryMock;
        private readonly List<Room> _rooms = new()
        {
            new Room
            {
                Id = "123",
                CreatedBy = "123",
                Customers = new List<CustomerDTO>
                {
                    new CustomerDTO
                    {
                        CustomerId = "1",
                        DateOfEnteringRoom = new DateTime(2021, 2, 3)
                    },
                    new CustomerDTO
                    {
                        CustomerId = "2",
                        DateOfEnteringRoom =  DateTime.UtcNow
                    }
                },
                CreatedAtUtc = DateTime.UtcNow,
                IsOneToOne = true,
                Messages = new List<Message>
                {
                    new Message
                    {
                        Id = "1",
                        Content = "AA",
                        SenderId = "1",
                        Username = "username1",
                        CreatedAtUtc = DateTime.Now,
                    },
                    new Message
                    {
                        Id = "2",
                        Content = "BB",
                        SenderId = "2",
                        Username = "username2",
                        CreatedAtUtc = DateTime.Now,
                    }
                },
                Name = "room1"
            },
            new Room
            {
                Id = "1234",
                CreatedBy = "1234",
                Customers = new List<CustomerDTO>()
                {
                    new CustomerDTO
                    {
                        CustomerId = "3",
                        DateOfEnteringRoom = DateTime.Now
                    },
                    new CustomerDTO
                    {
                        CustomerId = "4",
                        DateOfEnteringRoom = DateTime.Now
                    }
                },
                CreatedAtUtc = DateTime.Now,
                IsOneToOne = true,
                Messages = new List<Message>
                {
                    new Message
                    {
                        Id = "3",
                        Content = "CC",
                        SenderId = "3",
                        Username = "username1",
                        CreatedAtUtc = new DateTime(2021, 2, 3)
                    },
                    new Message
                    {
                        Id = "4",
                        Content = "DD",
                        SenderId = "4",
                        Username = "username2",
                        CreatedAtUtc = new DateTime(2021, 2, 3)
                    }
                },
                Name = "room2"
            },
        };

        [SetUp]

        public void SetUp()
        {
            _roomRepositoryMock = new Mock<IRoomRepository>();
        }

        [Test]
        public async Task RemoveUserFromGroup_ObjectIsNull_ThrowsNotFoundException()
        {
            var command = new RemoveUserFromGroupCommand(null, null);
            var handler = new RemoveUserFromGroupHandler(_roomRepositoryMock.Object);

            Assert.That(async () => await handler.Handle(command, new CancellationToken()), Throws.Exception.TypeOf<NotFoundException>());
        }

        [Test]
        public async Task RemoveUserFromGroup_UserConnectionIsNull_ThrowsNotFoundException()
        {
            _roomRepositoryMock.Setup(x => x.GetByIdAsync(It.IsAny<string>()))
                .ReturnsAsync(new Room
                {
                    Name = "Room1",
                    Customers = new List<CustomerDTO>
                    {
                        new CustomerDTO { CustomerId = "user", DateOfEnteringRoom = DateTime.Now}
                    },
                    CreatedBy = "User1"
                });
            var command = new RemoveUserFromGroupCommand("room1", "user1");
            var handler = new RemoveUserFromGroupHandler(_roomRepositoryMock.Object);

            Assert.That(async () => await handler.Handle(command, new CancellationToken()), Throws.Exception.TypeOf<NotFoundException>());

        }


        [Test]
        public async Task RemoveUserFromGroup_UserConnectionIsNotNull_ObjectIsNotNull()
        {
            var userConnection = new CustomerDTO { CustomerId = "user1", DateOfEnteringRoom = DateTime.Now };

            var room = new Room
            {
                Name = "Room1",
                Customers = new List<CustomerDTO>
                    {
                        userConnection   
                    },
                CreatedBy = "User1"
            };

            _roomRepositoryMock.Setup(x => x.GetByIdAsync(It.IsAny<string>()))
                .ReturnsAsync(room);

            _roomRepositoryMock.Setup(x => x.LeaveChatRoom(It.IsAny<Room>(), It.IsAny<CustomerDTO>()));

            var command = new RemoveUserFromGroupCommand("room1", "user1");
            var handler = new RemoveUserFromGroupHandler(_roomRepositoryMock.Object);

            var result = await handler.Handle(command, new CancellationToken());

            _roomRepositoryMock.Verify(mock => mock.LeaveChatRoom(room, userConnection));

        }

        [Test]
        public async Task GetAllRoomsWithFilteredMessages_CustomerIsNull_ReturnsEmptyList()
        {
            _roomRepositoryMock.Setup(x => x.GetAsync()).Returns(Task.FromResult(_rooms));
            var query = new GetAllRoomsWithFilteredMessagesQuery("5");
            var handler = new GetAllRoomsWithFilteredMessagesHandler(_roomRepositoryMock.Object);

            var result = await handler.Handle(query, new CancellationToken());

            Assert.That(result[0].Messages.Count(), Is.EqualTo(0));
        }

        [Test]
        public async Task GetAllRoomsWithFilteredMessages_CustomerIsNotNull_ReturnsEmptyListWithMessage()
        {
            _roomRepositoryMock.Setup(x => x.GetAsync()).Returns(Task.FromResult(_rooms));
            var query = new GetAllRoomsWithFilteredMessagesQuery("3");
            var handler = new GetAllRoomsWithFilteredMessagesHandler(_roomRepositoryMock.Object);

            var result = await handler.Handle(query, new CancellationToken());

            Assert.That(result[0].Messages.Count(), Is.EqualTo(0));
        }

        [Test]
        public async Task GetAllRoomsWithFilteredMessages_CustomerIsNotNull_Messages()
        {
            _roomRepositoryMock.Setup(x => x.GetAsync()).Returns(Task.FromResult(_rooms));
            var query = new GetAllRoomsWithFilteredMessagesQuery("1");
            var handler = new GetAllRoomsWithFilteredMessagesHandler(_roomRepositoryMock.Object);

            var result = await handler.Handle(query, new CancellationToken());

            Assert.That(result[0].Messages.Count(), Is.EqualTo(2));
        }
    }
}