using MagicCarpetContracts.BindingModels;
using MagicCarpetContracts.ViewModels;
using MagicCarpetDatabase.Models;
using MagicCarpetTests.Infrastructure;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Net;
using System.Text;
using System.Threading.Tasks;

namespace MagicCarpetTests.WebApiControllersTests;

[TestFixture]
internal class ClientControllerTests : BaseWebApiControllerTest
{
    [TearDown]
    public void TearDown()
    {
        MagicCarpetDbContext.RemoveSalesFromDatabase();
        MagicCarpetDbContext.RemoveEmployeesFromDatabase();
        MagicCarpetDbContext.RemoveClientsFromDatabase();
    }

    [Test]
    public async Task GetList_WhenHaveRecords_ShouldSuccess_Test()
    {
        //Arrange
        var client = MagicCarpetDbContext.InsertClientToDatabaseAndReturn(phoneNumber: "+5-555-555-55-55");
        MagicCarpetDbContext.InsertClientToDatabaseAndReturn(phoneNumber: "+6-666-666-66-66");
        MagicCarpetDbContext.InsertClientToDatabaseAndReturn(phoneNumber: "+7-777-777-77-77");
        //Act
        var response = await HttpClient.GetAsync("/api/clients");
        //Assert
        Assert.That(response.StatusCode, Is.EqualTo(HttpStatusCode.OK));
        var data = await GetModelFromResponseAsync<List<ClientViewModel>>(response);
        Assert.Multiple(() =>
        {
            Assert.That(data, Is.Not.Null);
            Assert.That(data, Has.Count.EqualTo(3));
        });
        AssertElement(data.First(x => x.Id == client.Id), client);
    }

    [Test]
    public async Task GetList_WhenNoRecords_ShouldSuccess_Test()
    {
        //Act
        var response = await HttpClient.GetAsync("/api/clients");
        //Assert
        Assert.That(response.StatusCode, Is.EqualTo(HttpStatusCode.OK));
        var data = await GetModelFromResponseAsync<List<ClientViewModel>>(response);
        Assert.Multiple(() =>
        {
            Assert.That(data, Is.Not.Null);
            Assert.That(data, Has.Count.EqualTo(0));
        });
    }

    [Test]
    public async Task GetElement_ById_WhenHaveRecord_ShouldSuccess_Test()
    {
        //Arrange
        var client = MagicCarpetDbContext.InsertClientToDatabaseAndReturn();
        //Act
        var response = await HttpClient.GetAsync($"/api/clients/{client.Id}");
        //Assert
        Assert.That(response.StatusCode, Is.EqualTo(HttpStatusCode.OK));
        AssertElement(await GetModelFromResponseAsync<ClientViewModel>(response), client);
    }

    [Test]
    public async Task GetElement_ById_WhenNoRecord_ShouldNotFound_Test()
    {
        //Arrange
        MagicCarpetDbContext.InsertClientToDatabaseAndReturn();
        //Act
        var response = await HttpClient.GetAsync($"/api/clients/{Guid.NewGuid()}");
        //Assert
        Assert.That(response.StatusCode, Is.EqualTo(HttpStatusCode.NotFound));
    }

    [Test]
    public async Task GetElement_ByFIO_WhenHaveRecord_ShouldSuccess_Test()
    {
        //Arrange
        var client = MagicCarpetDbContext.InsertClientToDatabaseAndReturn();
        //Act
        var response = await HttpClient.GetAsync($"/api/clients/{client.FIO}");
        //Assert
        Assert.That(response.StatusCode, Is.EqualTo(HttpStatusCode.OK));
        AssertElement(await GetModelFromResponseAsync<ClientViewModel>(response), client);
    }

    [Test]
    public async Task GetElement_ByFIO_WhenNoRecord_ShouldNotFound_Test()
    {
        //Arrange
        MagicCarpetDbContext.InsertClientToDatabaseAndReturn();
        //Act
        var response = await HttpClient.GetAsync($"/api/clients/New%20Fio");
        //Assert
        Assert.That(response.StatusCode, Is.EqualTo(HttpStatusCode.NotFound));
    }

    [Test]
    public async Task GetElement_ByPhoneNumber_WhenHaveRecord_ShouldSuccess_Test()
    {
        //Arrange
        var client = MagicCarpetDbContext.InsertClientToDatabaseAndReturn();
        //Act
        var response = await HttpClient.GetAsync($"/api/clients/{client.PhoneNumber}");
        //Assert
        Assert.That(response.StatusCode, Is.EqualTo(HttpStatusCode.OK));
        AssertElement(await GetModelFromResponseAsync<ClientViewModel>(response), client);
    }

    [Test]
    public async Task GetElement_ByPhoneNumber_WhenNoRecord_ShouldNotFound_Test()
    {
        //Arrange
        MagicCarpetDbContext.InsertClientToDatabaseAndReturn();
        //Act
        var response = await HttpClient.GetAsync($"/api/clients/+8-888-888-88-88");
        //Assert
        Assert.That(response.StatusCode, Is.EqualTo(HttpStatusCode.NotFound));
    }

    [Test]
    public async Task Post_ShouldSuccess_Test()
    {
        //Arrange
        MagicCarpetDbContext.InsertClientToDatabaseAndReturn();
        var clientModel = CreateBindingModel();
        //Act
        var response = await HttpClient.PostAsync($"/api/clients", MakeContent(clientModel));
        //Assert
        Assert.That(response.StatusCode, Is.EqualTo(HttpStatusCode.NoContent));
        AssertElement(MagicCarpetDbContext.GetClientFromDatabase(clientModel.Id!), clientModel);
    }

    [Test]
    public async Task Post_WhenHaveRecordWithSameId_ShouldBadRequest_Test()
    {
        //Arrange
        var clientModel = CreateBindingModel();
        MagicCarpetDbContext.InsertClientToDatabaseAndReturn(clientModel.Id);
        //Act
        var response = await HttpClient.PostAsync($"/api/clients", MakeContent(clientModel));
        //Assert
        Assert.That(response.StatusCode, Is.EqualTo(HttpStatusCode.BadRequest));
    }

    [Test]
    public async Task Post_WhenHaveRecordWithSamePhoneNumber_ShouldBadRequest_Test()
    {
        //Arrange
        var clientModel = CreateBindingModel();
        MagicCarpetDbContext.InsertClientToDatabaseAndReturn(phoneNumber: clientModel.PhoneNumber!);
        //Act
        var response = await HttpClient.PostAsync($"/api/clients", MakeContent(clientModel));
        //Assert
        Assert.That(response.StatusCode, Is.EqualTo(HttpStatusCode.BadRequest));
    }

    [Test]
    public async Task Post_WhenDataIsIncorrect_ShouldBadRequest_Test()
    {
        //Arrange
        var clientModelWithIdIncorrect = new ClientBindingModel { Id = "Id", FIO = "fio", PhoneNumber = "+7-111-111-11-11", DiscountSize = 10 };
        var clientModelWithFioIncorrect = new ClientBindingModel { Id = Guid.NewGuid().ToString(), FIO = string.Empty, PhoneNumber = "+7-111-111-11-11", DiscountSize = 10 };
        var clientModelWithPhoneNumberIncorrect = new ClientBindingModel { Id = Guid.NewGuid().ToString(), FIO = "fio", PhoneNumber = "71", DiscountSize = 10 };
        //Act
        var responseWithIdIncorrect = await HttpClient.PostAsync($"/api/clients", MakeContent(clientModelWithIdIncorrect));
        var responseWithFioIncorrect = await HttpClient.PostAsync($"/api/clients", MakeContent(clientModelWithFioIncorrect));
        var responseWithPhoneNumberIncorrect = await HttpClient.PostAsync($"/api/clients", MakeContent(clientModelWithPhoneNumberIncorrect));
        //Assert
        Assert.Multiple(() =>
        {
            Assert.That(responseWithIdIncorrect.StatusCode, Is.EqualTo(HttpStatusCode.BadRequest), "Id is incorrect");
            Assert.That(responseWithFioIncorrect.StatusCode, Is.EqualTo(HttpStatusCode.BadRequest), "Fio is incorrect");
            Assert.That(responseWithPhoneNumberIncorrect.StatusCode, Is.EqualTo(HttpStatusCode.BadRequest), "PhoneNumber is incorrect");
        });
    }

    [Test]
    public async Task Post_WhenSendEmptyData_ShouldBadRequest_Test()
    {
        //Act
        var response = await HttpClient.PostAsync($"/api/clients", MakeContent(string.Empty));
        //Assert
        Assert.That(response.StatusCode, Is.EqualTo(HttpStatusCode.BadRequest));
    }

    [Test]
    public async Task Post_WhenSendWrongFormatData_ShouldBadRequest_Test()
    {
        //Act
        var response = await HttpClient.PostAsync($"/api/clients", MakeContent(new { Data = "test", Position = 10 }));
        //Assert
        Assert.That(response.StatusCode, Is.EqualTo(HttpStatusCode.BadRequest));
    }

    [Test]
    public async Task Put_ShouldSuccess_Test()
    {
        //Arrange
        var clientModel = CreateBindingModel(fio: "new fio");
        MagicCarpetDbContext.InsertClientToDatabaseAndReturn(clientModel.Id);
        //Act
        var response = await HttpClient.PutAsync($"/api/clients", MakeContent(clientModel));
        //Assert
        Assert.That(response.StatusCode, Is.EqualTo(HttpStatusCode.NoContent));
        MagicCarpetDbContext.ChangeTracker.Clear();
        AssertElement(MagicCarpetDbContext.GetClientFromDatabase(clientModel.Id!), clientModel);
    }

    [Test]
    public async Task Put_WhenNoFoundRecord_ShouldBadRequest_Test()
    {
        //Arrange
        var clientModel = CreateBindingModel(fio: "new fio");
        MagicCarpetDbContext.InsertClientToDatabaseAndReturn();
        //Act
        var response = await HttpClient.PutAsync($"/api/clients", MakeContent(clientModel));
        //Assert
        Assert.That(response.StatusCode, Is.EqualTo(HttpStatusCode.BadRequest));
    }

    [Test]
    public async Task Put_WhenHaveRecordWithSamePhoneNumber_ShouldBadRequest_Test()
    {
        //Arrange
        var clientModel = CreateBindingModel(fio: "new fio");
        MagicCarpetDbContext.InsertClientToDatabaseAndReturn(clientModel.Id);
        MagicCarpetDbContext.InsertClientToDatabaseAndReturn(phoneNumber: clientModel.PhoneNumber!);
        //Act
        var response = await HttpClient.PostAsync($"/api/clients", MakeContent(clientModel));
        //Assert
        Assert.That(response.StatusCode, Is.EqualTo(HttpStatusCode.BadRequest));
    }

    [Test]
    public async Task Put_WhenDataIsIncorrect_ShouldBadRequest_Test()
    {
        //Arrange
        var clientModelWithIdIncorrect = new ClientBindingModel { Id = "Id", FIO = "fio", PhoneNumber = "+7-111-111-11-11", DiscountSize = 10 };
        var clientModelWithFioIncorrect = new ClientBindingModel { Id = Guid.NewGuid().ToString(), FIO = string.Empty, PhoneNumber = "+7-111-111-11-11", DiscountSize = 10 };
        var clientModelWithPhoneNumberIncorrect = new ClientBindingModel { Id = Guid.NewGuid().ToString(), FIO = "fio", PhoneNumber = "71", DiscountSize = 10 };
        //Act
        var responseWithIdIncorrect = await HttpClient.PutAsync($"/api/clients", MakeContent(clientModelWithIdIncorrect));
        var responseWithFioIncorrect = await HttpClient.PutAsync($"/api/clients", MakeContent(clientModelWithFioIncorrect));
        var responseWithPhoneNumberIncorrect = await HttpClient.PutAsync($"/api/clients", MakeContent(clientModelWithPhoneNumberIncorrect));
        //Assert
        Assert.Multiple(() =>
        {
            Assert.That(responseWithIdIncorrect.StatusCode, Is.EqualTo(HttpStatusCode.BadRequest), "Id is incorrect");
            Assert.That(responseWithFioIncorrect.StatusCode, Is.EqualTo(HttpStatusCode.BadRequest), "Fio is incorrect");
            Assert.That(responseWithPhoneNumberIncorrect.StatusCode, Is.EqualTo(HttpStatusCode.BadRequest), "PhoneNumber is incorrect");
        });
    }

    [Test]
    public async Task Put_WhenSendEmptyData_ShouldBadRequest_Test()
    {
        //Act
        var response = await HttpClient.PutAsync($"/api/clients", MakeContent(string.Empty));
        //Assert
        Assert.That(response.StatusCode, Is.EqualTo(HttpStatusCode.BadRequest));
    }

    [Test]
    public async Task Put_WhenSendWrongFormatData_ShouldBadRequest_Test()
    {
        //Act
        var response = await HttpClient.PutAsync($"/api/clients", MakeContent(new { Data = "test", Position = 10 }));
        //Assert
        Assert.That(response.StatusCode, Is.EqualTo(HttpStatusCode.BadRequest));
    }

    [Test]
    public async Task Delete_ShouldSuccess_Test()
    {
        //Arrange
        var clientId = Guid.NewGuid().ToString();
        MagicCarpetDbContext.InsertClientToDatabaseAndReturn(clientId);
        //Act
        var response = await HttpClient.DeleteAsync($"/api/clients/{clientId}");
        //Assert
        Assert.Multiple(() =>
        {
            Assert.That(response.StatusCode, Is.EqualTo(HttpStatusCode.NoContent));
            Assert.That(MagicCarpetDbContext.GetClientFromDatabase(clientId), Is.Null);
        });
    }

    [Test]
    public async Task Delete_WhenHaveSalesByThisClient_ShouldSuccess_Test()
    {
        //Arrange
        var client = MagicCarpetDbContext.InsertClientToDatabaseAndReturn();
        var employee = MagicCarpetDbContext.InsertEmployeeToDatabaseAndReturn();
        MagicCarpetDbContext.InsertSaleToDatabaseAndReturn(employee.Id, client.Id);
        MagicCarpetDbContext.InsertSaleToDatabaseAndReturn(employee.Id, client.Id);
        var salesBeforeDelete = MagicCarpetDbContext.GetSalesByClientId(client.Id);
        //Act
        var response = await HttpClient.DeleteAsync($"/api/clients/{client.Id}");
        //Assert
        MagicCarpetDbContext.ChangeTracker.Clear();
        var element = MagicCarpetDbContext.GetClientFromDatabase(client.Id);
        var salesAfterDelete = MagicCarpetDbContext.GetSalesByClientId(client.Id);
        var salesNoClients = MagicCarpetDbContext.GetSalesByClientId(null);
        Assert.Multiple(() =>
        {
            Assert.That(response.StatusCode, Is.EqualTo(HttpStatusCode.NoContent));
            Assert.That(element, Is.Null);
            Assert.That(salesBeforeDelete, Has.Length.EqualTo(2));
            Assert.That(salesAfterDelete, Is.Empty);
            Assert.That(salesNoClients, Has.Length.EqualTo(2));
        });
    }

    [Test]
    public async Task Delete_WhenNoFoundRecord_ShouldBadRequest_Test()
    {
        //Arrange
        MagicCarpetDbContext.InsertClientToDatabaseAndReturn();
        //Act
        var response = await HttpClient.DeleteAsync($"/api/clients/{Guid.NewGuid()}");
        //Assert
        Assert.That(response.StatusCode, Is.EqualTo(HttpStatusCode.BadRequest));
    }

    [Test]
    public async Task Delete_WhenSendWrongFormatData_ShouldBadRequest_Test()
    {
        //Act
        var response = await HttpClient.DeleteAsync($"/api/clients/id");
        //Assert
        Assert.That(response.StatusCode, Is.EqualTo(HttpStatusCode.BadRequest));
    }

    private static void AssertElement(ClientViewModel? actual, Client expected)
    {
        Assert.That(actual, Is.Not.Null);
        Assert.Multiple(() =>
        {
            Assert.That(actual.Id, Is.EqualTo(expected.Id));
            Assert.That(actual.FIO, Is.EqualTo(expected.FIO));
            Assert.That(actual.PhoneNumber, Is.EqualTo(expected.PhoneNumber));
            Assert.That(actual.DiscountSize, Is.EqualTo(expected.DiscountSize));
        });
    }

    private static ClientBindingModel CreateBindingModel(string? id = null, string fio = "fio", string phoneNumber = "+7-666-666-66-66", double discountSize = 10) =>
        new()
        {
            Id = id ?? Guid.NewGuid().ToString(),
            FIO = fio,
            PhoneNumber = phoneNumber,
            DiscountSize = discountSize
        };

    private static void AssertElement(Client? actual, ClientBindingModel expected)
    {
        Assert.That(actual, Is.Not.Null);
        Assert.Multiple(() =>
        {
            Assert.That(actual.Id, Is.EqualTo(expected.Id));
            Assert.That(actual.FIO, Is.EqualTo(expected.FIO));
            Assert.That(actual.PhoneNumber, Is.EqualTo(expected.PhoneNumber));
            Assert.That(actual.DiscountSize, Is.EqualTo(expected.DiscountSize));
        });
    }
}