using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using Tango.BL;
using Tango.Core;
using Tango.Core.DI;
using Tango.Insights;
using Tango.Integration.ExternalBridge;
using Tango.Logging;
using Tango.PPC.Common.Application;
using Tango.PPC.Common.Connection;
using Tango.PPC.Common.ExternalBridge;
using Tango.PPC.Shared.Insights;
using Tango.Settings;

namespace Tango.PPC.Common.Insights
{
    [TangoCreateWhenRegistered]
    public class DefaultInsightsService : ExtendedObject, IInsightsService, IExternalBridgeRequestHandler
    {
        private InsightsListener _listener;

        private IMachineProvider MachineProvider { get; set; }

        public DefaultInsightsService(IPPCExternalBridgeService externalBridge, IMachineProvider machineProvider, IPPCApplicationManager applicationManager)
        {
            externalBridge.RegisterRequestHandler(this);
            MachineProvider = machineProvider;
            applicationManager.ApplicationStarted += ApplicationManager_ApplicationStarted;
        }

        private void ApplicationManager_ApplicationStarted(object sender, EventArgs e)
        {
            Task.Factory.StartNew(() =>
            {
                try
                {
                    var settings = SettingsManager.Default.GetOrCreate<PPCSettings>();
                    settings.Save();

                    if (settings.InsightsEnabled)
                    {
                        LogManager.Log("Starting insights service...");

                        _listener = new InsightsListener(MachineProvider.MachineOperator);
                        _listener.SamplingInterval = settings.InsightsSamplingInterval;
                        _listener.StorageCleanupInterval = settings.InsightsStorageCleanupInterval;
                        _listener.MaxStorageDuration = settings.InsightsMaxStorageDuration;

                        LogManager.Log($"Insights configuration:\nSampling Interval: {_listener.SamplingInterval}\nStorage Cleanup Interval: {_listener.StorageCleanupInterval}\nMax Storage Duration: {_listener.MaxStorageDuration}");

                        _listener.Start();
                    }
                    else
                    {
                        LogManager.Log("Insights service is disabled.", LogCategory.Warning);
                    }
                }
                catch (Exception ex)
                {
                    LogManager.Log(ex, "Error initializing insights listener.");
                }
            });
        }

        [ExternalBridgeRequestHandlerMethod(typeof(InsightsRequest), RequestHandlerLoggingMode.LogRequestName)]
        public async Task OnInsightsRequest(InsightsRequest request, String token, ExternalBridgeReceiver receiver)
        {
            try
            {
                InsightsFile insightsFile = new InsightsFile();
                var filePath = TemporaryManager.CreateImaginaryFile();

                await Task.Factory.StartNew(() =>
                {
                    var frames = InsightsManager.Default.GetFrames(request.StartDateUTC, request.EndDateUTC);
                    insightsFile.Frames = frames;

                    if (request.IncludeEvents)
                    {
                        insightsFile.Events = InsightsManager.Default.GetEvents(request.StartDateUTC, request.EndDateUTC);
                    }

                    if (request.IncludeStatuses)
                    {
                        insightsFile.Statuses = InsightsManager.Default.GetStatuses(request.StartDateUTC, request.EndDateUTC);
                    }

                    if (request.IncludeApplicationExceptions)
                    {
                        insightsFile.ApplicationExceptions = InsightsManager.Default.GetApplicationExceptions(request.StartDateUTC, request.EndDateUTC);
                    }

                    insightsFile.ToFile(filePath);
                });

                await receiver.SendGenericResponse(new InsightsResponse()
                {
                    InisightsFilePath = filePath,
                    InsightsFileLength = new FileInfo(filePath).Length
                }, token);
            }
            catch (Exception ex)
            {
                LogManager.Log(ex, "Error processing insights request.");
            }
        }

        [ExternalBridgeRequestHandlerMethod(typeof(InsightsDownloadCompletedRequest), RequestHandlerLoggingMode.LogRequestName)]
        public async Task OnInsightsDownloadCompletedRequest(InsightsDownloadCompletedRequest request, String token, ExternalBridgeReceiver receiver)
        {
            await Task.Factory.StartNew(() =>
            {
                try
                {
                    File.Delete(request.InisightsFilePath);
                }
                catch (Exception ex)
                {
                    LogManager.Log(ex, "Error deleting insights request temp file after download completion.");
                }
            });
            await receiver.SendGenericResponse(new InsightsResponse(), token);
        }

        [ExternalBridgeRequestHandlerMethod(typeof(InsightsMinDateRequest), RequestHandlerLoggingMode.LogRequestName)]
        public async Task OnInsightsMinDateRequest(InsightsMinDateRequest request, String token, ExternalBridgeReceiver receiver)
        {
            DateTime? minDate = null;

            try
            {
                await Task.Factory.StartNew(() =>
                {
                    minDate = InsightsManager.Default.GetFramesMinDate();
                });
            }
            catch (Exception ex)
            {
                LogManager.Log(ex, "Error retrieving insights frames minimum date.");
            }

            await receiver.SendGenericResponse(new InsightsMinDateResponse() { MinDate = minDate }, token);
        }

        public void OnReceiverDisconnected(ExternalBridgeReceiver receiver)
        {
            //Do Nothing...
        }
    }
}