using Centron.BusinessLogic;
using Centron.BusinessLogic.EmployeeArea;
using Centron.BusinessLogic.Sales.Receipts.DataAndResults;
using Centron.BusinessLogic.WebServices.Sales.Receipts;
using Centron.Data.Entities.Administration.Logins;
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 System;
using System.Collections.Generic;
using System.Linq;
using Xunit;
using Xunit.Abstractions;

namespace Centron.Tests.EndToEnd.Tests.CompanyGroupContracts
{
    public class CompanyGroupContractTests : EndToEndTest
    {
        public CompanyGroupContractTests(ITestOutputHelper testOutputHelper) 
            : base(testOutputHelper)
        {
        }

        const int Customer1I3D = 10000;
        const int Customer1ContractI3D = 10;

        const int Customer2I3D = 10003;
        const int Customer2ContractI3D = 5;

        const int Customer3I3D = 10005;
        const int Customer3ContractI3D = 19;

        const int ArticleI3D = 1191;

        public override void Execute()
        {
            // Okay, I first need company a with company b as parent-company
            // Both companies need contracts
            // And then I need to create a order at company A, with a contract of company B in a receipt-item
            // Then I insert that order in a delivery-list for company B
            // -> The receipt-item should still have the same contract

            this.PrepareDatabase();

            this.CreateOrderAndForwardToDeliveryList(Customer1I3D, Customer2ContractI3D, Customer2I3D, expectContractTakeover: true);
            this.CreateOrderAndForwardToDeliveryList(Customer1I3D, Customer3ContractI3D, Customer3I3D, expectContractTakeover: true);
            this.CreateOrderAndForwardToDeliveryList(Customer2I3D, Customer3ContractI3D, Customer3I3D, expectContractTakeover: true);

            this.CreateOrderAndForwardToDeliveryList(Customer1I3D, Customer1ContractI3D, Customer2I3D, expectContractTakeover: false);
            this.CreateOrderAndForwardToDeliveryList(Customer1I3D, Customer1ContractI3D, Customer3I3D, expectContractTakeover: false);
            this.CreateOrderAndForwardToDeliveryList(Customer2I3D, Customer2ContractI3D, Customer3I3D, expectContractTakeover: false);
        }

        private void PrepareDatabase()
        {
            this.Sql($"INSERT INTO dbo.KundeToKonzern (KundenI3D, KonzernI3D) VALUES ({Customer1I3D}, {Customer2I3D})");
            this.Sql($"INSERT INTO dbo.KundeToKonzern (KundenI3D, KonzernI3D) VALUES ({Customer2I3D}, {Customer3I3D})");
        }

        private void CreateOrderAndForwardToDeliveryList(int orderCustomerI3D, int contractI3D, int deliveryListCustomerI3D, bool expectContractTakeover)
        {
            var order = this.CreateAndSaveOrder(orderCustomerI3D, contractI3D);
            var deliveryList = this.ForwardToDeliveryList(order, deliveryListCustomerI3D);

            var deliveryListItem = deliveryList.Items.First(f => f.ArticleI3D == ArticleI3D);

            if (expectContractTakeover)
            {
                Assert.Equal(contractI3D, deliveryListItem.ContractI3D);
            }
            else
            {
                Assert.NotEqual(contractI3D, deliveryListItem.ContractI3D);
            }

            this.Verifier.Verify($"FromCustomer_{orderCustomerI3D}_Contract_{contractI3D}_ToCustomer_{deliveryListCustomerI3D}_ExpectContractTakeover_{expectContractTakeover}", deliveryListItem);
        }

        private ReceiptOrderDTO CreateAndSaveOrder(int orderCustomerI3D, int contractI3D)
        {
            // CreateOrder
            using var session = new BLSession();

            var user = session.GetBL<AppUserBL>().GetAppUser(f => f.I3D == 11);
            var loggedInUser = new LoggedInUser(user);

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

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

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

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

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

            var receiptItem = receiptItemResult.Data.ReceiptItems
                .Cast<ReceiptOrderItemDTO>()
                .FirstOrDefault(f => f.ArticleI3D == ArticleI3D);

            Assert.NotNull(receiptItem);

            receiptItem.ContractI3D = contractI3D;

            receiptOrderDTO.Items.Add(receiptItem);

            // Save Order
            using var saveSession = new BLSession();

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

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

            var savedReceiptOrderDTO = (ReceiptOrderDTO)saveResult.Data.Receipt;
            Assert.NotNull(savedReceiptOrderDTO);

            return savedReceiptOrderDTO;
        }

        private ReceiptDeliveryListDTO ForwardToDeliveryList(ReceiptOrderDTO order, int deliveryListCustomerI3D)
        {
            using var session = new BLSession();
            var user = session.GetBL<AppUserBL>().GetAppUser(f => f.I3D == 11);
            var loggedInUser = new LoggedInUser(user);

            var deliveryListResult = session.GetBL<ReceiptWebServiceBL>().CreateNewReceipt(
                CentronObjectKindNumeric.DeliveryListClass,
                loggedInUser,
                deliveryListCustomerI3D,
                new CreateReceiptData { IgnoreCallbacks = true },
                addressI3D: null,
                contactPersonI3D: null,
                insertSalutationAndAgreement: false,
                ignoreDefaultContract: false,
                insertCustomerDiscount: false);
            
            Assert.Equal(ResultStatus.Success, deliveryListResult.Status);

            var deliveryList = (ReceiptDeliveryListDTO)deliveryListResult.Data.Receipt;

            var forwardItemsResult = session.GetBL<ReceiptItemWebServiceBL>().CreateReceiptItemsFromExistingItems(
                deliveryList,
                user,
                order.ReceiptKind,
                order.Items.Select(f => f.I3D).ToList(),
                InsertReceiptTakeoverOptions.Reference,
                takeoverPrice: true,
                takeoverPurchasePrice: true,
                takeoverCostCenterCostObject: true,
                onlyTakeoverAvailableQuantity: false,
                data: new CreateReceiptItemsFromExistingItemsData { IgnoreCallbacks = true },
                doNotInsertFreeTexts: true);
            Assert.Equal(ResultStatus.Success, forwardItemsResult.Status);

            deliveryList.Items.AddRange(forwardItemsResult.Data.ReceiptItems.Cast<ReceiptDeliveryListItemDTO>());

            return deliveryList;
        }
    }
}