using FastReport.Cloud.StorageClient;
using FastReport.Cloud.StorageClient.Dropbox;
using FastReport.Cloud.StorageClient.Ftp;
using FastReport.Cloud.StorageClient.S3;
#if !AVALONIA
using FastReport.Cloud.StorageClient.Box;
using FastReport.Cloud.StorageClient.GoogleDrive;
using FastReport.Cloud.StorageClient.SkyDrive;
#endif
using FastReport.Export;
using FastReport.Export.BIFF8;
using FastReport.Export.Csv;
using FastReport.Export.Dbf;
using FastReport.Export.Dxf;
using FastReport.Export.Html;
using FastReport.Export.Image;
using FastReport.Export.Json;
using FastReport.Export.LaTeX;
using FastReport.Export.Mht;
using FastReport.Export.Odf;
using FastReport.Export.OoXML;
using FastReport.Export.Pdf;
using FastReport.Export.Ppml;
using FastReport.Export.PS;
using FastReport.Export.RichText;
using FastReport.Export.Svg;
using FastReport.Export.Text;
using FastReport.Export.XAML;
using FastReport.Export.Xml;
using FastReport.Export.Zpl;
using FastReport.Messaging;
using System;

namespace FastReport.Utils
{
#if !COMMUNITY
    public partial class ExportsOptions
    {
        private void CreateDefaultExports()
        {
            var root = ExportsMenu;

            root.AddExport(typeof(PDFExport), "Pdf", 201);

            root.AddCategory("Office", 190)
                .AddExport(typeof(Excel2007Export), "Xlsx", 191)
                .AddExport(typeof(Word2007Export), "Docx", 190)
                .AddExport(typeof(PowerPoint2007Export), "Pptx")
                .AddExport(typeof(ODSExport), "Ods")
                .AddExport(typeof(ODTExport), "Odt")
                .AddExport(typeof(RTFExport), "RichText", 190)
                .AddExport(typeof(Excel2003Document), "Xls")
                .AddExport(typeof(XMLExport), "Xml");

            root.AddCategory("Web", 153)
                .AddExport(typeof(HTMLExport), "Html")
                .AddExport(typeof(MHTExport), "Mht");

            root.AddCategory("Image", 103)
                .AddExport(typeof(ImageExport), "Image")
                .AddExport(typeof(SVGExport), "Svg");

            root.AddCategory("DataBase", 53)
                .AddExport(typeof(CSVExport), "Csv")
                .AddExport(typeof(DBFExport), "Dbf")
                .AddExport(typeof(JsonExport), "Json");

            root.AddCategory("Print", 195)
                .AddExport(typeof(TextExport), "Text")
                .AddExport(typeof(ZplExport), "Zpl")
                .AddExport(typeof(PPMLExport), "Ppml")
                .AddExport(typeof(PSExport), "PS")
                .AddExport(typeof(XPSExport), "Xps");

            root.AddCategory("Other")
                .AddExport(typeof(LaTeXExport), "LaTeX")
                .AddExport(typeof(DxfExport), "Dxf")
                .AddExport(typeof(XAMLExport), "Xaml");
        }

        private ExportsTreeNode cloudMenu;

        /// <summary>
        /// All cloud exports available in the preview.
        /// </summary>
        public ExportsTreeNode CloudMenu
        {
            get
            {
                if (cloudMenu == null)
                {
                    cloudMenu = new ExportsTreeNode() { Name = "Cloud", ImageIndex = 238 };
                    cloudMenu
                        .AddCloud(typeof(FtpStorageClient), "Ftp")
                        .AddCloud(typeof(DropboxStorageClient), "Dropbox", 238)
#if !AVALONIA
                        .AddCloud(typeof(BoxStorageClient), "Box", 238)
                        .AddCloud(typeof(GoogleDriveStorageClient), "GoogleDrive", 238)
                        .AddCloud(typeof(SkyDriveStorageClient), "SkyDrive", 238)
#endif
                        .AddCloud(typeof(S3StorageClient), "S3", 238);
                }

                return cloudMenu;
            }
        }

        private ExportsTreeNode messengerMenu;

        /// <summary>
        /// All messengers exports available in the preview.
        /// </summary>
        public ExportsTreeNode MessengerMenu
        {
            get
            {
                if (messengerMenu == null)
                {
                    messengerMenu = new ExportsTreeNode() { Name = "Messengers" };
                    //messengerMenu.AddMessenger("Xmpp", typeof(Messaging.Xmpp.XmppMessenger));
                }
                return messengerMenu;
            }
        }

        internal PreviewExports Exports
        {
            get
            {
                var result = PreviewExports.None;
                foreach (var node in EnumNodes(ExportsMenu))
                {
                    if (node.Enabled && node.GetEnum<PreviewExports>(out var res))
                        result |= res;
                }
                return result;
            }
            set
            {
                foreach (var node in EnumNodes(ExportsMenu))
                {
                    if (node.GetEnum<PreviewExports>(out var res))
                        node.Enabled = (value & res) != 0;
                }
            }
        }

        internal PreviewClouds Clouds
        {
            get
            {
                var result = PreviewClouds.None;
                foreach (var node in EnumNodes(CloudMenu))
                {
                    if (node.Enabled && node.GetEnum<PreviewClouds>(out var res))
                        result |= res;
                }
                return result;
            }
            set
            {
                foreach (var node in EnumNodes(CloudMenu))
                {
                    if (node.GetEnum<PreviewClouds>(out var res))
                        node.Enabled = (value & res) != 0;
                }
            }
        }

        internal PreviewMessengers Messengers
        {
            get
            {
                var result = PreviewMessengers.None;
                foreach (var node in EnumNodes(MessengerMenu))
                {
                    if (node.Enabled && node.GetEnum<PreviewMessengers>(out var res))
                        result |= res;
                }
                return result;
            }
            set
            {
                foreach (var node in EnumNodes(MessengerMenu))
                {
                    if (node.GetEnum<PreviewMessengers>(out var res))
                        node.Enabled = (value & res) != 0;
                }
            }
        }

        private void SaveMenuTree(XmlItem item, ExportsTreeNode root)
        {
            item.Items.Clear();
            item.Name = root.Name;
            if (!root.Enabled)
                item.SetProp("Enabled", "false");

            foreach (ExportsTreeNode node in root.Nodes)
            {
                SaveMenuTree(item.Add(), node);
            }
        }

        private XmlItem SaveMenuTree(ExportsTreeNode root)
        {
            var item = new XmlItem();
            SaveMenuTree(item, root);
            return item;
        }

        private void SaveMenuTree(string name, ExportsTreeNode root)
        {
            SaveMenuTree(Config.Root.FindItem("PreviewSettings").FindItem(name), root);
        }

        private void RestoreMenuTree(XmlItem item, ExportsTreeNode root)
        {
            for (int i = 0; i < item.Count; i++)
            {
                var xi = item[i];
                var name = xi.Name;
                var node = FindItem(root.Root, name, null) ?? new ExportsTreeNode() { Name = name };
                if (i < root.Nodes.Count)
                    root.Nodes.Insert(i, node);
                else
                    root.Nodes.Add(node);
                node.Enabled = string.Compare(xi.GetProp("Enabled"), "false", true) != 0;

                RestoreMenuTree(xi, node);
            }
        }

        private void RestoreMenuTree(string name, ExportsTreeNode root)
        {
            RestoreMenuTree(Config.Root.FindItem("PreviewSettings").FindItem(name), root);
        }

        private XmlItem defaultExports;
        private XmlItem defaultClouds;
        private XmlItem defaultMessengers;

        private void RestoreOptions()
        {
            // save current state as default one
            defaultExports = SaveMenuTree(ExportsMenu);
            defaultClouds = SaveMenuTree(CloudMenu);
            defaultMessengers = SaveMenuTree(MessengerMenu);

            RestoreMenuTree("Exports", ExportsMenu);
            RestoreMenuTree("Cloud", CloudMenu);
            RestoreMenuTree("Messengers", MessengerMenu);
        }

        private void SaveOptions()
        {
            SaveMenuTree("Exports", ExportsMenu);
            SaveMenuTree("Cloud", CloudMenu);
            SaveMenuTree("Messengers", MessengerMenu);
        }

        /// <summary>
        /// Resets the export nodes to default state.
        /// </summary>
        public void ResetToDefault()
        {
            if (defaultExports != null)
                RestoreMenuTree(defaultExports, ExportsMenu);
            if (defaultClouds != null)
                RestoreMenuTree(defaultClouds, CloudMenu);
            if (defaultMessengers != null)
                RestoreMenuTree(defaultMessengers, MessengerMenu);
        }


        public partial class ExportsTreeNode
        {
            /// <summary>
            /// Returns true if the node is a category.
            /// </summary>
            public bool IsCategory => ExportType == null;

            /// <summary>
            /// Returns true if the node is an export.
            /// </summary>
            public bool IsExport => ExportType != null && ExportType.IsSubclassOf(typeof(ExportBase));

            /// <summary>
            /// Returns true if the node is a cloud export.
            /// </summary>
            public bool IsCloud => ExportType != null && ExportType.IsSubclassOf(typeof(CloudStorageClient));

            /// <summary>
            /// Returns true if the node is a category.
            /// </summary>
            public bool IsMessenger => ExportType != null && ExportType.IsSubclassOf(typeof(MessengerBase));

            /// <summary>
            /// Adds a cloud export and registers it.
            /// </summary>
            /// <param name="type">The export type.</param>
            /// <param name="text">The display text.</param>
            /// <param name="imageIndex">The image index.</param>
            /// <returns>Returns this object to allow method chaining.</returns>
            public ExportsTreeNode AddCloud(Type type, string text, int imageIndex = -1)
            {
                var node = new ExportsTreeNode() { Name = type.Name, ExportType = type, Text = text, ImageIndex = imageIndex };
                node.Tag = RegisteredObjects.AddCloud(node.ExportType, node.ToString(), node.ImageIndex);
                Nodes.Add(node);
                return this;
            }

            /// <summary>
            /// Adds a messenger and registers it.
            /// </summary>
            /// <param name="type">The export type.</param>
            /// <param name="text">The display text.</param>
            /// <param name="imageIndex">The image index.</param>
            /// <returns>Returns this object to allow method chaining.</returns>
            public ExportsTreeNode AddMessenger(Type type, string text, int imageIndex = -1)
            {
                var node = new ExportsTreeNode() { Name = type.Name, ExportType = type, Text = text, ImageIndex = imageIndex };
                node.Tag = RegisteredObjects.AddMessenger(node.ExportType, node.ToString(), node.ImageIndex);
                Nodes.Add(node);
                return this;
            }

            internal bool GetEnum<T>(out T res) where T : struct => Enum.TryParse(Name, out res);

            /// <inheritdoc/>
            public override string ToString()
            {
                string resPath;
                if (IsCategory)
                {
                    resPath = "Export,ExportGroups," + Name;
                }
                else
                {
                    if (IsExport)
                    {
                        resPath = "Export," + Text + ",File";
                    }
                    else
                    {
                        resPath = (IsCloud ? "Cloud," : "Messaging,") + Text + ",Name";
                    }
                }

                string result = Res.TryGet(resPath);
                if (result == resPath)
                    return Text;
                return result;
            }
        }
    }
#endif
}