using Centron.BusinessLogic;
using Centron.BusinessLogic.WebServices.Sales.Support;
using Centron.Data.WebServices.Sales.Support;
using Centron.Tests.EndToEnd.Infrastructure;
using System;
using Xunit.Abstractions;
using Centron.BusinessLogic.WebServices.Warehousing;
using CentronSoftware.Centron.WebServices.Entities.Warehousing;
using Centron.Interfaces;
using Centron.Interfaces.BL;
using Centron.Controls.Shared;

namespace Centron.Tests.EndToEnd.Tests.Helpdesk
{
    public class HelpdeskTimerTests : EndToEndTest
    {
        private readonly int _referenceHelpdeskI3D = 10491;
        private readonly int _referenceTimerI3D = 10521;
        private readonly int _referenceArticleI3D = 4361;
        private int _referenceArticleWorkItemI3D;

        public HelpdeskTimerTests(ITestOutputHelper testOutputHelper)
            : base(testOutputHelper)
        {
            this.Verifier.Settings.IgnoreProperty<HelpdeskTimerDTO>(f => f.CreatedVersion);
        }

        public override void Execute()
        {
            this.PrepareArticleWorkItems();

            this.GetHelpdeskTimers();
            // ISSUE WITH THREATING when saving helpdesk timers
            // this.SaveHelpdeskTimer();

            // this.CreateTimersForArticle();
        }

        private void GetHelpdeskTimers()
        {
            using (var session = new BLSession())
            {
                var timers = session.GetBL<HelpdeskTimerWebServiceBL>().GetActivHelpdeskTimer(this._referenceHelpdeskI3D);
                this.Verifier.Verify("HelpdeskTimers", timers);
            }

            using (var session = new BLSession())
            {
                var timer = session.GetBL<HelpdeskTimerWebServiceBL>().GetHelpdeskTimerByI3D(this._referenceTimerI3D);
                this.Verifier.Verify("HelpdeskTimer", timer);
            }
        }

        private void SaveHelpdeskTimer()
        {
            var timerI3D = this.SaveNewHelpdeskTimer();
            this.UpdateNewHelpdeskTimer(timerI3D);
            this.LoadLogs(timerI3D);
        }

        private int SaveNewHelpdeskTimer()
        {
            int? timerI3D;

            using (var session = new BLSession())
            {
                var timer = new HelpdeskTimerDTO
                {
                    HelpdeskI3D = this._referenceHelpdeskI3D,

                    Start = new DateTime(2022, 1, 1, 12, 0, 0),
                    Stop = new DateTime(2022, 1, 1, 13, 0, 0),

                    InternalNote = "internal note here",
                    ExternalNote = "external note here",

                    ArticleWorkItemI3D = this._referenceArticleWorkItemI3D,
                };

                timerI3D = session.GetBL<HelpdeskTimerWebServiceBL>().SaveHelpdeskTimer(timer, this.GetLoggedInUser());
            }

            if (timerI3D.HasValue == false)
                throw new Exception("timerI3D is null");

            using (var session = new BLSession())
            {
                var savedTimer = session.GetBL<HelpdeskTimerWebServiceBL>().GetHelpdeskTimerByI3D(timerI3D.Value);
                this.Verifier.Verify("SavedTimer", savedTimer);
            }

            return timerI3D.Value;
        }

        private void UpdateNewHelpdeskTimer(int timerI3D)
        {
            HelpdeskTimerDTO savedTimer = null;

            using (var session = new BLSession())
            {
                savedTimer = session.GetBL<HelpdeskTimerWebServiceBL>().GetHelpdeskTimerByI3D(timerI3D);
            }

            using (var session = new BLSession())
            {
                savedTimer.Start = savedTimer.Start.AddHours(2);
                savedTimer.Stop = savedTimer.Stop.AddHours(2);

                savedTimer.Calculable = true;
                savedTimer.IsPlanned = true;

                savedTimer.InternalNote += " but this time with more text";
                savedTimer.ExternalNote += " but this time with more text";

                session.GetBL<HelpdeskTimerWebServiceBL>().SaveHelpdeskTimerWithSignature(savedTimer, this.GetLoggedInUser(), new byte[42]);
            }

            using (var session = new BLSession())
            {
                var updatedTimer = session.GetBL<HelpdeskTimerWebServiceBL>().GetHelpdeskTimerByI3D(timerI3D);
                this.Verifier.Verify("UpdatedTimer", updatedTimer);
            }
        }

        private void LoadLogs(int timerI3D)
        {
            using var session = new BLSession();

            var logs = session.GetBL<HelpdeskTimerLogWebServiceBL>().GetLogs(timerI3D);
            this.Verifier.Verify("Logs", logs);
        }

        private void PrepareArticleWorkItems()
        {
            // this is not a test, the db does not contain any articleworkitems so we have to create them first

            this._referenceArticleWorkItemI3D = SaveArticleWorkItemInternal(new ArticleWorkItemDTO
            {
                TextInRTF = TextHelper.PlainToRtf("the first cold shower"),
                Caption = "the first cold shower",
                DurationInHours = 2.5f,
            });

            SaveArticleWorkItemInternal(new ArticleWorkItemDTO
            {
                TextInRTF = TextHelper.PlainToRtf("even the monkey seems to want"),
                Caption = "even the monkey seems to want",
                DurationInHours = 1f,
            });

            SaveArticleWorkItemInternal(new ArticleWorkItemDTO
            {
                // no TextInRTF, testing if the fallback works
                Caption = "a little coat of straw",
                DurationInHours = 10f,
            });

            int SaveArticleWorkItemInternal(ArticleWorkItemDTO articleWorkItem)
            {
                articleWorkItem.ObjectI3D = this._referenceArticleI3D;
                articleWorkItem.ObjectKind = (int)CentronObjectKindNumeric.Article;

                using var session = new BLSession();
                var savedArticleWorkItem = session.GetBL<ArticleWorkItemWebserviceBL>().SaveArticleWorkItem(articleWorkItem, this.GetLoggedInUser()).ThrowIfError();

                return savedArticleWorkItem.I3D;
            }
        }

        private void CreateTimersForArticle()
        {
            using var session = new BLSession();

            var timers = session.GetBL<HelpdeskTimerWebServiceBL>().CreateTimersForArticle(this.GetLoggedInUser().User,
                this._referenceHelpdeskI3D,
                this._referenceArticleI3D,
                new DateTime(2020, 1, 1, 12, 0, 0));

            this.Verifier.Verify("TimersCreatedFromArticle", timers);
        }
    }
}