using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.IO;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace Tango.Core.IO
{
    /// <summary>
    /// Represents the Tango system temporary file manager.
    /// </summary>
    public class TemporaryManager : IDisposable
    {
        #region Singleton

        private static TemporaryManager _default;
        /// <summary>
        /// Gets the default temporary manager instance.
        /// </summary>
        public static TemporaryManager Default
        {
            get
            {
                if (_default == null)
                {
                    _default = new TemporaryManager();
                }

                return _default;
            }
        }

        /// <summary>
        /// Prevents a default instance of the <see cref="TemporaryManager"/> class from being created.
        /// </summary>
        private TemporaryManager()
        {
            Items = new List<ITemporaryItem>().ToReadOnlyCollection();
            RootPath = Path.Combine(Path.GetTempPath(), "Twine");
            Directory.CreateDirectory(RootPath);
        }

        #endregion

        private bool _disposed;

        /// <summary>
        /// Gets or sets the temporary root path.
        /// </summary>
        public String RootPath { get; protected set; }

        /// <summary>
        /// Gets the collection of temporary items.
        /// </summary>
        public IReadOnlyCollection<ITemporaryItem> Items { get; protected set; }

        /// <summary>
        /// Adds the item.
        /// </summary>
        /// <param name="item">The item.</param>
        private void AddItem(ITemporaryItem item)
        {
            var list = Items.ToList();
            list.Add(item);
            Items = list.ToReadOnlyCollection();
            item.Deleted += Item_Deleted;
        }

        /// <summary>
        /// Removes the item.
        /// </summary>
        /// <param name="item">The item.</param>
        private void RemoveItem(ITemporaryItem item)
        {
            var list = Items.ToList();
            list.Remove(item);
            Items = list.ToReadOnlyCollection();
            item.Deleted -= Item_Deleted;
        }

        /// <summary>
        /// Handles the Deleted event of the item.
        /// </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 Item_Deleted(object sender, EventArgs e)
        {
            RemoveItem(sender as ITemporaryItem);
        }

        /// <summary>
        /// Creates a new temporary folder and returns the folder item.
        /// </summary>
        /// <returns></returns>
        public virtual TemporaryFolder CreateFolder()
        {
            TemporaryFolder folder = new TemporaryFolder(Path.Combine(RootPath, Path.GetRandomFileName()));
            AddItem(folder);
            return folder;
        }

        /// <summary>
        /// Creates a new temporary folder and returns the folder item.
        /// </summary>
        /// <returns></returns>
        public virtual TemporaryFolder CreateFolder(String name)
        {
            TemporaryFolder folder = new TemporaryFolder(Path.Combine(RootPath, name));
            AddItem(folder);
            return folder;
        }

        /// <summary>
        /// Creates a new temporary file and returns the file item.
        /// </summary>
        /// <returns></returns>
        public virtual TemporaryFile CreateFile(String extension = null)
        {
            TemporaryFile file = new TemporaryFile(Path.Combine(RootPath, Path.GetRandomFileName() + extension));
            AddItem(file);
            return file;
        }

        /// <summary>
        /// Creates a new temporary file but does not create it.
        /// </summary>
        /// <returns></returns>
        public virtual TemporaryFile CreateImaginaryFile(String extension = null)
        {
            TemporaryFile file = new TemporaryFile(Path.Combine(RootPath, Path.GetRandomFileName() + extension), false);
            AddItem(file);
            return file;
        }

        /// <summary>
        /// Deletes all items.
        /// </summary>
        public virtual void Clean()
        {
            var items = Items;

            foreach (var item in items.Where(x => !x.Persist))
            {
                item.Delete();
            }
        }

        /// <summary>
        /// Deletes all items.
        /// </summary>
        public virtual Task CleanAsync()
        {
            return Task.Factory.StartNew(() => Clean());
        }

        /// <summary>
        /// Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources.
        /// </summary>
        public void Dispose()
        {
            if (!_disposed)
            {
                Clean();
                _disposed = true;
            }
        }

        /// <summary>
        /// Finalizes an instance of the <see cref="TemporaryManager"/> class.
        /// </summary>
        ~TemporaryManager()
        {
            Dispose();
        }
    }
}