path: root/Software/Visual_Studio/FSE/Tango.FSE.UI/FileSystem/DefaultFileSystemProvider.cs

using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.IO.Compression;
using System.Linq;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using Tango.Core;
using Tango.Core.Threading;
using Tango.FileSystem;
using Tango.FileSystem.Network;
using Tango.FSE.Common.Connection;
using Tango.FSE.Common.FileSystem;
using Tango.Transport;
using Tango.Transport.Transporters;
using Tango.WebRTC;

namespace Tango.FSE.UI.FileSystem
{
    public class DefaultFileSystemProvider : ExtendedObject, IFileSystemProvider
    {
        private IMachineProvider _machineProvider;
        private BasicTransporter _webRtcTransporter;
        private const string WEB_RTC_CHANNEL_NAME = "FileSystemChannel";
        private const long MAX_CHUNK_SIZE = 1024 * 10;
        private const long MAX_CHUNK_SIZE_WEB_RTC = 1024 * 50;
        private const int WEB_RTC_MAX_RETRIES = 8;
        private List<FileSystemHandler> _activeHandlers;

        private bool _enableWebRTC;
        public bool EnableWebRTC
        {
            get { return _enableWebRTC; }
            set { _enableWebRTC = value; RaisePropertyChangedAuto(); }
        }

        private bool _isWebRtcAvailable;
        public bool IsWebRtcAvailable
        {
            get { return _isWebRtcAvailable; }
            private set { _isWebRtcAvailable = value; RaisePropertyChangedAuto(); }
        }

        public DefaultFileSystemProvider(IMachineProvider machineProvider)
        {
            _activeHandlers = new List<FileSystemHandler>();

            EnableWebRTC = true; //TODO: From Settings..
            _machineProvider = machineProvider;
            _machineProvider.MachineConnected += _machineProvider_MachineConnected;
            _machineProvider.MachineDisconnected += _machineProvider_MachineDisconnected;
        }

        private async void _machineProvider_MachineDisconnected(object sender, MachineDisconnectedEventArgs e)
        {
            IsWebRtcAvailable = false;

            foreach (var handler in _activeHandlers.ToList())
            {
                try
                {
                    handler.RaiseFailed(new TransporterDisconnectedException("Machine disconnected."));
                }
                catch (Exception ex)
                {
                    Debug.WriteLine(ex);
                }
            }

            _activeHandlers.Clear();

            if (_webRtcTransporter != null)
            {
                try
                {
                    LogManager.Log("Machine disconnected. Disconnecting FileSystem WebRTC Transporter...");
                    await _webRtcTransporter.Disconnect();
                }
                catch (Exception ex)
                {
                    LogManager.Log(ex, "Error while disconnecting FileSystem WebRTC Transporter.");
                }
            }
        }

        private async void _machineProvider_MachineConnected(object sender, MachineConnectedEventArgs e)
        {
            if (EnableWebRTC)
            {
                try
                {
                    IsWebRtcAvailable = false;

                    await _machineProvider.MachineOperator.SendGenericRequest<InitWebRtcRequest, InitWebRtcResponse>(new InitWebRtcRequest()
                    {
                        DataChannelName = WEB_RTC_CHANNEL_NAME
                    }, new TransportRequestConfig()
                    {
                        Timeout = TimeSpan.FromSeconds(60),
                        Priority = QueuePriority.Low
                    });

                    _webRtcTransporter = new BasicTransporter(new WebRtcTransportAdapter(_machineProvider.MachineOperator, WebRtcTransportAdapterMode.Active, WEB_RTC_CHANNEL_NAME));
                    _webRtcTransporter.UseKeepAlive = false;
                    _webRtcTransporter.ComponentName = "File System Active WebRTC Transporter";
                    await _webRtcTransporter.Connect();

                    IsWebRtcAvailable = true;

                    LogManager.Log("FileSystem via WebRTC is ready.");
                }
                catch (Exception ex)
                {
                    IsWebRtcAvailable = false;
                    LogManager.Log(ex, "Error initializing FileSystem via WebRTC.");
                }
            }
        }

        public async Task<IFileSystemContainer> GetFolder(string path)
        {
            var response = await _machineProvider.MachineOperator.SendGenericRequest<GetFileSystemItemRequest, GetFileSystemItemResponse>(new GetFileSystemItemRequest()
            {
                Path = path
            }, new TransportRequestConfig()
            {
                Timeout = TimeSpan.FromSeconds(30),
            });

            return FileSystemItem.FromDTO(response.FileSystemItem) as IFileSystemContainer;
        }

        public async Task<IFileSystemContainer> GetSpecialFolder(Environment.SpecialFolder specialFolder)
        {
            var response = await _machineProvider.MachineOperator.SendGenericRequest<GetFileSystemItemRequest, GetFileSystemItemResponse>(new GetFileSystemItemRequest()
            {
                SpecialFolder = specialFolder
            }, new TransportRequestConfig()
            {
                Timeout = TimeSpan.FromSeconds(30),
            });

            return FileSystemItem.FromDTO(response.FileSystemItem) as IFileSystemContainer;
        }

        public async Task<IFileSystemContainer> GetThisPC()
        {
            var response = await _machineProvider.MachineOperator.SendGenericRequest<GetFileSystemItemRequest, GetFileSystemItemResponse>(new GetFileSystemItemRequest()
            {
                //No parameters at all
            }, new TransportRequestConfig()
            {
                Timeout = TimeSpan.FromSeconds(30),
            });

            return FileSystemItem.FromDTO(response.FileSystemItem) as IFileSystemContainer;
        }

        public Task<FileSystemHandler> Download(FileSystemItem item, string localTargetFolder)
        {
            String operationId = String.Empty;
            String destination = String.Empty;
            long downloadLength = 0;
            bool aborted = false;

            FileSystemHandler handler = null;

            destination = Path.Combine(localTargetFolder, item.Name);


            handler = new FileSystemHandler(item, destination, async () =>
            {
                if (!aborted)
                {
                    aborted = true;
                    try
                    {
                        var response = await _machineProvider.MachineOperator.SendGenericRequest<AbortOperationRequest, AbortOperationResponse>(
                        new AbortOperationRequest()
                        {
                            OperationId = operationId
                        }, new TransportRequestConfig() { Timeout = TimeSpan.FromSeconds(30) });
                    }
                    catch (Exception ex)
                    {
                        LogManager.Log(ex, "Error aborting the download operation.");
                    }
                    finally
                    {
                        handler.RaiseAborted();
                    }
                }
            });

            _activeHandlers.Add(handler);

            ThreadFactory.StartNew(async () =>
            {
                try
                {
                    if (item.Type == FileSystemItemType.File)
                    {
                        var response = await _machineProvider.MachineOperator.SendGenericRequest<FileDownloadRequest, FileDownloadResponse>(
                            new FileDownloadRequest()
                            {
                                Path = item.Path
                            }, new TransportRequestConfig() { Timeout = TimeSpan.FromSeconds(20) });

                        operationId = response.OperationId;
                        downloadLength = response.Length;
                        handler.OperationId = operationId;
                    }
                    else if (item.Type == FileSystemItemType.Folder)
                    {
                        var response = await _machineProvider.MachineOperator.SendGenericRequest<FolderDownloadRequest, FolderDownloadResponse>(
                            new FolderDownloadRequest()
                            {
                                Path = item.Path
                            }, new TransportRequestConfig() { Timeout = TimeSpan.FromSeconds(60) });

                        operationId = response.OperationId;
                        downloadLength = response.Length;
                        handler.OperationId = operationId;
                    }
                    else
                    {
                        throw new NotSupportedException("The requested file system item is not supported for downloading.");
                    }
                }
                catch (Exception ex)
                {
                    _activeHandlers.Remove(handler);
                    handler.RaiseFailed(ex);
                    return;
                }

                long position = 0;
                bool webRtcFailed = false;
                int webRtcRetries = WEB_RTC_MAX_RETRIES;

                var tempFile = TemporaryManager.CreateFile();

                while (position < downloadLength && !aborted)
                {
                    if (handler.IsPaused)
                    {
                        Thread.Sleep(1000);
                        continue;
                    }

                    try
                    {
                        ChunkDownloadResponse response = null;
                        ChunkDownloadRequest request = new ChunkDownloadRequest()
                        {
                            MaxChunkSize = MAX_CHUNK_SIZE,
                            OperationId = operationId,
                            Position = position,
                        };

                        if (_webRtcTransporter != null && _webRtcTransporter.State == TransportComponentState.Connected && EnableWebRTC && !webRtcFailed)
                        {
                            try
                            {
                                request.MaxChunkSize = MAX_CHUNK_SIZE_WEB_RTC;
                                response = await _webRtcTransporter.SendGenericRequest<ChunkDownloadRequest, ChunkDownloadResponse>(request, new TransportRequestConfig()
                                {
                                    Timeout = TimeSpan.FromSeconds(2),
                                    Priority = QueuePriority.Low
                                });

                                webRtcRetries = WEB_RTC_MAX_RETRIES;
                            }
                            catch (Exception ex)
                            {
                                webRtcRetries--;

                                if (webRtcRetries == 0)
                                {
                                    webRtcFailed = true;
                                    LogManager.Log(ex, "WebRTC chunk download failed. Falling back to standard download...");
                                }

                                continue;
                            }
                        }
                        else
                        {
                            response = await _machineProvider.MachineOperator.SendGenericRequest<ChunkDownloadRequest, ChunkDownloadResponse>(request, new TransportRequestConfig()
                            {
                                Timeout = TimeSpan.FromSeconds(30),
                                Priority = QueuePriority.Low
                            });
                        }

                        using (FileStream fs = new FileStream(tempFile, FileMode.Append))
                        {
                            fs.Write(response.Data, 0, response.Data.Length);
                        }

                        position += response.Data.Length;
                        handler.InvalidateProgress(position, downloadLength);
                    }
                    catch (Exception ex)
                    {
                        _activeHandlers.Remove(handler);
                        tempFile.Delete();
                        handler.RaiseFailed(ex);
                        return;
                    }
                }

                if (!aborted)
                {
                    try
                    {
                        if (item.Type == FileSystemItemType.File)
                        {
                            File.Copy(tempFile, destination, true);
                            tempFile.Delete();
                        }
                        else if (item.Type == FileSystemItemType.Folder)
                        {
                            ZipFile.ExtractToDirectory(tempFile, destination);
                            tempFile.Delete();
                        }

                        handler.RaiseCompleted();
                    }
                    catch (Exception ex)
                    {
                        handler.RaiseFailed(ex);
                    }
                }
                else
                {
                    tempFile.Delete();
                }

                _activeHandlers.Remove(handler);
            });

            return Task.FromResult(handler);
        }

        public Task<FileSystemHandler> Upload(string sourcePath, string remoteTargetFolder)
        {
            throw new NotImplementedException();
        }

        public async Task Copy(FileSystemItem source, FileSystemItem target)
        {
            if (source.Type == FileSystemItemType.Drive)
            {
                throw new NotSupportedException("The source file system item is not supported for copying.");
            }
            if (target.Type == FileSystemItemType.File)
            {
                throw new NotSupportedException("The target file system item is not a valid container.");
            }

            await _machineProvider.MachineOperator.SendGenericRequest<CopyRequest, CopyResponse>(new CopyRequest()
            {

                Source = source.Path,
                Destination = Path.Combine(target.Path, source.Name)

            }, new TransportRequestConfig()
            {
                Timeout = TimeSpan.FromSeconds(120),
            });
        }

        public async Task Move(FileSystemItem source, FileSystemItem target)
        {
            if (source.Type == FileSystemItemType.Drive)
            {
                throw new NotSupportedException("The source file system item is not supported for copying.");
            }
            if (target.Type == FileSystemItemType.File)
            {
                throw new NotSupportedException("The target file system item is not a valid container.");
            }

            await _machineProvider.MachineOperator.SendGenericRequest<MoveRequest, MoveResponse>(new MoveRequest()
            {

                Source = source.Path,
                Destination = Path.Combine(target.Path, source.Name)

            }, new TransportRequestConfig()
            {
                Timeout = TimeSpan.FromSeconds(120),
            });
        }

        public async Task Rename(FileSystemItem source, string newName)
        {
            if (source.Type == FileSystemItemType.Drive)
            {
                throw new NotSupportedException("The source file system item is not supported for copying.");
            }
            if (newName.ToList().Exists(x => Path.GetInvalidFileNameChars().Contains(x)))
            {
                throw new ArgumentException("The new name contains invalid characters.");
            }

            await _machineProvider.MachineOperator.SendGenericRequest<MoveRequest, MoveResponse>(new MoveRequest()
            {

                Source = source.Path,
                Destination = Path.Combine(Path.GetDirectoryName(source.Path), newName)

            });
        }

        public async Task Delete(FileSystemItem item)
        {
            if (item.Type == FileSystemItemType.Drive)
            {
                throw new NotSupportedException("The source file system item is not supported for deletion.");
            }

            await _machineProvider.MachineOperator.SendGenericRequest<DeleteRequest, DeleteResponse>(new DeleteRequest()
            {
                Path = item.Path
            }, new TransportRequestConfig() { Timeout = TimeSpan.FromSeconds(120) });
        }

        public async Task<FolderItem> CreateFolder(FileSystemItem parent, string folderName)
        {
            var response = await _machineProvider.MachineOperator.SendGenericRequest<CreateFolderRequest, CreateFolderResponse>(new CreateFolderRequest()
            {
                Path = parent.Path,
                FolderName = folderName,
            });

            return FileSystemItem.FromDTO(response.FolderItem) as FolderItem;
        }
    }
}