using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using Tango.Core;
using Tango.Core.DI;
using Tango.Explorer;
using Tango.PPC.Common.Application;
using Tango.PPC.Common.Threading;

namespace Tango.PPC.Common.Storage
{
    /// <summary>
    /// Represents the default <see cref="IStorageProvider"/>.
    /// </summary>
    /// <seealso cref="Tango.Core.ExtendedObject" />
    /// <seealso cref="Tango.PPC.Common.Storage.IStorageProvider" />
    public class DefaultStorageProvider : ExtendedObject, IStorageProvider
    {
        private Thread _scanThread;
        private Dictionary<String, Action<List<ExplorerFileItem>>> _fileHandlers;

        /// <summary>
        /// Occurs when a new storage drive has been inserted.
        /// </summary>
        public event EventHandler<DriveInfo> StorageConnected;

        /// <summary>
        /// Occurs when a storage drive has been removed.
        /// </summary>
        public event EventHandler<DriveInfo> StorageDisconnected;

        private bool _isConnected;
        /// <summary>
        /// Gets a value indicating whether a storage drive is currently inserted.
        /// </summary>
        public bool IsConnected
        {
            get { return _isConnected; }
            set { _isConnected = value; RaisePropertyChangedAuto(); }
        }

        private DriveInfo _drive;
        /// <summary>
        /// Gets the inserted storage drive information.
        /// </summary>
        public DriveInfo Drive
        {
            get { return _drive; }
            set { _drive = value; RaisePropertyChangedAuto(); }
        }

        /// <summary>
        /// Initializes a new instance of the <see cref="DefaultStorageProvider"/> class.
        /// </summary>
        public DefaultStorageProvider(IPPCApplicationManager applicationManager)
        {
            _fileHandlers = new Dictionary<string, Action<List<ExplorerFileItem>>>();
            var drives = DriveInfo.GetDrives().Where(x => x.DriveType == DriveType.Removable).ToList();

            if (drives.Count > 0)
            {
                IsConnected = true;
                Drive = drives.FirstOrDefault();
            }

            applicationManager.ApplicationReady += ApplicationManager_ApplicationReady;
        }

        /// <summary>
        /// Handles the ApplicationReady event of the ApplicationManager.
        /// </summary>
        /// <param name="sender">The source of the event.</param>
        /// <param name="e">The <see cref="EventArgs"/> instance containing the event data.</param>
        private void ApplicationManager_ApplicationReady(object sender, EventArgs e)
        {
            Initialize();
        }

        /// <summary>
        /// Registers a method for handling a file selection.
        /// </summary>
        /// <param name="extension">The file extension.</param>
        /// <param name="handler">The handler.</param>
        /// <exception cref="System.InvalidOperationException">Cannot register multiple file handlers for the same extension.</exception>
        public void RegisterFileHandler(string extension, Action<List<ExplorerFileItem>> handler)
        {
            if (_fileHandlers.ContainsKey(extension))
            {
                throw new InvalidOperationException("Cannot register multiple file handlers for the same extension.");
            }
            _fileHandlers.Add(extension, handler);
        }

        /// <summary>
        /// Unregisters the file handler.
        /// </summary>
        /// <param name="handler">The handler.</param>
        public void UnregisterFileHandler(Action<List<ExplorerFileItem>> handler)
        {
            var h = _fileHandlers.SingleOrDefault(x => x.Value == handler);

            if (h.Key != null)
            {
                _fileHandlers.Remove(h.Key);
            }
        }

        /// <summary>
        /// Submits a file selection.
        /// </summary>
        /// <param name="fileItems">The file item.</param>
        public void SubmitFileSelection(List<ExplorerFileItem> fileItems)
        {
            if (fileItems != null && fileItems.Count > 0)
            {
                String extension = Path.GetExtension(fileItems.First().Path);

                if (_fileHandlers.ContainsKey(extension))
                {
                    _fileHandlers[extension].Invoke(fileItems);
                }
            }
        }

        private void Initialize()
        {
            _scanThread = new Thread(ScanThreadMethod);
            _scanThread.IsBackground = true;
            _scanThread.Start();
        }

        private void ScanThreadMethod()
        {
            while (true)
            {
                var drives = DriveInfo.GetDrives().Where(x => x.DriveType == DriveType.Removable).ToList();

                if (IsConnected && !drives.Exists(x => x.RootDirectory.FullName == Drive.RootDirectory.FullName))
                {
                    StorageDisconnected?.Invoke(this, Drive);
                    Drive = null;
                    IsConnected = false;
                }

                if (!IsConnected && drives.Count > 0)
                {
                    Drive = drives.FirstOrDefault();
                    IsConnected = true;
                    StorageConnected?.Invoke(this, Drive);
                }

                Thread.Sleep(5000);
            }
        }
    }
}