using System.Collections.Generic;
using System.Linq;
using Centron.BusinessLogic;
using Centron.BusinessLogic.EmployeeArea;
using Centron.BusinessLogic.Sales.Receipts.DataAndResults;
using Centron.BusinessLogic.WebServices.Sales.Receipts;
using Centron.Data.WebServices.Sales.Receipts.DeliveryLists;
using Centron.Data.WebServices.Sales.Receipts.Orders;
using Centron.Interfaces;
using Centron.Interfaces.Administration.Environment;
using Centron.Interfaces.BL;
using Centron.Interfaces.Sales.Receipts.InsertReceipts;
using Centron.Tests.EndToEnd.Infrastructure;
using CentronSoftware.Centron.WebServices.EntitiesWrongPlace.Sales.Receipts.DataAndResults;
using Xunit;
using Xunit.Abstractions;

namespace Centron.Tests.EndToEnd.TicketTests.Ticket164522;

public class Ticket164522Tests : EndToEndTest
{
    private const int SourceCustomerI3D = 10000;
    private const int ArticleI3D = 17;

    public Ticket164522Tests(ITestOutputHelper testOutputHelper)
        : base(testOutputHelper)
    {
    }

    public override void Execute()
    {
        var foreignContactPersonI3D = this.GetForeignContactPersonI3D();
        var foreignCustomerI3D = this.GetCustomerI3DFromContactPerson(foreignContactPersonI3D);

        Assert.NotEqual(SourceCustomerI3D, foreignCustomerI3D);

        var order = this.CreateOrder(SourceCustomerI3D);
        var sourceAddressI3D = order.AddressI3D;

        // Simulate "Empfaenger aendern" edge-case: contact person points to another customer,
        // while the business owner (CustomerI3D) of the source receipt stays unchanged.
        order.ContactPersonI3D = foreignContactPersonI3D;
        var savedOrder = this.SaveOrder(order);

        var deliveryList = this.ForwardOrderToDeliveryList(savedOrder);

        Assert.Equal(SourceCustomerI3D, deliveryList.CustomerI3D);
        Assert.NotEqual(foreignCustomerI3D, deliveryList.CustomerI3D);
        Assert.Equal(sourceAddressI3D, deliveryList.AddressI3D);
        Assert.Equal(savedOrder.ContactPersonI3D, deliveryList.ContactPersonI3D);
        Assert.NotNull(savedOrder.ReceiptReceiver);
        Assert.NotNull(deliveryList.ReceiptReceiver);
        Assert.Equal(savedOrder.ReceiptReceiver.AccountI3D, deliveryList.ReceiptReceiver.AccountI3D);
        Assert.Equal(savedOrder.ReceiptReceiver.CustomerNumber, deliveryList.ReceiptReceiver.CustomerNumber);
        Assert.Equal(savedOrder.ReceiptReceiver.SupplierNumber, deliveryList.ReceiptReceiver.SupplierNumber);
        Assert.Equal(savedOrder.ReceiptReceiver.CompanyName, deliveryList.ReceiptReceiver.CompanyName);
        Assert.Equal(savedOrder.ReceiptReceiver.Street, deliveryList.ReceiptReceiver.Street);
        Assert.Equal(savedOrder.ReceiptReceiver.Zip, deliveryList.ReceiptReceiver.Zip);
        Assert.Equal(savedOrder.ReceiptReceiver.City, deliveryList.ReceiptReceiver.City);
    }

    private int GetForeignContactPersonI3D()
    {
        return this.Sql<int>($@"
SELECT TOP 1 P.I3D
FROM dbo.Personen P
INNER JOIN dbo.Anschrif A ON A.I3D = P.AnschriftID
WHERE A.Kunde <> {SourceCustomerI3D}
  AND A.Status = 1
  AND P.Status = 1
ORDER BY P.I3D");
    }

    private int GetCustomerI3DFromContactPerson(int contactPersonI3D)
    {
        return this.Sql<int>($@"
SELECT A.Kunde
FROM dbo.Personen P
INNER JOIN dbo.Anschrif A ON A.I3D = P.AnschriftID
WHERE P.I3D = {contactPersonI3D}");
    }

    private ReceiptOrderDTO CreateOrder(int customerI3D)
    {
        using var session = new BLSession();

        var loggedInUser = this.GetLoggedInUser();

        var orderResult = session.GetBL<ReceiptWebServiceBL>().CreateNewReceipt(
            CentronObjectKindNumeric.OrderClass,
            loggedInUser,
            customerI3D,
            new CreateReceiptData { IgnoreCallbacks = true },
            addressI3D: null,
            contactPersonI3D: null,
            insertSalutationAndAgreement: false,
            ignoreDefaultContract: false,
            insertCustomerDiscount: false);

        Assert.Equal(ResultStatus.Success, orderResult.Status);

        var order = (ReceiptOrderDTO)orderResult.Data.Receipt;

        var newItems = session.GetBL<ReceiptItemWebServiceBL>().CreateArticleReceiptItems(
            order,
            isExternalArticle: false,
            articleI3D: ArticleI3D,
            externalArticleKind: null,
            externalArticleId: null,
            warehouseI3D: -1,
            loggedInUser).ThrowIfError();

        order.Items.AddRange(newItems.ReceiptItems.Cast<ReceiptOrderItemDTO>());

        return this.SaveOrder(order);
    }

    private ReceiptOrderDTO SaveOrder(ReceiptOrderDTO order)
    {
        using var session = new BLSession();

        var user = this.GetLoggedInUser().User;

        var saveResult = session.GetBL<ReceiptWebServiceBL>().SaveReceipt(
            order,
            user,
            new SaveReceiptData { IgnoreCallbacks = true },
            autoLockIfNewReceipt: false,
            application: CreatedThroughApplication.CentronNet,
            receiptTemplateFolderI3D: null);

        Assert.Equal(ResultStatus.Success, saveResult.Status);
        return (ReceiptOrderDTO)saveResult.Data.Receipt;
    }

    private ReceiptDeliveryListDTO ForwardOrderToDeliveryList(ReceiptOrderDTO order)
    {
        using var session = new BLSession();
        var user = this.GetLoggedInUser().User;

        var forwardResult = session.GetBL<ReceiptWebServiceBL>().ForwardReceipt(
            CentronObjectKindNumeric.DeliveryListClass,
            user,
            new ForwardReceiptData
            {
                IgnoreCallbacks = true,
                CreateReceiptData = new CreateReceiptData
                {
                    IgnoreCallbacks = true,
                },
                CreateReceiptItemsFromExistingItemsData = new List<CreateReceiptItemsFromExistingItemsData>
                {
                    new()
                    {
                        IgnoreCallbacks = true,
                    },
                },
            },
            new List<ReceiptToForward>
            {
                new()
                {
                    ReceiptKind = CentronObjectKindNumeric.OrderClass,
                    ReceiptI3D = order.I3D,
                    ReceiptItemI3Ds = order.Items.Select(f => f.I3D).ToArray(),
                },
            },
            receiptProjectLayoutItemI3DsToForward: null,
            takeoverOptions: InsertReceiptTakeoverOptions.Reference,
            onlyTakeoverAvailableQuantity: false,
            ignoreDefaultContract: false);

        Assert.Equal(ResultStatus.Success, forwardResult.Status);
        return (ReceiptDeliveryListDTO)forwardResult.Data.Receipt;
    }
}