using System;
using System.Collections;
using System.Text.RegularExpressions;
using System.Web;
using System.Web.UI;
using umbraco.BasePages;
using umbraco.BusinessLogic;
using umbraco.cms.businesslogic.web;
using umbraco.editorControls.wysiwyg;
using umbraco.interfaces;
using umbraco.uicontrols;
using umbraco.editorControls.tinymce;

namespace umbraco.editorControls.tinyMCE3 {
    public class TinyMCE : webcontrol.TinyMCEWebControl , IDataEditor, IMenuElement, ILiveEditingDataEditor {
        private IData _data;
        private bool m_isInLiveEditingMode = false;
        private bool _enableContextMenu = false;
        private string _editorButtons = "";
        private string _advancedUsers = "";
        private bool _fullWidth = false;
        private int _width = 0;
        private int _height = 0;
        private bool _showLabel = false;
        private string _plugins = "";
        private ArrayList _stylesheets = new ArrayList();

        private ArrayList _menuIcons = new ArrayList();
        private SortedList _buttons = new SortedList();
        private SortedList _mceButtons = new SortedList();
        private bool _isInitialized = false;
        private string _activateButtons = "";
        private string _disableButtons = "help,visualaid,";
        private int m_maxImageWidth = 500;


        public virtual string Plugins {
            get { return _plugins; }
            set { _plugins = value; }
        }

        public TinyMCE(IData Data, string Configuration) {
            _data = Data;
            try
            {
                string[] configSettings = Configuration.Split("|".ToCharArray());

                if (configSettings.Length > 0)
                {
                    _editorButtons = configSettings[0];

                    if (configSettings.Length > 1)
                        if (configSettings[1] == "1")
                            _enableContextMenu = true;

                    if (configSettings.Length > 2)
                        _advancedUsers = configSettings[2];

                    if (configSettings.Length > 3)
                    {
                        if (configSettings[3] == "1")
                            _fullWidth = true;
                        else if (configSettings[4].Split(',').Length > 1)
                        {
                            _width = int.Parse(configSettings[4].Split(',')[0]);
                            _height = int.Parse(configSettings[4].Split(',')[1]);
                        }
                    }

                    // default width/height
                    if (_width < 1)
                        _width = 500;
                    if (_height < 1)
                        _height = 400;

                    // add stylesheets
                    if (configSettings.Length > 4)
                    {
                        foreach (string s in configSettings[5].Split(",".ToCharArray()))
                            _stylesheets.Add(s);
                    }

                    if (configSettings.Length > 6 && configSettings[6] != "")
                        _showLabel = bool.Parse(configSettings[6]);
                    if (configSettings.Length > 7 && configSettings[7] != "")
                        m_maxImageWidth = int.Parse(configSettings[7].ToString());

                    // sizing
                    if (!_fullWidth)
                    {
                        config.Add("width", _width.ToString());
                        config.Add("height", _height.ToString());
                    }

                    if (_enableContextMenu)
                        _plugins += ",contextmenu";

                    // safari compatibility
                    if (HttpContext.Current.Request.Browser.Browser.ToLower().Contains("safari"))
                    {
                        _plugins += ",safari";
                    }

                    // If the editor is used in umbraco, use umbraco's own toolbar
                    bool onFront = false;
                    if (GlobalSettings.RequestIsInUmbracoApplication(HttpContext.Current) || umbraco.presentation.UmbracoContext.Current.LiveEditingContext.Enabled)
                    {
                        config.Add("theme_umbraco_toolbar_location", "external");
                        config.Add("skin", "umbraco");
                        config.Add("inlinepopups_skin ", "umbraco");
                    }
                    else
                    {
                        onFront = true;
                        config.Add("theme_umbraco_toolbar_location", "top");
                    }

                    // load plugins
                    IDictionaryEnumerator pluginEnum = umbraco.editorControls.tinymce.tinyMCEConfiguration.Plugins.GetEnumerator();
                    while (pluginEnum.MoveNext())
                    {
                        umbraco.editorControls.tinymce.tinyMCEPlugin plugin = (umbraco.editorControls.tinymce.tinyMCEPlugin)pluginEnum.Value;
                        if (plugin.UseOnFrontend || (!onFront && !plugin.UseOnFrontend))
                            _plugins += "," + plugin.Name;
                    }
                    if (_plugins.StartsWith(","))
                        _plugins = _plugins.Substring(1, _plugins.Length - 1);
                    if (_plugins.EndsWith(","))
                        _plugins = _plugins.Substring(0, _plugins.Length - 1);

                    config.Add("plugins", _plugins);

                    // Check advanced settings
                    if (("," + _advancedUsers + ",").IndexOf("," + UmbracoEnsuredPage.CurrentUser.UserType.Id + ",") > -1)
                        config.Add("umbraco_advancedMode", "true");
                    else
                        config.Add("umbraco_advancedMode", "false");

                    // Check maximum image width
                    config.Add("umbraco_maximumDefaultImageWidth", m_maxImageWidth.ToString());

                    // Styles
                    string cssFiles = String.Empty;
                    string styles = string.Empty;
                    foreach (string styleSheetId in _stylesheets)
                    {
                        if (styleSheetId.Trim() != "")
                            try
                            {
                                StyleSheet s = new StyleSheet(int.Parse(styleSheetId));
                                if (s.nodeObjectType == StyleSheet.ModuleObjectType)
                                {
                                    cssFiles += GlobalSettings.Path + "/../css/" + s.Text + ".css";

                                    foreach (StylesheetProperty p in s.Properties)
                                    {
                                        if (styles != string.Empty)
                                        {
                                            styles += ";";
                                        }
                                        if (p.Alias.StartsWith("."))
                                            styles += p.Text + "=" + p.Alias;
                                        else
                                            styles += p.Text + "=" + p.Alias;
                                    }

                                    cssFiles += ",";
                                }
                            }
                            catch (Exception ee)
                            {
                                Log.Add(LogTypes.Error, -1,
                                        string.Format(
                                            string.Format("Error adding stylesheet to tinymce (id: {{0}}). {0}", ee),
                                            styleSheetId));
                            }
                    }
                    // remove any ending comma (,)
                    if (!string.IsNullOrEmpty(cssFiles))
                    {
                        cssFiles = cssFiles.TrimEnd(',');
                    }

                    // language
                    config.Add("language", User.GetCurrent().Language);

                    config.Add("content_css", cssFiles);
                    config.Add("theme_umbraco_styles", styles);

                    // Add buttons
                    IDictionaryEnumerator ide = umbraco.editorControls.tinymce.tinyMCEConfiguration.Commands.GetEnumerator();
                    while (ide.MoveNext())
                    {
                        umbraco.editorControls.tinymce.tinyMCECommand cmd = (umbraco.editorControls.tinymce.tinyMCECommand)ide.Value;
                        if (_editorButtons.IndexOf("," + cmd.Alias + ",") > -1)
                            _activateButtons += cmd.Alias + ",";
                        else
                            _disableButtons += cmd.Alias + ",";
                    }

                    if (_activateButtons.Length > 0)
                        _activateButtons = _activateButtons.Substring(0, _activateButtons.Length - 1);
                    if (_disableButtons.Length > 0)
                        _disableButtons = _disableButtons.Substring(0, _disableButtons.Length - 1);

                    // Add buttons
                    initButtons();
                    _activateButtons = "";

                    int separatorPriority = 0;
                    ide = _mceButtons.GetEnumerator();
                    while (ide.MoveNext())
                    {
                        string mceCommand = ide.Value.ToString();
                        int curPriority = (int)ide.Key;

                        // Check priority
                        if (separatorPriority > 0 &&
                            Math.Floor(decimal.Parse(curPriority.ToString()) / 10) >
                            Math.Floor(decimal.Parse(separatorPriority.ToString()) / 10))
                            _activateButtons += "separator,";

                        _activateButtons += mceCommand + ",";

                        separatorPriority = curPriority;
                    }


                    config.Add("theme_umbraco_buttons1", _activateButtons);
                    config.Add("theme_umbraco_buttons2", "");
                    config.Add("theme_umbraco_buttons3", "");
                    config.Add("theme_umbraco_toolbar_align", "left");
                    config.Add("theme_umbraco_disable", _disableButtons);

                    config.Add("theme_umbraco_path ", "true");
                    config.Add("extended_valid_elements", "div[*]");
                    config.Add("document_base_url", "/");
                    config.Add("relative_urls", "false");
                    config.Add("remove_script_host", "true");
                    config.Add("event_elements", "div");
                    config.Add("paste_auto_cleanup_on_paste", "true");

                    config.Add("valid_elements", tinyMCEConfiguration.ValidElements.Substring(1, tinyMCEConfiguration.ValidElements.Length-2));
                    config.Add("invalid_elements", tinyMCEConfiguration.InvalidElements);

                    // custom commands
                    if (tinyMCEConfiguration.ConfigOptions.Count > 0)
                    {
                        ide = tinyMCEConfiguration.ConfigOptions.GetEnumerator();
                        while (ide.MoveNext())
                        {
                            config.Add(ide.Key.ToString(), ide.Value.ToString());
                        }
                    }

                    //if (HttpContext.Current.Request.Path.IndexOf(GlobalSettings.Path) > -1)
                    //    config.Add("language", User.GetUser(BasePage.GetUserId(BasePage.umbracoUserContextID)).Language);
                    //else
                    //    config.Add("language", System.Threading.Thread.CurrentThread.CurrentCulture.TwoLetterISOLanguageName);

                    if (_fullWidth)
                    {
                        config.Add("auto_resize", "true");
                        base.Columns = 30;
                        base.Rows = 30;
                    }
                    else
                    {
                        base.Columns = 0;
                        base.Rows = 0;
                    }
                    EnableViewState = false;
                }
            }
            catch (Exception ex)
            {
                throw new ArgumentException("Incorrect TinyMCE configuration.", "Configuration", ex);
            }
        }

        #region IDataEditor Members

        #region TreatAsRichTextEditor

        public virtual bool TreatAsRichTextEditor {
            get { return false; }
        }

        #endregion

        #region ShowLabel

        public virtual bool ShowLabel {
            get { return _showLabel; }
        }

        #endregion

        #region Editor

        public Control Editor {
            get { return this; }
        }

        #endregion

        #region Save()

        public virtual void Save() {
            string parsedString = base.Text.Trim();
            if (parsedString != string.Empty) {
                parsedString = replaceMacroTags(parsedString).Trim();

                // clean macros and add paragraph element for tidy
                bool removeParagraphs = false;
                if (parsedString.Length > 16 && parsedString.ToLower().Substring(0, 17) == "|||?umbraco_macro") {
                    removeParagraphs = true;
                    parsedString = "<p>" + parsedString + "</p>";
                }

                // tidy html

                if (UmbracoSettings.TidyEditorContent) {
                    string tidyTxt = library.Tidy(parsedString, false);
                    if (tidyTxt != "[error]") {
                        // compensate for breaking macro tags by tidy
                        parsedString = tidyTxt.Replace("/?>", "/>");
                        if (removeParagraphs) {
                            if (parsedString.Length - parsedString.Replace("<", "").Length == 2)
                                parsedString = parsedString.Replace("<p>", "").Replace("</p>", "");
                        }
                    } else {
                        // TODO
                        // How to log errors? _data.NodeId does not exist?
                        //BusinessLogic.Log.Add(BusinessLogic.LogTypes.Error, BusinessLogic.User.GetUser(0), _data.NodeId, "Error tidying txt from property: " + _data.PropertyId.ToString());
                    }
                }

                // rescue umbraco tags
                parsedString = parsedString.Replace("|||?", "<?").Replace("/|||", "/>").Replace("|*|", "\"");

                // fix images
                parsedString = umbraco.editorControls.tinymce.tinyMCEImageHelper.cleanImages(parsedString);

                // parse current domain and instances of slash before anchor (to fix anchor bug)
                // NH 31-08-2007
                if (HttpContext.Current.Request.ServerVariables != null) {
                    parsedString = parsedString.Replace(helper.GetBaseUrl(HttpContext.Current) + "/#", "#");
                    parsedString = parsedString.Replace(helper.GetBaseUrl(HttpContext.Current), "");
                }

                // if text is an empty parargraph, make it all empty
                if (parsedString.ToLower() == "<p></p>")
                    parsedString = "";
            }
            _data.Value = parsedString;

            // update internal webcontrol value with parsed result
            base.Text = parsedString;
        }

        #endregion

        protected override void OnLoad(EventArgs e) {
            try {
                // add current page info
                base.NodeId = ((cms.businesslogic.datatype.DefaultData)_data).NodeId;
                base.VersionId = ((cms.businesslogic.datatype.DefaultData)_data).Version;
                config.Add("theme_umbraco_pageId", base.NodeId.ToString());
                config.Add("theme_umbraco_versionId", base.VersionId.ToString());

                // we'll need to make an extra check for the liveediting as that value is set after the constructor have initialized
                if (IsInLiveEditingMode)
                {
                    if (config["theme_umbraco_toolbar_location"] == null)
                        config.Add("theme_umbraco_toolbar_location", "");
                    config["theme_umbraco_toolbar_location"] = "external";
                    config.Add("umbraco_toolbar_id",
                               "LiveEditingClientToolbar");

                }
                else {
                    config.Add("umbraco_toolbar_id",
               ElementIdPreFix + ((cms.businesslogic.datatype.DefaultData)_data).PropertyId.ToString());

                }
            } catch {
                // Empty catch as this is caused by the document doesn't exists yet,
                // like when using this on an autoform
            }
            base.OnLoad(e);

        }

        protected override void OnInit(EventArgs e) {
            base.OnInit(e);
            if (_data != null && _data.Value != null)
                base.Text = _data.Value.ToString();
        }

        private string replaceMacroTags(string text) {
            while (findStartTag(text) > -1) {
                string result = text.Substring(findStartTag(text), findEndTag(text) - findStartTag(text));
                text = text.Replace(result, generateMacroTag(result));
            }
            return text;
        }

        private string generateMacroTag(string macroContent) {
            string macroAttr = macroContent.Substring(5, macroContent.IndexOf(">") - 5);
            string macroTag = "|||?UMBRACO_MACRO ";
            Hashtable attributes = ReturnAttributes(macroAttr);
            IDictionaryEnumerator ide = attributes.GetEnumerator();
            while (ide.MoveNext()) {
                if (ide.Key.ToString().IndexOf("umb_") != -1) {
                    // Hack to compensate for Firefox adding all attributes as lowercase
                    string orgKey = ide.Key.ToString();
                    if (orgKey == "umb_macroalias")
                        orgKey = "umb_macroAlias";

                    macroTag += orgKey.Substring(4, orgKey.ToString().Length - 4) + "=|*|" +
                                ide.Value.ToString() + "|*| ";
                }
            }
            macroTag += "/|||";

            return macroTag;
        }

        public static Hashtable ReturnAttributes(String tag) {
            Hashtable ht = new Hashtable();
            MatchCollection m =
                Regex.Matches(tag, "(?<attributeName>\\S*)=\"(?<attributeValue>[^\"]*)\"",
                              RegexOptions.IgnoreCase | RegexOptions.IgnorePatternWhitespace);
            foreach (Match attributeSet in m)
                ht.Add(attributeSet.Groups["attributeName"].Value.ToString(),
                       attributeSet.Groups["attributeValue"].Value.ToString());

            return ht;
        }

        private int findStartTag(string text) {
            string temp = "";
            text = text.ToLower();
            if (text.IndexOf("ismacro=\"true\"") > -1) {
                temp = text.Substring(0, text.IndexOf("ismacro=\"true\""));
                return temp.LastIndexOf("<");
            }
            return -1;
        }

        private int findEndTag(string text) {
            string find = "<!-- endumbmacro -->";

            int endMacroIndex = text.ToLower().IndexOf(find);
            string tempText = text.ToLower().Substring(endMacroIndex + find.Length, text.Length - endMacroIndex - find.Length);
            int finalEndPos = 0;
            while (tempText.Length > 5)
                if (tempText.Substring(finalEndPos, 6) == "</div>")
                    break;
                else
                    finalEndPos++;

            return endMacroIndex + find.Length + finalEndPos + 6;
        }

        #endregion

        #region IDataFieldWithButtons Members

        public object[] MenuIcons {
            get {
                initButtons();

                object[] tempIcons = new object[_menuIcons.Count];
                for (int i = 0; i < _menuIcons.Count; i++)
                    tempIcons[i] = _menuIcons[i];
                return tempIcons;
            }
        }

        private void initButtons() {
            if (!_isInitialized) {
                _isInitialized = true;

                // Add icons for the editor control:
                // Html
                // Preview
                // Style picker, showstyles
                // Bold, italic, Text Gen
                // Align: left, center, right
                // Lists: Bullet, Ordered, indent, undo indent
                // Link, Anchor
                // Insert: Image, macro, table, formular

                foreach (string button in _activateButtons.Split(',')) {
                    if (button.Trim() != "") {
                        try {
                            umbraco.editorControls.tinymce.tinyMCECommand cmd = (umbraco.editorControls.tinymce.tinyMCECommand)umbraco.editorControls.tinymce.tinyMCEConfiguration.Commands[button];

                            string appendValue = "";
                            if (cmd.Value != "")
                                appendValue = ", '" + cmd.Value + "'";
                            _mceButtons.Add(cmd.Priority, cmd.Command);
                            _buttons.Add(cmd.Priority,
                                         new editorButton(cmd.Alias, ui.Text("buttons", cmd.Alias, null), cmd.Icon,
                                                          "tinyMCE.execInstanceCommand('" + ClientID + "', '" +
                                                          cmd.Command + "', " + cmd.UserInterface + appendValue + ")"));
                        } catch (Exception ee) {
                            Log.Add(LogTypes.Error, User.GetUser(0), -1,
                                    string.Format("TinyMCE: Error initializing button '{0}': {1}", button, ee.ToString()));
                        }
                    }
                }

                // add save icon
                int separatorPriority = 0;
                IDictionaryEnumerator ide = _buttons.GetEnumerator();
                while (ide.MoveNext()) {
                    object buttonObj = ide.Value;
                    int curPriority = (int)ide.Key;

                    // Check priority
                    if (separatorPriority > 0 &&
                        Math.Floor(decimal.Parse(curPriority.ToString()) / 10) >
                        Math.Floor(decimal.Parse(separatorPriority.ToString()) / 10))
                        _menuIcons.Add("|");

                    try {
                        editorButton e = (editorButton)buttonObj;

                        MenuIconI menuItem = new MenuIconClass();

                        menuItem.OnClickCommand = e.onClickCommand;
                        menuItem.ImageURL = e.imageUrl;
                        menuItem.AltText = e.alttag;
                        menuItem.ID = e.id;
                        _menuIcons.Add(menuItem);
                    } catch {
                    }

                    separatorPriority = curPriority;
                }
            }
        }

        #endregion

        #region IMenuElement Members

        public string ElementName {
            get { return "div"; }
        }

        public string ElementIdPreFix {
            get { return "umbTinymceMenu"; }
        }

        public string ElementClass {
            get { return "tinymceMenuBar"; }
        }

        public int ExtraMenuWidth {
            get {
                initButtons();
                return _buttons.Count * 40 + 300;
            }
        }

        #endregion

        #region ILiveEditingDataEditor Members

        public Control LiveEditingControl
        {
            get {
                m_isInLiveEditingMode = true;
                base.IsInLiveEditingMode = true;
                return this;

            }
        }

        #endregion
    }
}