using MagicCarpetContracts.BindingModels;
using MagicCarpetContracts.Enums;
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 SaleControllerTests : BaseWebApiControllerTest
{
    private string _clientId;
    private string _employeeId;
    private string _tourId;

    [SetUp]
    public void SetUp()
    {
        _clientId = MagicCarpetDbContext.InsertClientToDatabaseAndReturn().Id;
        _employeeId = MagicCarpetDbContext.InsertEmployeeToDatabaseAndReturn().Id;
        _tourId = MagicCarpetDbContext.InsertTourToDatabaseAndReturn().Id;
    }

    [TearDown]
    public void TearDown()
    {
        MagicCarpetDbContext.RemoveSalesFromDatabase();
        MagicCarpetDbContext.RemoveEmployeesFromDatabase();
        MagicCarpetDbContext.RemoveClientsFromDatabase();
        MagicCarpetDbContext.RemoveToursFromDatabase();
    }

    [Test]
    public async Task GetList_WhenHaveRecords_ShouldSuccess_Test()
    {
        //Arrange
        var sale = MagicCarpetDbContext.InsertSaleToDatabaseAndReturn(_employeeId, clientId: _clientId, sum: 10, tours: [(_tourId, 10, 1.1)]);
        MagicCarpetDbContext.InsertSaleToDatabaseAndReturn(_employeeId, tours: [(_tourId, 10, 1.1)]);
        MagicCarpetDbContext.InsertSaleToDatabaseAndReturn(_employeeId, tours: [(_tourId, 10, 1.1)]);
        //Act
        var response = await HttpClient.GetAsync($"/api/sales/getrecords?fromDate={DateTime.UtcNow.AddDays(-1):MM/dd/yyyy HH:mm:ss}&toDate={DateTime.UtcNow.AddDays(1):MM/dd/yyyy HH:mm:ss}");
        //Assert
        Assert.That(response.StatusCode, Is.EqualTo(HttpStatusCode.OK));
        var data = await GetModelFromResponseAsync<List<SaleViewModel>>(response);
        Assert.Multiple(() =>
        {
            Assert.That(data, Is.Not.Null);
            Assert.That(data, Has.Count.EqualTo(3));
        });
        AssertElement(data.First(x => x.Sum == sale.Sum), sale);
    }

    [Test]
    public async Task GetList_WhenNoRecords_ShouldSuccess_Test()
    {
        //Act
        var response = await HttpClient.GetAsync($"/api/sales/getrecords?fromDate={DateTime.UtcNow.AddDays(-1):MM/dd/yyyy HH:mm:ss}&toDate={DateTime.UtcNow.AddDays(1):MM/dd/yyyy HH:mm:ss}");
        //Assert
        Assert.That(response.StatusCode, Is.EqualTo(HttpStatusCode.OK));
        var data = await GetModelFromResponseAsync<List<SaleViewModel>>(response);
        Assert.Multiple(() =>
        {
            Assert.That(data, Is.Not.Null);
            Assert.That(data, Has.Count.EqualTo(0));
        });
    }

    [Test]
    public async Task GetList_ByPeriod_ShouldSuccess_Test()
    {
        //Arrange
        MagicCarpetDbContext.InsertSaleToDatabaseAndReturn(_employeeId, _clientId, saleDate: DateTime.UtcNow.AddDays(-1).AddMinutes(-3), tours: [(_tourId, 1, 1.1)]);
        MagicCarpetDbContext.InsertSaleToDatabaseAndReturn(_employeeId, _clientId, saleDate: DateTime.UtcNow.AddDays(-1).AddMinutes(3), tours: [(_tourId, 1, 1.1)]);
        MagicCarpetDbContext.InsertSaleToDatabaseAndReturn(_employeeId, null, saleDate: DateTime.UtcNow.AddDays(1).AddMinutes(-3), tours: [(_tourId, 1, 1.1)]);
        MagicCarpetDbContext.InsertSaleToDatabaseAndReturn(_employeeId, null, saleDate: DateTime.UtcNow.AddDays(1).AddMinutes(3), tours: [(_tourId, 1, 1.1)]);
        //Act
        var response = await HttpClient.GetAsync($"/api/sales/getrecords?fromDate={DateTime.UtcNow.AddDays(-1):MM/dd/yyyy HH:mm:ss}&toDate={DateTime.UtcNow.AddDays(1):MM/dd/yyyy HH:mm:ss}");
        //Assert
        Assert.That(response.StatusCode, Is.EqualTo(HttpStatusCode.OK));
        var data = await GetModelFromResponseAsync<List<SaleViewModel>>(response);
        Assert.Multiple(() =>
        {
            Assert.That(data, Is.Not.Null);
            Assert.That(data, Has.Count.EqualTo(2));
        });
    }

    [Test]
    public async Task GetList_ByPeriod_WhenDateIsIncorrect_ShouldBadRequest_Test()
    {
        //Act
        var response = await HttpClient.GetAsync($"/api/sales/getrecords?fromDate={DateTime.UtcNow.AddDays(1):MM/dd/yyyy HH:mm:ss}&toDate={DateTime.UtcNow.AddDays(-1):MM/dd/yyyy HH:mm:ss}");
        //Assert
        Assert.That(response.StatusCode, Is.EqualTo(HttpStatusCode.BadRequest));
    }

    [Test]
    public async Task GetList_ByEmployeeId_ShouldSuccess_Test()
    {
        //Arrange
        var employee = MagicCarpetDbContext.InsertEmployeeToDatabaseAndReturn(fio: "Other employee");
        MagicCarpetDbContext.InsertSaleToDatabaseAndReturn(_employeeId, _clientId, tours: [(_tourId, 1, 1.1)]);
        MagicCarpetDbContext.InsertSaleToDatabaseAndReturn(_employeeId, _clientId, tours: [(_tourId, 1, 1.1)]);
        MagicCarpetDbContext.InsertSaleToDatabaseAndReturn(employee.Id, null, tours: [(_tourId, 1, 1.1)]);
        //Act
        var response = await HttpClient.GetAsync($"/api/sales/getemployeerecords?id={_employeeId}&fromDate={DateTime.UtcNow.AddDays(-1):MM/dd/yyyy HH:mm:ss}&toDate={DateTime.UtcNow.AddDays(1):MM/dd/yyyy HH:mm:ss}");
        //Assert
        Assert.That(response.StatusCode, Is.EqualTo(HttpStatusCode.OK));
        var data = await GetModelFromResponseAsync<List<SaleViewModel>>(response);
        Assert.That(data, Is.Not.Null);
        Assert.Multiple(() =>
        {
            Assert.That(data, Has.Count.EqualTo(2));
            Assert.That(data.All(x => x.EmployeeId == _employeeId));
        });
    }

    [Test]
    public async Task GetList_ByEmployeeId_WhenNoRecords_ShouldSuccess_Test()
    {
        //Arrange
        var employee = MagicCarpetDbContext.InsertEmployeeToDatabaseAndReturn(fio: "Other employee");
        MagicCarpetDbContext.InsertSaleToDatabaseAndReturn(_employeeId, _clientId, tours: [(_tourId, 1, 1.1)]);
        //Act
        var response = await HttpClient.GetAsync($"/api/sales/getemployeerecords?id={employee.Id}&fromDate={DateTime.UtcNow.AddDays(-1):MM/dd/yyyy HH:mm:ss}&toDate={DateTime.UtcNow.AddDays(1):MM/dd/yyyy HH:mm:ss}");
        //Assert
        Assert.That(response.StatusCode, Is.EqualTo(HttpStatusCode.OK));
        var data = await GetModelFromResponseAsync<List<SaleViewModel>>(response);
        Assert.That(data, Is.Not.Null);
        Assert.That(data, Has.Count.EqualTo(0));
    }

    [Test]
    public async Task GetList_ByEmployeeId_WhenDateIsIncorrect_ShouldBadRequest_Test()
    {
        //Act
        var response = await HttpClient.GetAsync($"/api/sales/getemployeerecords?id={_employeeId}&fromDate={DateTime.UtcNow.AddDays(1):MM/dd/yyyy HH:mm:ss}&toDate={DateTime.UtcNow.AddDays(-1):MM/dd/yyyy HH:mm:ss}");
        //Assert
        Assert.That(response.StatusCode, Is.EqualTo(HttpStatusCode.BadRequest));
    }

    [Test]
    public async Task GetList_ByEmployeeId_WhenIdIsIncorrect_ShouldBadRequest_Test()
    {
        //Act
        var response = await HttpClient.GetAsync($"/api/sales/getemployeerecords?id=Id&fromDate={DateTime.UtcNow.AddDays(-1):MM/dd/yyyy HH:mm:ss}&toDate={DateTime.UtcNow.AddDays(1):MM/dd/yyyy HH:mm:ss}");
        //Assert
        Assert.That(response.StatusCode, Is.EqualTo(HttpStatusCode.BadRequest));
    }

    [Test]
    public async Task GetList_ByClientId_ShouldSuccess_Test()
    {
        //Arrange
        var client = MagicCarpetDbContext.InsertClientToDatabaseAndReturn(fio: "Other fio", phoneNumber: "+8-888-888-88-88");
        MagicCarpetDbContext.InsertSaleToDatabaseAndReturn(_employeeId, _clientId, tours: [(_tourId, 1, 1.1)]);
        MagicCarpetDbContext.InsertSaleToDatabaseAndReturn(_employeeId, _clientId, tours: [(_tourId, 1, 1.1)]);
        MagicCarpetDbContext.InsertSaleToDatabaseAndReturn(_employeeId, client.Id, tours: [(_tourId, 1, 1.1)]);
        MagicCarpetDbContext.InsertSaleToDatabaseAndReturn(_employeeId, null, tours: [(_tourId, 1, 1.1)]);
        //Act
        var response = await HttpClient.GetAsync($"/api/sales/getclientrecords?id={_clientId}&fromDate={DateTime.UtcNow.AddDays(-1):MM/dd/yyyy HH:mm:ss}&toDate={DateTime.UtcNow.AddDays(1):MM/dd/yyyy HH:mm:ss}");
        //Assert
        Assert.That(response.StatusCode, Is.EqualTo(HttpStatusCode.OK));
        var data = await GetModelFromResponseAsync<List<SaleViewModel>>(response);
        Assert.That(data, Is.Not.Null);
        Assert.Multiple(() =>
        {
            Assert.That(data, Has.Count.EqualTo(2));
            Assert.That(data.All(x => x.ClientId == _clientId));
        });
    }

    [Test]
    public async Task GetList_ByClientId_WhenNoRecords_ShouldSuccess_Test()
    {
        //Arrange
        var client = MagicCarpetDbContext.InsertClientToDatabaseAndReturn(fio: "Other client", phoneNumber: "+8-888-888-88-88");
        MagicCarpetDbContext.InsertSaleToDatabaseAndReturn(_employeeId, _clientId, tours: [(_tourId, 1, 1.1)]);
        //Act
        var response = await HttpClient.GetAsync($"/api/sales/getclientrecords?id={client.Id}&fromDate={DateTime.UtcNow.AddDays(-1):MM/dd/yyyy HH:mm:ss}&toDate={DateTime.UtcNow.AddDays(1):MM/dd/yyyy HH:mm:ss}");
        //Assert
        Assert.That(response.StatusCode, Is.EqualTo(HttpStatusCode.OK));
        var data = await GetModelFromResponseAsync<List<SaleViewModel>>(response);
        Assert.That(data, Is.Not.Null);
        Assert.That(data, Has.Count.EqualTo(0));
    }

    [Test]
    public async Task GetList_ByClientId_WhenDateIsIncorrect_ShouldBadRequest_Test()
    {
        //Act
        var response = await HttpClient.GetAsync($"/api/sales/getclientrecords?id={_clientId}&fromDate={DateTime.UtcNow.AddDays(1):MM/dd/yyyy HH:mm:ss}&toDate={DateTime.UtcNow.AddDays(-1):MM/dd/yyyy HH:mm:ss}");
        //Assert
        Assert.That(response.StatusCode, Is.EqualTo(HttpStatusCode.BadRequest));
    }

    [Test]
    public async Task GetList_ByClientId_WhenIdIsIncorrect_ShouldBadRequest_Test()
    {
        //Act
        var response = await HttpClient.GetAsync($"/api/sales/getclientrecords?id=Id&fromDate={DateTime.UtcNow.AddDays(-1):MM/dd/yyyy HH:mm:ss}&toDate={DateTime.UtcNow.AddDays(1):MM/dd/yyyy HH:mm:ss}");
        //Assert
        Assert.That(response.StatusCode, Is.EqualTo(HttpStatusCode.BadRequest));
    }

    [Test]
    public async Task GetList_ByTourId_ShouldSuccess_Test()
    {
        //Arrange
        var tour = MagicCarpetDbContext.InsertTourToDatabaseAndReturn(tourName: "Other name");
        MagicCarpetDbContext.InsertSaleToDatabaseAndReturn(_employeeId, _clientId, tours: [(_tourId, 5, 1.1)]);
        MagicCarpetDbContext.InsertSaleToDatabaseAndReturn(_employeeId, _clientId, tours: [(_tourId, 1, 1.1), (tour.Id, 4, 1.1)]);
        MagicCarpetDbContext.InsertSaleToDatabaseAndReturn(_employeeId, null, tours: [(tour.Id, 1, 1.1)]);
        MagicCarpetDbContext.InsertSaleToDatabaseAndReturn(_employeeId, null, tours: [(tour.Id, 1, 1.1), (_tourId, 1, 1.1)]);
        //Act
        var response = await HttpClient.GetAsync($"/api/sales/gettourrecords?id={_tourId}&fromDate={DateTime.UtcNow.AddDays(-1):MM/dd/yyyy HH:mm:ss}&toDate={DateTime.UtcNow.AddDays(1):MM/dd/yyyy HH:mm:ss}");
        //Assert
        Assert.That(response.StatusCode, Is.EqualTo(HttpStatusCode.OK));
        var data = await GetModelFromResponseAsync<List<SaleViewModel>>(response);
        Assert.That(data, Is.Not.Null);
        Assert.Multiple(() =>
        {
            Assert.That(data, Has.Count.EqualTo(3));
            Assert.That(data.All(x => x.Tours.Any(y => y.TourId == _tourId)));
        });
    }

    [Test]
    public async Task GetList_ByTourId_WhenNoRecords_ShouldSuccess_Test()
    {
        //Arrange
        var tour = MagicCarpetDbContext.InsertTourToDatabaseAndReturn(tourName: "Other tour");
        MagicCarpetDbContext.InsertSaleToDatabaseAndReturn(_employeeId, _clientId, tours: [(_tourId, 1, 1.1)]);
        //Act
        var response = await HttpClient.GetAsync($"/api/sales/gettourrecords?id={tour.Id}&fromDate={DateTime.UtcNow.AddDays(-1):MM/dd/yyyy HH:mm:ss}&toDate={DateTime.UtcNow.AddDays(1):MM/dd/yyyy HH:mm:ss}");
        //Assert
        Assert.That(response.StatusCode, Is.EqualTo(HttpStatusCode.OK));
        var data = await GetModelFromResponseAsync<List<SaleViewModel>>(response);
        Assert.That(data, Is.Not.Null);
        Assert.That(data, Has.Count.EqualTo(0));
    }

    [Test]
    public async Task GetList_ByTourId_WhenDateIsIncorrect_ShouldBadRequest_Test()
    {
        //Act
        var response = await HttpClient.GetAsync($"/api/sales/gettourrecords?id={_tourId}&fromDate={DateTime.UtcNow.AddDays(1):MM/dd/yyyy HH:mm:ss}&toDate={DateTime.UtcNow.AddDays(-1):MM/dd/yyyy HH:mm:ss}");
        //Assert
        Assert.That(response.StatusCode, Is.EqualTo(HttpStatusCode.BadRequest));
    }

    [Test]
    public async Task GetList_ByTourId_WhenIdIsIncorrect_ShouldBadRequest_Test()
    {
        //Act
        var response = await HttpClient.GetAsync($"/api/sales/gettourrecords?id=Id&fromDate={DateTime.UtcNow.AddDays(-1):MM/dd/yyyy HH:mm:ss}&toDate={DateTime.UtcNow.AddDays(1):MM/dd/yyyy HH:mm:ss}");
        //Assert
        Assert.That(response.StatusCode, Is.EqualTo(HttpStatusCode.BadRequest));
    }

    [Test]
    public async Task GetElement_ById_WhenHaveRecord_ShouldSuccess_Test()
    {
        //Arrange
        var sale = MagicCarpetDbContext.InsertSaleToDatabaseAndReturn(_employeeId, _clientId, tours: [(_tourId, 5, 1.1)]);
        //Act
        var response = await HttpClient.GetAsync($"/api/sales/getrecord/{sale.Id}");
        //Assert
        Assert.That(response.StatusCode, Is.EqualTo(HttpStatusCode.OK));
        AssertElement(await GetModelFromResponseAsync<SaleViewModel>(response), sale);
    }

    [Test]
    public async Task GetElement_ById_WhenNoRecord_ShouldNotFound_Test()
    {
        //Arrange
        MagicCarpetDbContext.InsertSaleToDatabaseAndReturn(_employeeId, _clientId, tours: [(_tourId, 5, 1.1)]);
        //Act
        var response = await HttpClient.GetAsync($"/api/sales/getrecord/{Guid.NewGuid()}");
        //Assert
        Assert.That(response.StatusCode, Is.EqualTo(HttpStatusCode.NotFound));
    }

    [Test]
    public async Task GetElement_ById_WhenRecordHasCanceled_ShouldSuccess_Test()
    {
        //Arrange
        var sale = MagicCarpetDbContext.InsertSaleToDatabaseAndReturn(_employeeId, _clientId, tours: [(_tourId, 1, 1.2)], isCancel: true);
        //Act
        var response = await HttpClient.GetAsync($"/api/sales/getrecord/{sale.Id}");
        //Assert
        Assert.That(response.StatusCode, Is.EqualTo(HttpStatusCode.OK));
    }

    [Test]
    public async Task GetElement_ById_WhenIdIsIncorrect_ShouldBadRequest_Test()
    {
        //Act
        var response = await HttpClient.GetAsync($"/api/sales/getrecord/Id");
        //Assert
        Assert.That(response.StatusCode, Is.EqualTo(HttpStatusCode.BadRequest));
    }

    [Test]
    public async Task Post_ShouldSuccess_Test()
    {
        //Arrange
        MagicCarpetDbContext.InsertSaleToDatabaseAndReturn(_employeeId, null, tours: [(_tourId, 5, 1.1)]);
        var saleModel = CreateModel(_employeeId, _clientId, _tourId);
        //Act
        var response = await HttpClient.PostAsync($"/api/sales/sale", MakeContent(saleModel));
        //Assert
        Assert.That(response.StatusCode, Is.EqualTo(HttpStatusCode.NoContent));
        AssertElement(MagicCarpetDbContext.GetSalesByClientId(_clientId)[0], saleModel);
    }

    [Test]
    public async Task Post_WhenNoClient_ShouldSuccess_Test()
    {
        //Arrange
        MagicCarpetDbContext.InsertSaleToDatabaseAndReturn(_employeeId, _clientId, tours: [(_tourId, 5, 1.1)]);
        var saleModel = CreateModel(_employeeId, null, _tourId);
        //Act
        var response = await HttpClient.PostAsync($"/api/sales/sale", MakeContent(saleModel));
        //Assert
        Assert.That(response.StatusCode, Is.EqualTo(HttpStatusCode.NoContent));
        AssertElement(MagicCarpetDbContext.GetSalesByClientId(null)[0], saleModel);
    }

    [Test]
    public async Task Post_WhenDataIsIncorrect_ShouldBadRequest_Test()
    {
        //Arrange
        var saleId = Guid.NewGuid().ToString();
        var saleModelWithIdIncorrect = new SaleBindingModel { Id = "Id", EmployeeId = _employeeId, ClientId = _clientId, DiscountType = 1, Tours = [new SaleTourBindingModel { SaleId = saleId, TourId = _tourId, Count = 10, Price = 1.1 }] };
        var saleModelWithEmployeeIdIncorrect = new SaleBindingModel { Id = saleId, EmployeeId = "Id", ClientId = _clientId, DiscountType = 1, Tours = [new SaleTourBindingModel { SaleId = saleId, TourId = _tourId, Count = 10, Price = 1.1 }] };
        var saleModelWithClientIdIncorrect = new SaleBindingModel { Id = saleId, EmployeeId = _employeeId, ClientId = "Id", DiscountType = 1, Tours = [new SaleTourBindingModel { SaleId = saleId, TourId = _tourId, Count = 10, Price = 1.1 }] };
        var saleModelWithToursIncorrect = new SaleBindingModel { Id = saleId, EmployeeId = _employeeId, ClientId = _clientId, DiscountType = 1, Tours = null };
        var saleModelWithTourIdIncorrect = new SaleBindingModel { Id = saleId, EmployeeId = _employeeId, ClientId = _clientId, DiscountType = 1, Tours = [new SaleTourBindingModel { SaleId = saleId, TourId = "Id", Count = 10, Price = 1.1 }] };
        var saleModelWithCountIncorrect = new SaleBindingModel { Id = saleId, EmployeeId = _employeeId, ClientId = _clientId, DiscountType = 1, Tours = [new SaleTourBindingModel { SaleId = saleId, TourId = _tourId, Count = -10, Price = 1.1 }] };
        var saleModelWithPriceIncorrect = new SaleBindingModel { Id = saleId, EmployeeId = _employeeId, ClientId = _clientId, DiscountType = 1, Tours = [new SaleTourBindingModel { SaleId = saleId, TourId = _tourId, Count = 10, Price = -1.1 }] };
        //Act
        var responseWithIdIncorrect = await HttpClient.PostAsync($"/api/sales/sale", MakeContent(saleModelWithIdIncorrect));
        var responseWithEmployeeIdIncorrect = await HttpClient.PostAsync($"/api/sales/sale", MakeContent(saleModelWithEmployeeIdIncorrect));
        var responseWithClientIdIncorrect = await HttpClient.PostAsync($"/api/sales/sale", MakeContent(saleModelWithClientIdIncorrect));
        var responseWithToursIncorrect = await HttpClient.PostAsync($"/api/sales/sale", MakeContent(saleModelWithToursIncorrect));
        var responseWithTourIdIncorrect = await HttpClient.PostAsync($"/api/sales/sale", MakeContent(saleModelWithTourIdIncorrect));
        var responseWithCountIncorrect = await HttpClient.PostAsync($"/api/sales/sale", MakeContent(saleModelWithCountIncorrect));
        var responseWithPriceIncorrect = await HttpClient.PostAsync($"/api/sales/sale", MakeContent(saleModelWithPriceIncorrect));
        //Assert
        Assert.Multiple(() =>
        {
            Assert.That(responseWithIdIncorrect.StatusCode, Is.EqualTo(HttpStatusCode.BadRequest), "EmployeeId is incorrect");
            Assert.That(responseWithEmployeeIdIncorrect.StatusCode, Is.EqualTo(HttpStatusCode.BadRequest), "EmployeeId is incorrect");
            Assert.That(responseWithClientIdIncorrect.StatusCode, Is.EqualTo(HttpStatusCode.BadRequest), "ClientId is incorrect");
            Assert.That(responseWithToursIncorrect.StatusCode, Is.EqualTo(HttpStatusCode.BadRequest), "Tours is incorrect");
            Assert.That(responseWithTourIdIncorrect.StatusCode, Is.EqualTo(HttpStatusCode.BadRequest), "TourId is incorrect");
            Assert.That(responseWithCountIncorrect.StatusCode, Is.EqualTo(HttpStatusCode.BadRequest), "Count is incorrect");
            Assert.That(responseWithPriceIncorrect.StatusCode, Is.EqualTo(HttpStatusCode.BadRequest), "Price is incorrect");
        });
    }

    [Test]
    public async Task Post_WhenSendEmptyData_ShouldBadRequest_Test()
    {
        //Act
        var response = await HttpClient.PostAsync($"/api/sales/sale", 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/sales/sale", MakeContent(new { Data = "test", Position = 10 }));
        //Assert
        Assert.That(response.StatusCode, Is.EqualTo(HttpStatusCode.BadRequest));
    }

    [Test]
    public async Task Delete_ShouldSuccess_Test()
    {
        //Arrange
        var sale = MagicCarpetDbContext.InsertSaleToDatabaseAndReturn(_employeeId, _clientId, tours: [(_tourId, 5, 1.1)]);
        //Act
        var response = await HttpClient.DeleteAsync($"/api/sales/cancel/{sale.Id}");
        MagicCarpetDbContext.ChangeTracker.Clear();
        //Assert
        Assert.Multiple(() =>
        {
            Assert.That(response.StatusCode, Is.EqualTo(HttpStatusCode.NoContent));
            Assert.That(MagicCarpetDbContext.GetSaleFromDatabaseById(sale.Id)!.IsCancel);
        });
    }

    [Test]
    public async Task Delete_WhenNoFoundRecord_ShouldBadRequest_Test()
    {
        //Arrange
        MagicCarpetDbContext.InsertSaleToDatabaseAndReturn(_employeeId, _clientId, tours: [(_tourId, 5, 1.1)]);
        //Act
        var response = await HttpClient.DeleteAsync($"/api/sales/cancel/{Guid.NewGuid()}");
        //Assert
        Assert.That(response.StatusCode, Is.EqualTo(HttpStatusCode.BadRequest));
    }

    [Test]
    public async Task Delete_WhenIsCanceled_ShouldBadRequest_Test()
    {
        //Arrange
        var sale = MagicCarpetDbContext.InsertSaleToDatabaseAndReturn(_employeeId, _clientId, tours: [(_tourId, 5, 1.1)], isCancel: true);
        //Act
        var response = await HttpClient.DeleteAsync($"/api/sales/cancel/{sale.Id}");
        //Assert
        Assert.That(response.StatusCode, Is.EqualTo(HttpStatusCode.BadRequest));
    }

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

    private static void AssertElement(SaleViewModel? actual, Sale expected)
    {
        Assert.That(actual, Is.Not.Null);
        Assert.Multiple(() =>
        {
            Assert.That(actual.Id, Is.EqualTo(expected.Id));
            Assert.That(actual.EmployeeFIO, Is.EqualTo(expected.Employee!.FIO));
            Assert.That(actual.ClientFIO, Is.EqualTo(expected.Client?.FIO));
            Assert.That(actual.DiscountType, Is.EqualTo(expected.DiscountType.ToString()));
            Assert.That(actual.Discount, Is.EqualTo(expected.Discount));
            Assert.That(actual.IsCancel, Is.EqualTo(expected.IsCancel));
        });

        if (expected.SaleTours is not null)
        {
            Assert.That(actual.Tours, Is.Not.Null);
            Assert.That(actual.Tours, Has.Count.EqualTo(expected.SaleTours.Count));
            for (int i = 0; i < actual.Tours.Count; ++i)
            {
                Assert.Multiple(() =>
                {
                    Assert.That(actual.Tours[i].TourName, Is.EqualTo(expected.SaleTours[i].Tour!.TourName));
                    Assert.That(actual.Tours[i].Count, Is.EqualTo(expected.SaleTours[i].Count));
                });
            }
        }
        else
        {
            Assert.That(actual.Tours, Is.Null);
        }
    }

    private static SaleBindingModel CreateModel(string employeeId, string? clientId, string tourId, string? id = null, DiscountType discountType = DiscountType.OnSale, int count = 1, double price = 1.1)
    {
        var saleId = id ?? Guid.NewGuid().ToString();
        return new()
        {
            Id = saleId,
            EmployeeId = employeeId,
            ClientId = clientId,
            DiscountType = (int)discountType,
            Tours = [new SaleTourBindingModel { SaleId = saleId, TourId = tourId, Count = count, Price = price }]
        };
    }

    private static void AssertElement(Sale? actual, SaleBindingModel expected)
    {
        Assert.That(actual, Is.Not.Null);
        Assert.Multiple(() =>
        {
            Assert.That(actual.EmployeeId, Is.EqualTo(expected.EmployeeId));
            Assert.That(actual.ClientId, Is.EqualTo(expected.ClientId));
            Assert.That((int)actual.DiscountType, Is.EqualTo(expected.DiscountType));
            Assert.That(!actual.IsCancel);
        });

        if (expected.Tours is not null)
        {
            Assert.That(actual.SaleTours, Is.Not.Null);
            Assert.That(actual.SaleTours, Has.Count.EqualTo(expected.Tours.Count));
            for (int i = 0; i < actual.SaleTours.Count; ++i)
            {
                Assert.Multiple(() =>
                {
                    Assert.That(actual.SaleTours[i].TourId, Is.EqualTo(expected.Tours[i].TourId));
                    Assert.That(actual.SaleTours[i].Count, Is.EqualTo(expected.Tours[i].Count));
                    Assert.That(actual.SaleTours[i].Price, Is.EqualTo(expected.Tours[i].Price));
                });
            }
        }
        else
        {
            Assert.That(actual.SaleTours, Is.Null);
        }
    }
}