using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Text;
using RainmeterStudio.Documents;
using RainmeterStudio.Model;
using RainmeterStudio.Model.Events;

namespace RainmeterStudio.Business
{
    public class DocumentManager
    {
        #region Events

        /// <summary>
        /// Triggered when a document is opened
        /// </summary>
        public event EventHandler<DocumentOpenedEventArgs> DocumentOpened;

        /// <summary>
        /// Triggered when a document is closed
        /// </summary>
        public event EventHandler<DocumentClosedEventArgs> DocumentClosed;

        #endregion

        #region Properties

        /// <summary>
        /// Gets a list of factories
        /// </summary>
        public IEnumerable<IDocumentEditorFactory> Factories { get { return _factories; } }

        /// <summary>
        /// Gets a list of editors
        /// </summary>
        public IEnumerable<IDocumentEditor> Editors { get { return _editors; } }

        /// <summary>
        /// Gets a list of storages
        /// </summary>
        public IEnumerable<IDocumentStorage> Storages { get { return _storages; } }

        #endregion

        #region Private fields

        private List<IDocumentEditorFactory> _factories = new List<IDocumentEditorFactory>();
        private List<IDocumentEditor> _editors = new List<IDocumentEditor>();
        private List<IDocumentStorage> _storages = new List<IDocumentStorage>();
        private List<DocumentTemplate> _templates = new List<DocumentTemplate>();

        #endregion

        #region Initialization

        /// <summary>
        /// Initializes this document manager
        /// </summary>
        public DocumentManager()
        {
        }

        /// <summary>
        /// Registers a document editor factory
        /// </summary>
        /// <param name="factory">Document editor factory</param>
        public void RegisterEditorFactory(IDocumentEditorFactory factory)
        {
            _factories.Add(factory);
        }

        /// <summary>
        /// Registers a document storage
        /// </summary>
        /// <param name="storage">The storage</param>
        public void RegisterStorage(IDocumentStorage storage)
        {
            _storages.Add(storage);
        }

        /// <summary>
        /// Registers a document template
        /// </summary>
        /// <param name="template">The document template</param>
        public void RegisterTemplate(DocumentTemplate template)
        {
            _templates.Add(template);
        }

        #endregion

        #region Document operations

        /// <summary>
        /// Creates a new document in the specified path, with the specified format, and opens it
        /// </summary>
        /// <param name="format"></param>
        /// <param name="path"></param>
        public IDocumentEditor Create(DocumentTemplate format)
        {
            // Create document
            var document = format.CreateDocument();
            document.IsDirty = true;

            // Find and create editor
            IDocumentEditor editor = CreateEditor(document);

            // Trigger event
            if (DocumentOpened != null)
                DocumentOpened(this, new DocumentOpenedEventArgs(editor));

            return editor;
        }

        /// <summary>
        /// Opens the specified document
        /// </summary>
        public IDocumentEditor Open(string path)
        {
            // Try to open
            IDocument document = Read(path);

            // Create factory
            var editor = CreateEditor(document);

            // Trigger event
            if (DocumentOpened != null)
                DocumentOpened(this, new DocumentOpenedEventArgs(editor));

            return editor;
        }

        public void Save(IDocument document)
        {
            // Find a storage
            var storage = FindStorage(document);

            if (document.Reference == null)
                throw new ArgumentException("Reference cannot be empty");

            // Save
            storage.Write(document.Reference.Path, document);

            // Clear dirty flag
            document.IsDirty = false;
        }

        public void SaveAs(string path, IDocument document)
        {
            // Find a storage
            var storage = FindStorage(document);

            // Save
            storage.Write(path, document);

            // Update reference
            document.Reference.Name = Path.GetFileName(path);
            document.Reference.Path = path;

            // Clear dirty flag
            document.IsDirty = false;
        }

        public void SaveACopy(string path, IDocument document)
        {
            // Find a storage
            var storage = FindStorage(document);

            // Save
            storage.Write(path, document);
        }

        #endregion

        #region Private functions

        /// <summary>
        /// Attempts to create an editor for the document
        /// </summary>
        /// <param name="document">The document</param>
        /// <exception cref="ArgumentException">Thrown if failed to create editor</exception>
        /// <returns>The editor</returns>
        private IDocumentEditor CreateEditor(IDocument document)
        {
            IDocumentEditor editor = null;

            foreach (var factory in Factories)
                if (factory.CanEdit(document.GetType()))
                {
                    editor = factory.CreateEditor(document);
                    break;
                }

            if (editor == null)
                throw new ArgumentException("Failed to create editor.");

            _editors.Add(editor);
            return editor;
        }

        /// <summary>
        /// Attempts to read a document
        /// </summary>
        /// <param name="path">Path of file</param>
        /// <exception cref="ArgumentException">Thrown when failed to open the document</exception>
        /// <returns></returns>
        private IDocument Read(string path)
        {
            IDocument document = null;

            foreach (var storage in Storages)
                if (storage.CanRead(path))
                {
                    document = storage.Read(path);
                    break;
                }

            // Failed to open
            if (document == null)
                throw new ArgumentException("Failed to open document.");

            return document;
        }

        /// <summary>
        /// Attempts to find a storage for the specified document
        /// </summary>
        /// <param name="document"></param>
        /// <returns></returns>
        private IDocumentStorage FindStorage(IDocument document)
        {
            IDocumentStorage storage = null;

            foreach (var s in Storages)
                if (s.CanWrite(document.GetType()))
                {
                    storage = s;
                    break;
                }

            if (storage == null)
                throw new ArgumentException("Failed to find storage object.");

            return storage;
        }

        #endregion
    }
}