using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.IO;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using Tango.Core;
using Tango.FileSystem;
using Tango.FSE.Common.Connection;
using Tango.FSE.Common.FileSystem;
using Tango.FSE.Common.Logging;
using Tango.Integration.ExternalBridge;
using Tango.Integration.Logging;
using Tango.Logging;
using Tango.PPC.Shared.Logs;

namespace Tango.FSE.UI.Logging
{
    /// <summary>
    /// Represents the <see cref="ILoggingProvider"/> default implementation.
    /// </summary>
    /// <seealso cref="Tango.FSE.Common.Logging.ILoggingProvider" />
    public class DefaultLoggingProvider : ExtendedObject, ILoggingProvider
    {
        private IFileSystemProvider _fileSystemProvider;
        private IMachineProvider _machineProvider;

        public event EventHandler<LogItemBase> FSELogAvailable;

        /// <summary>
        /// Occurs when a new PPC application log is available.
        /// </summary>
        public event EventHandler<LogItemBase> ApplicationLogAvailable;

        /// <summary>
        /// Occurs when a new embedded log is available.
        /// </summary>
        public event EventHandler<EmbeddedLogItem> FirmwareLogAvailable;

        /// <summary>
        /// Gets the last retrieved history of the application log files.
        /// </summary>
        public ObservableCollection<RemoteLogFile> ApplicationLogFiles { get; private set; }

        /// <summary>
        /// Gets the last retrieved history of the embedded firmware log files.
        /// </summary>
        public ObservableCollection<RemoteLogFile> FirmwareLogFiles { get; private set; }

        /// <summary>
        /// Initializes a new instance of the <see cref="DefaultLoggingProvider"/> class.
        /// </summary>
        /// <param name="machineProvider">The machine provider.</param>
        public DefaultLoggingProvider(IMachineProvider machineProvider, IFileSystemProvider fileSystemProvider)
        {
            ApplicationLogFiles = new ObservableCollection<RemoteLogFile>();
            FirmwareLogFiles = new ObservableCollection<RemoteLogFile>();

            _machineProvider = machineProvider;
            _fileSystemProvider = fileSystemProvider;

            if (machineProvider.MachineOperator is ExternalBridgeTcpClient)
            {
                (machineProvider.MachineOperator as ExternalBridgeTcpClient).ApplicationLogAvailable += DefaultLoggingProvider_ApplicationLogAvailable;
            }

            machineProvider.MachineOperator.DebugLogAvailable += MachineOperator_DebugLogAvailable;

            LogManager.NewLog += LogManager_NewLog;
        }

        /// <summary>
        /// Gets the history of application log files.
        /// </summary>
        /// <returns></returns>
        public async Task<List<RemoteLogFile>> GetApplicationLogFiles()
        {
            var response = await _machineProvider.MachineOperator.SendGenericRequest<GetLogFilesRequest, GetLogFilesResponse>(new GetLogFilesRequest() { LogFileType = RemoteLogFileType.Application });

            ApplicationLogFiles.Clear();

            foreach (var item in response.LogFiles)
            {
                ApplicationLogFiles.Add(item);
            }

            return response.LogFiles;
        }

        /// <summary>
        /// Gets the history of the embedded firmware log files.
        /// </summary>
        /// <returns></returns>
        public async Task<List<RemoteLogFile>> GetFirmwareLogFiles()
        {
            var response = await _machineProvider.MachineOperator.SendGenericRequest<GetLogFilesRequest, GetLogFilesResponse>(new GetLogFilesRequest() { LogFileType = RemoteLogFileType.Firmware });

            FirmwareLogFiles.Clear();

            foreach (var item in response.LogFiles)
            {
                FirmwareLogFiles.Add(item);
            }

            return response.LogFiles;
        }

        /// <summary>
        /// Downloads the specified remote log file.
        /// </summary>
        /// <param name="logFile">The log file.</param>
        /// <param name="targetFile">Target local file.</param>
        /// <returns></returns>
        public async Task<FileSystemHandler> DownloadLogFile(RemoteLogFile logFile, String targetFile)
        {
            var tempFolder = TemporaryManager.CreateFolder();
            var handler = await _fileSystemProvider.Download(new FileItem() { Path = logFile.Path }, tempFolder);
            handler.StatusChanged += (x, status) =>
            {
                if (status == FileSystemHandlerStatus.Completed)
                {
                    File.Move(Path.Combine(tempFolder, logFile.Name), targetFile);
                }
            };
            return handler;
        }

        private void LogManager_NewLog(object sender, LogItemBase log)
        {
            FSELogAvailable?.Invoke(this, log);
        }

        private void DefaultLoggingProvider_ApplicationLogAvailable(object sender, LogItemBase log)
        {
            ApplicationLogAvailable?.Invoke(this, log);
        }

        private void MachineOperator_DebugLogAvailable(object sender, PMR.Debugging.StartDebugLogResponse log)
        {
            FirmwareLogAvailable?.Invoke(this, new EmbeddedLogItem(log) { TimeStamp = DateTime.Now });
        }
    }
}