/*
 *  Copyright (c) Codiad & Kent Safranski (codiad.com), distributed
 *  as-is and without warranty under the MIT License. See
 *  [root]/license.txt for more. This information must remain intact.
 */

(function(global, $) {

    // Classes from Ace
    var VirtualRenderer = ace.require('ace/virtual_renderer').VirtualRenderer;
    var Editor = ace.require('ace/editor').Editor;
    var EditSession = ace.require('ace/edit_session').EditSession;
    var ModeList = ace.require("ace/ext/modelist");
    var UndoManager = ace.require("ace/undomanager").UndoManager;
    
    // Editor modes that have been loaded
    var editorModes = {};

    var codiad = global.codiad;
    codiad._cursorPoll = null;

    var separatorWidth = 3;

    $(function(){
        codiad.editor.init();
    });

    function SplitContainer(root, children, splitType) {
        var _this = this;

        this.root = root;
        this.splitType = splitType;
        this.childContainers = {};
        this.childElements = {};
        this.splitProp = 0.5;

        this.setChild(0, children[0]);
        this.setChild(1, children[1]);

        this.splitter = $('<div>')
            .addClass('splitter')
            .appendTo(root)
            .draggable({
                axis: (splitType === 'horizontal' ? 'x' : 'y'),
                drag: function(e, ui){
                    if (_this.splitType === 'horizontal') {
                        var w1, w2;
                        w1 = ui.position.left - separatorWidth/2;
                        w2 = _this.root.width() - ui.position.left
                            - separatorWidth/2;
                        _this.splitProp = w1 / _this.root.width();
                        _this.childElements[0]
                            .width(w1)
                            .trigger('h-resize', [true, true]);
                        _this.childElements[1]
                            .width(w2)
                            .css('left', w1 + separatorWidth + 'px')
                            .trigger('h-resize', [true, true]);
                        _this.splitProp = ui.position.left / _this.root.width();
                    } else {
                        var h1, h2;
                         h1 = ui.position.top - separatorWidth/2;
                        h2 = _this.root.width() - ui.position.top
                            - separatorWidth/2;
                        _this.splitProp = h1 / _this.root.height();
                        _this.childElements[0]
                            .height(h1)
                            .trigger('v-resize', [true, true]);
                        _this.childElements[1]
                            .height(h2)
                            .css('top', h1 + separatorWidth + 'px')
                            .trigger('v-resize', [true, true]);
                    }
                }
            });

        if (splitType === 'horizontal') {
            this.splitter
                .addClass('h-splitter')
                .width(separatorWidth)
                .height(root.height());
        } else if (splitType === 'vertical') {
            this.splitter
                .addClass('v-splitter')
                .height(separatorWidth)
                .width(root.width());
        }

        this.root.on('h-resize', function(e, percolateUp, percolateDown){
            e.stopPropagation();
            if (_this.splitType === 'horizontal') {
                var w1, w2;
                w1 = _this.root.width() * _this.splitProp
                    - separatorWidth / 2;
                w2 = _this.root.width() * (1 - _this.splitProp)
                    - separatorWidth / 2;
                _this.childElements[0]
                    .width(w1);
                _this.childElements[1]
                    .width(w2)
                    .css('left', w1 + separatorWidth);
                _this.splitter.css('left', w1);
            } else if (_this.splitType === 'vertical') {
                var w = _this.root.width();
                _this.childElements[0]
                    .width(w);
                _this.childElements[1]
                    .width(w);
                _this.splitter.width(w);
            }
            if (percolateUp) {
                _this.root.parent('.editor-wrapper')
                    .trigger('h-resize', [true ,false]);
            }
            if (! percolateDown) return;
            if (_this.childContainers[0]) {
                _this.childContainers[0].root
                    .trigger('h-resize', [false, true]);
            } else if (_this.childContainers[1]) {
                _this.childContainers[1].root
                    .trigger('h-resize', [false, true]);
            }
        });

        this.root.on('v-resize', function(e, percolateUp, percolateDown){
            e.stopPropagation();
            if (_this.splitType === 'horizontal') {
                var h = _this.root.height();
                _this.childElements[0]
                    .height(h);
                _this.childElements[1]
                    .height(h);
                _this.splitter.height(h);
            } else if (_this.splitType === 'vertical') {
                var h1 = _this.root.height() * _this.splitProp
                    - separatorWidth / 2;
                var h2 = _this.root.height() * (1 - _this.splitProp)
                    - separatorWidth / 2;
                _this.childElements[0]
                    .height(h1);
                _this.childElements[1]
                    .height(h2)
                    .css('top', h1+separatorWidth);
                _this.splitter.css('top', h1);
            }
            if (percolateUp) {
                _this.root.parent('.editor-wrapper')
                    .trigger('v-resize', [true ,false]);
            }
            if (! percolateDown) return;
            if (_this.childContainers[0]) {
                _this.childContainers[0].root
                    .trigger('v-resize', [false, true]);
            } else if (_this.childContainers[1]) {
                _this.childContainers[1].root
                    .trigger('v-resize', [false, true]);
            }
        });

        this.root
            .trigger('h-resize', [false, false])
            .trigger('v-resize', [false, false]);
    }

    SplitContainer.prototype = {
        setChild: function(idx, el){

            if (el instanceof SplitContainer) {
                this.childElements[idx] = el.root;
                this.childContainers[idx] = el;
                el.idx = idx;
            } else {
                this.childElements[idx] = el;
            }

            this.childElements[idx].appendTo(this.root);
            this.cssInit(this.childElements[idx], idx);
        },
        cssInit: function(el, idx){
            var props = {};
            var h1, h2, w1, w2, rh, rw;

            rh = this.root.height();
            rw = this.root.width();

            if (this.splitType === 'horizontal') {

                w1 = rw * this.splitProp - separatorWidth / 2;
                w2 = rw * (1 - this.splitProp) - separatorWidth / 2;

                if (idx === 0) {
                    props = {
                        left: 0,
                        width: w1,
                        height: rh,
                        top: 0
                    };
                } else {
                    props = {
                        left: w1 + separatorWidth,
                        width: w2,
                        height: rh,
                        top: 0
                    };
                }

            } else if (this.splitType === 'vertical') {

                h1 = rh * this.splitProp - separatorWidth / 2;
                h2 = rh * (1 - this.splitProp) - separatorWidth / 2;

                if (idx === 0) {
                    props = {
                        top: 0,
                        height: h1,
                        width: rw,
                        left: 0
                    };
                } else {
                    props = {
                        top: h1 + separatorWidth,
                        height: h2,
                        width: rw,
                        left: 0
                    };
                }

            }

            el.css(props);
        }
    };

    //////////////////////////////////////////////////////////////////
    //
    // Editor Component for Codiad
    // ---------------------------
    // Manage the lifecycle of Editor instances
    //
    //////////////////////////////////////////////////////////////////

    codiad.editor = {

        /// Editor instances - One instance corresponds to an editor
        /// pane in the user interface. Different EditSessions
        /// (ace/edit_session)
        instances: [],

        /// Currently focussed editor
        activeInstance: null,

        // Settings for Editor instances
        settings: {
        	autocomplete: false,
            theme: 'twilight',
            fontSize: '13px',
            printMargin: false,
            printMarginColumn: 80,
            highlightLine: true,
            indentGuides: true,
            wrapMode: false,
            softTabs: false,
            persistentModal: true,
            rightSidebarTrigger: false,
            fileManagerTrigger: false,
            tabSize: 4
        },
		
		multi_line: false,
		
        rootContainer: null,

        fileExtensionTextMode: {},
        
        init: function(){
            this.createSplitMenu();
            this.createModeMenu();

            var er = $('#editor-region');

            er.on('h-resize-init', function(){
                $('#editor-region > .editor-wrapper')
                    .width($(this).width())
                    .trigger('h-resize');

            }).on('v-resize-init', function(){
                $('#editor-region > .editor-wrapper')
                    .height($(this).height())
                    .trigger('v-resize');
            });
			
			$("#root-editor-wrapper").live("contextmenu", function( e ) {
					
				// Context Menu
                e.preventDefault();
                _this = codiad.editor
                
                if( _this.getActive() ) {
                	
	                let path = codiad.active.getPath();
	                $(e.target).attr('data-path', path);
	                codiad.filemanager.contextMenuShow( e, path, 'editor', 'editor');
	                $(this).addClass('context-menu-active');
                }
            });
			
            $(window).resize(function(){
                $('#editor-region')
                    .trigger('h-resize-init')
                    .trigger('v-resize-init');
            });
            
            //Load settings when initially starting up that way the first editor 
            //we open doesn't have the default settings.
            this.getSettings();
        },

        //////////////////////////////////////////////////////////////////
        //
        // Retrieve editor settings from database
        //
        //////////////////////////////////////////////////////////////////

        getSettings: async function() {
        	
            let boolVal = null;
            let _this = this;
			let options = [
				'editor.fontSize',
				'editor.overScroll',
				'editor.printMarginColumn',
				'editor.tabSize',
				'editor.theme',
			];
			let bool_options = [
				'editor.autocomplete',
				'settings.autosave',
				'editor.printMargin',
				'editor.highlightLine',
				'editor.indentGuides',
				'editor.wrapMode',
				'editor.rightSidebarTrigger',
				'editor.fileManagerTrigger',
				'editor.softTabs',
				'editor.persistentModal',
			];
			
			let user_settings = await codiad.settings.get_options();
			
			//console.log( user_settings );
			
            $.each( options, function( idx, key ) {
            	
                let localValue = user_settings['codiad.' + key];
                if ( localValue != null ) {
            		
                    _this.settings[key.split('.').pop()] = localValue;
                }
            });

            $.each( bool_options, async function(idx, key) {
            	
               let localValue = user_settings['codiad.' + key];
               if ( localValue != null ) {
               	
        			_this.settings[key.split('.').pop()] = (localValue == 'true');
               }
           });
        },

        /////////////////////////////////////////////////////////////////
        //
        // Apply configuration settings
        //
        // Parameters:
        //   i - {Editor}
        //
        /////////////////////////////////////////////////////////////////

        applySettings: function(i) {
            // Check user-specified settings
            this.getSettings();

            // Apply the current configuration settings:
            i.setTheme('ace/theme/' + this.settings.theme);
            i.setFontSize(this.settings.fontSize);
            i.setPrintMarginColumn(this.settings.printMarginColumn);
            i.setShowPrintMargin(this.settings.printMargin);
            i.setHighlightActiveLine(this.settings.highlightLine);
            i.setDisplayIndentGuides(this.settings.indentGuides);
            i.getSession().setUseWrapMode(this.settings.wrapMode);
            this.setTabSize(this.settings.tabSize, i);
            this.setSoftTabs(this.settings.softTabs, i);
            this.setOverScroll(this.settings.overScroll, i);
        	i.setOptions({
		        enableBasicAutocompletion: true,
		        enableSnippets: true,
		        enableLiveAutocompletion: this.settings.autocomplete
		    });
        },

        //////////////////////////////////////////////////////////////////
        //
        // Create a new editor instance attached to given session
        //
        // Parameters:
        //   session - {EditSession} Session to be used for new Editor instance
        //
        //////////////////////////////////////////////////////////////////

        addInstance: function(session, where) {
            var el = $('<div class="editor">');
            var chType, chArr = [], sc = null, chIdx = null;
            var _this = this;

            if (this.instances.length == 0) {
                // el.appendTo($('#editor-region'));
                el.appendTo($('#root-editor-wrapper'));
            } else {

                var ch = this.activeInstance.el;
                var root;

                chIdx = (where === 'top' || where === 'left') ? 0 : 1;
                chType = (where === 'top' || where === 'bottom') ?
                    'vertical' : 'horizontal';

                chArr[chIdx] = el;
                chArr[1 - chIdx] = ch;

                root = $('<div class="editor-wrapper">')
                    .height(ch.height())
                    .width(ch.width())
                    .addClass('editor-wrapper-' + chType)
                    .appendTo(ch.parent());

                sc = new SplitContainer(root, chArr, chType);

                if (this.instances.length > 1) {
                    var pContainer = this.activeInstance.splitContainer;
                    var idx = this.activeInstance.splitIdx;
                    pContainer.setChild(idx, sc);
                }
            }
            
			ace.require("ace/ext/language_tools");
            var i = ace.edit(el[0]);
            var resizeEditor = function(){
                i.resize();
            };
			
            if (sc) {
                i.splitContainer = sc;
                i.splitIdx = chIdx;

                this.activeInstance.splitContainer = sc;
                this.activeInstance.splitIdx = 1 - chIdx;

                sc.root
                    .on('h-resize', resizeEditor)
                    .on('v-resize', resizeEditor);

                if (this.instances.length === 1) {
                    var re = function(){
                        _this.instances[0].resize();
                    };
                    sc.root
                        .on('h-resize', re)
                        .on('v-resize', re);
                }
            }

            i.el = el;
            this.setSession(session, i);

            this.changeListener(i);
            this.cursorTracking(i);
            this.clickListener(i);
            this.bindKeys(i);

            this.instances.push(i);

            i.on('focus', function(){
                _this.focus(i);
            });

            return i;
        },

        createSplitMenu: function(){
            var _this = this;
            var _splitOptionsMenu = $('#split-options-menu');

            this.initMenuHandler($('#split'),_splitOptionsMenu);

            $('#split-horizontally a').click(function(e){
                e.stopPropagation();
                _this.addInstance(_this.activeInstance.getSession(), 'bottom');
                _splitOptionsMenu.hide();
            });

            $('#split-vertically a').click(function(e){
                e.stopPropagation();
                _this.addInstance(_this.activeInstance.getSession(), 'right');
                _splitOptionsMenu.hide();
            });

            $('#merge-all a').click(function(e){
                e.stopPropagation();
                var s = _this.activeInstance.getSession();
                _this.exterminate();
                _this.addInstance(s);
                _splitOptionsMenu.hide();
            });
        },

        createModeMenu: function(){
            var _this = this;
            var _thisMenu = $('#changemode-menu');
            var modeColumns = new Array();
            var modeOptions = new Array();
            var maxOptionsColumn = 15;
            var firstOption = 0;

            this.initMenuHandler($('#current-mode'),_thisMenu);
            
            var modes = Object.keys( ModeList.modesByName ).sort();
            
            $.each(modes, function(i){
                modeOptions.push('<li><a>'+modes[i]+'</a></li>');     
            });
                       
            var html = '<table><tr>';
            while(true) {
                html += '<td><ul>';
                if ((modeOptions.length-firstOption) < maxOptionsColumn) {
                    max = modeOptions.length;
                } else {
                    max = firstOption + maxOptionsColumn;
                }
                var currentcolumn = modeOptions.slice(firstOption, max);
                for (var option in currentcolumn) {
                    html += currentcolumn[option];
                }
                html += '</ul></td>';
                firstOption = firstOption +  maxOptionsColumn;
                if(firstOption >= modeOptions.length) {
                    break;
                }
            }
            
            html += '</tr></table>';
            _thisMenu.html(html);

            $('#changemode-menu a').click(function(e){
                e.stopPropagation();
                var newMode = "ace/mode/" + $(e.currentTarget).text();
                var actSession = _this.activeInstance.getSession();

                // handle async mode change
                var fn = function(){
                   _this.setModeDisplay(actSession);
                   actSession.removeListener('changeMode', fn);
                };
                actSession.on("changeMode", fn);

                actSession.setMode(newMode);
                _thisMenu.hide();

            });
        },

        initMenuHandler: function(button,menu){
            var _this = this;
            var thisButton = button;
            var thisMenu = menu;

            thisMenu.appendTo($('body'));

            thisButton.click(function(e){
                var wh = $(window).height();

                e.stopPropagation();

                // close other menus
                _this.closeMenus(thisMenu);

                thisMenu.css({
                    // display: 'block',
                    bottom: ( (wh - $(this).offset().top) + 8) + 'px',
                    left: ($(this).offset().left - 13) + 'px'
                });

                thisMenu.slideToggle('fast');

                // handle click-out autoclosing
                var fn = function(){
                    thisMenu.hide();
                    $(window).off('click', fn);
                };
                $(window).on('click', fn);
            });
        },

        closeMenus: function(exclude){
            var menuId = exclude.attr("id");
            if(menuId != 'split-options-menu') $('#split-options-menu').hide();
            if(menuId != 'changemode-menu') $('#changemode-menu').hide();
        },

        setModeDisplay: function(session){
                var currMode = session.getMode().$id;
                if(currMode){
                    currMode = currMode.substring(currMode.lastIndexOf('/') + 1);
                    $('#current-mode').html(currMode);
                }  else {
                    $('#current-mode').html('text');
                }
        },

        //////////////////////////////////////////////////////////////////
        //
        // Remove all Editor instances and clean up the DOM
        //
        //////////////////////////////////////////////////////////////////

        exterminate: function() {
            $('.editor').remove();
            $('.editor-wrapper').remove();
            $('#editor-region').append($('<div>').attr('id', 'editor'));
            $('#current-file').html('');
            $('#current-mode').html('');
            this.instances = [];
            this.activeInstance = null;
        },

        //////////////////////////////////////////////////////////////////
        //
        // Detach EditSession session from all Editor instances replacing
        // them with replacementSession
        //
        //////////////////////////////////////////////////////////////////

        removeSession: function(session, replacementSession) {
            for (var k = 0; k < this.instances.length; k++) {
                if (this.instances[k].getSession().path === session.path) {
                    this.instances[k].setSession(replacementSession);
                }
            }
            if ($('#current-file').text() === session.path) {
                $('#current-file').text(replacementSession.path);
            }

            this.setModeDisplay(replacementSession);
        },

        isOpen: function(session){
            for (var k = 0; k < this.instances.length; k++) {
                if (this.instances[k].getSession().path === session.path) {
                    return true;
                }
            }
            return false;
        },

        /////////////////////////////////////////////////////////////////
        //
        // Convenience function to iterate over Editor instances
        //
        // Parameters:
        //   fn - {Function} callback called with each member as an argument
        //
        /////////////////////////////////////////////////////////////////

        forEach: function(fn) {
            for (var k = 0; k < this.instances.length; k++) {
                fn.call(this, this.instances[k]);
            }
        },

        /////////////////////////////////////////////////////////////////
        //
        // Get the currently active Editor instance
        //
        // In a multi-pane setup this would correspond to the
        // editor pane user is currently working on.
        //
        /////////////////////////////////////////////////////////////////

        getActive: function() {
            return this.activeInstance;
        },

        /////////////////////////////////////////////////////////////////
        //
        // Set an editor instance as active
        //
        // Parameters:
        //   i - {Editor}
        //
        /////////////////////////////////////////////////////////////////

        setActive: function(i) {
            if (! i) return;
            this.activeInstance = i;
            $('#current-file').text(i.getSession().path);
            this.setModeDisplay(i.getSession());
        },

        /////////////////////////////////////////////////////////////////
        //
        // Change the EditSession of Editor instance
        //
        // Parameters:
        //   session - {EditSession}
        //   i - {Editor}
        //
        /////////////////////////////////////////////////////////////////

        setSession: function(session, i) {
            i = i || this.getActive();
            if (! this.isOpen(session)) {
                if (! i) {
                    i = this.addInstance(session);
                } else {
                    i.setSession(session);
                }
            } else {
                // Proxy session is required because scroll-position and
                // cursor position etc. are shared among sessions.

                var proxySession = new EditSession(session.getDocument(),
                                                   session.getMode());
                proxySession.setUndoManager(new UndoManager());
                proxySession.path = session.path;
                proxySession.listThumb = session.listThumb;
                proxySession.tabThumb = session.tabThumb;
                if (! i) {
                    i = this.addInstance(proxySession);
                } else {
                    i.setSession(proxySession);
                }
            }
            this.applySettings(i);
            this.cursorTracking(i);
            this.setActive(i);
        },

        /////////////////////////////////////////////////////////////////
        //
        // Select file mode by extension case insensitive
        //
        // Parameters:
        // e - {String} File extension
        //
        /////////////////////////////////////////////////////////////////

        selectMode: function(e) {
            if(typeof(e) != 'string'){
                return 'text';
            }
            e = e.toLowerCase();
            return( ModeList.getModeForPath( e ) );
        },

        /////////////////////////////////////////////////////////////////
        //
        // Add an text mode for an extension
        //
        // Parameters:
        // extension - {String} File Extension
        // mode - {String} TextMode for this extension
        //
        /////////////////////////////////////////////////////////////////
        
        addFileExtensionTextMode: function(extension, mode){
            if(typeof(extension) != 'string' || typeof(mode) != 'string'){
                if (console){
                    console.warn('wrong usage of addFileExtensionTextMode, both parameters need to be string');
                }
                return;
            }
            mode = mode.toLowerCase();
            this.fileExtensionTextMode[extension] = mode;
        },
        
        /////////////////////////////////////////////////////////////////
        //
        // clear all extension-text mode joins
        //
        /////////////////////////////////////////////////////////////////
        
        clearFileExtensionTextMode: function(){
            this.fileExtensionTextMode = {};
        },
        
        /////////////////////////////////////////////////////////////////
        //
        // Set the editor mode
        //
        // Parameters:
        //   m - {TextMode} mode
        //   i - {Editor} Editor (Defaults to active editor)
        //
        /////////////////////////////////////////////////////////////////

        setMode: function(m, i) {
            i = i || this.getActive();

            // Check if mode is already loaded
            if (! editorModes[m]) {

                // Load the Mode
                var modeFile = 'components/editor/ace-editor/mode-' + m + '.js';
                $.loadScript(modeFile, function() {

                    // Mark the mode as loaded
                    editorModes[m] = true;
                    var EditorMode = ace.require('ace/mode/' + m).Mode;
                    i.getSession().setMode(new EditorMode());
                }, true);
            } else {

                var EditorMode = ace.require('ace/mode/' + m).Mode;
                i.getSession().setMode(new EditorMode());

            }
        },

        /////////////////////////////////////////////////////////////////
        //
        // Set the editor theme
        //
        // Parameters:
        //   t - {String} theme eg. twilight, cobalt etc.
        //   i - {Editor} Editor instance (If omitted, Defaults to all editors)
        //
        // For a list of themes supported by Ace - refer :
        //   https://github.com/ajaxorg/ace/tree/master/lib/ace/theme
        //
        // TODO: Provide support for custom themes
        //
        /////////////////////////////////////////////////////////////////

        setTheme: function(t, i) {
            if (i) {
                // If a specific instance is specified, change the theme for
                // this instance
                i.setTheme('ace/theme/'+ t);
            } else {
                // Change the theme for the existing editor instances
                // and make it the default for new instances
                this.settings.theme = t;
                for (var k = 0; k < this.instances.length; k++) {
                    this.instances[k].setTheme('ace/theme/'+ t);
                }
            }
            //Database
            //codiad.settings.update_option( 'codiad.editor.theme', t );
        },

        /////////////////////////////////////////////////////////////////
        //
        // Set contents of the editor
        //
        // Parameters:
        //   c - {String} content
        //   i - {Editor} (Defaults to active editor)
        //
        /////////////////////////////////////////////////////////////////

        setContent: function(c, i) {
            i = i || this.getActive();
            i.getSession().setValue(c);
        },

        /////////////////////////////////////////////////////////////////
        //
        // Set Font Size
        //
        // Set the font for all Editor instances and remember
        // the value for Editor instances to be created in
        // future
        //
        // Parameters:
        //   s - {Number} font size
        //   i - {Editor} Editor instance  (If omitted, Defaults to all editors)
        //
        /////////////////////////////////////////////////////////////////

        setFontSize: function(s, i) {
            if (i) {
                i.setFontSize(s);
            } else {
                this.settings.fontSize = s;
                this.forEach(function(i) {
                    i.setFontSize(s);
                });
            }
            //Database
            //codiad.settings.update_option( 'codiad.editor.fontSize', s );
        },


        /////////////////////////////////////////////////////////////////
        //
        // Enable/disable Highlighting of active line
        //
        // Parameters:
        //   h - {Boolean}
        //   i - {Editor} Editor instance ( If left out, setting is
        //                    applied to all editors )
        //
        /////////////////////////////////////////////////////////////////

        setHighlightLine: function(h, i) {
            if (i) {
                i.setHighlightActiveLine(h);
            } else {
                this.settings.highlightLine = h;
                this.forEach(function(i) {
                    i.setHighlightActiveLine(h);
                });
            }
            //Database
            //codiad.settings.update_option( 'codiad.editor.highlightLine', h );
        },

        //////////////////////////////////////////////////////////////////
        //
        // Show/Hide print margin indicator
        //
        // Parameters:
        //   p - {Number} print margin column
        //   i - {Editor}  (If omitted, Defaults to all editors)
        //
        //////////////////////////////////////////////////////////////////

        setPrintMargin: function(p, i) {
            if (i) {
                i.setShowPrintMargin(p);
            } else {
                this.settings.printMargin = p;
                this.forEach(function(i) {
                    i.setShowPrintMargin(p);
                });
            }
            //Database
            //codiad.settings.update_option( 'codiad.editor.printMargin', p );
        },

        //////////////////////////////////////////////////////////////////
        //
        // Set print margin column
        //
        // Parameters:
        //   p - {Number} print margin column
        //   i - {Editor}  (If omitted, Defaults to all editors)
        //
        //////////////////////////////////////////////////////////////////

        setPrintMarginColumn: function(p, i) {
            if (i) {
                i.setPrintMarginColumn(p);
            } else {
                this.settings.printMarginColumn = p;
                this.forEach(function(i) {
                    i.setPrintMarginColumn(p);
                });
            }
            //Database
            //codiad.settings.update_option( 'codiad.editor.printMarginColumn', p );
        },

        //////////////////////////////////////////////////////////////////
        //
        // Show/Hide indent guides
        //
        // Parameters:
        //   g - {Boolean}
        //   i - {Editor}  (If omitted, Defaults to all editors)
        //
        //////////////////////////////////////////////////////////////////

        setIndentGuides: function(g, i) {
            if (i) {
                i.setDisplayIndentGuides(g);
            } else {
                this.settings.indentGuides = g;
                this.forEach(function(i) {
                    i.setDisplayIndentGuides(g);
                });
            }
            //Database
            //codiad.settings.update_option( 'codiad.editor.indentGuides', g );
        },

        //////////////////////////////////////////////////////////////////
        //
        // Enable/Disable Code Folding
        //
        // Parameters:
        //   f - {Boolean}
        //   i - {Editor}  (If omitted, Defaults to all editors)
        //
        //////////////////////////////////////////////////////////////////

        setCodeFolding: function(f, i) {
            if (i) {
                i.setFoldStyle(f);
            } else {
                this.forEach(function(i) {
                    i.setFoldStyle(f);
                });
            }
        },

        //////////////////////////////////////////////////////////////////
        //
        // Enable/Disable Line Wrapping
        //
        // Parameters:
        //   w - {Boolean}
        //   i - {Editor}  (If omitted, Defaults to all editors)
        //
        //////////////////////////////////////////////////////////////////

        setWrapMode: function(w, i) {
            if (i) {
                i.getSession().setUseWrapMode(w);
            } else {
                this.forEach(function(i) {
                    i.getSession().setUseWrapMode(w);
                });
            }
            //Database
            //codiad.settings.update_option( 'codiad.editor.wrapMode', w );
        },
        
        //////////////////////////////////////////////////////////////////
        //
        // Set last position of modal to be saved
        //
        // Parameters:
        //   t - {Boolean} (false for Automatic Position, true for Last Position)
        //   i - {Editor}  (If omitted, Defaults to all editors)
        //
        //////////////////////////////////////////////////////////////////

        setPersistentModal: function(t, i) {
            this.settings.persistentModal = t;
            //Database
            //codiad.settings.update_option( 'codiad.editor.persistentModal', t );
        },

        //////////////////////////////////////////////////////////////////
        //
        // Set trigger for opening the right sidebar
        //
        // Parameters:
        //   t - {Boolean} (false for Hover, true for Click)
        //   i - {Editor}  (If omitted, Defaults to all editors)
        //
        //////////////////////////////////////////////////////////////////

        setRightSidebarTrigger: function(t, i) {
            this.settings.rightSidebarTrigger = t;
            //Database
            //codiad.settings.update_option( 'codiad.editor.rightSidebarTrigger', t );
        },
        
        //////////////////////////////////////////////////////////////////
        //
        // Set trigger for clicking on the filemanager
        //
        // Parameters:
        //   t - {Boolean} (false for Hover, true for Click)
        //   i - {Editor}  (If omitted, Defaults to all editors)
        //
        //////////////////////////////////////////////////////////////////

        setFileManagerTrigger: function(t, i) {
            this.settings.fileManagerTrigger = t;
            //Database
            //codiad.settings.update_option( 'codiad.editor.fileManagerTrigger', t );
            codiad.project.loadSide();
        },
        
        
        //////////////////////////////////////////////////////////////////
        //
        // set Tab Size
        //
        // Parameters:
        //   s - size
        //   i - {Editor}  (If omitted, Defaults to all editors)
        //
        //////////////////////////////////////////////////////////////////

        setTabSize: function(s, i) {
            if (i) {
                i.getSession().setTabSize(parseInt(s));
            } else {
                this.forEach(function(i) {
                    i.getSession().setTabSize(parseInt(s));
                });
            }
            //Database
            //codiad.settings.update_option( 'codiad.editor.tabSize', s );
            
        },
        
        //////////////////////////////////////////////////////////////////
        //
        // Enable or disable Soft Tabs
        //
        // Parameters:
        //   t - true / false
        //   i - {Editor}  (If omitted, Defaults to all editors)
        //
        //////////////////////////////////////////////////////////////////

        setSoftTabs: function(t, i) {
            if (i) {
                i.getSession().setUseSoftTabs(t);
            } else {
                this.forEach(function(i) {
                    i.getSession().setUseSoftTabs(t);
                });
            }
            //Database
            //codiad.settings.update_option( 'codiad.editor.softTabs', t );
            
        },
        
        //////////////////////////////////////////////////////////////////
        //
        // Get content from editor
        //
        // Parameters:
        //   i - {Editor} (Defaults to active editor)
        //
        //////////////////////////////////////////////////////////////////

        getContent: function(i) {
            i = i || this.getActive();
            if (! i) return;
            var content = i.getSession().getValue();
            if (!content) {
                content = ' ';
            } // Pass something through
            return content;
        },

        //////////////////////////////////////////////////////////////////
        //
        // Resize the editor - Trigger the editor to readjust its layout
        // esp if the container has been resized manually.
        //
        // Parameters:
        //   i - {Editor} (Defaults to active editor)
        //
        //////////////////////////////////////////////////////////////////

        resize: function(i) {
            i = i || this.getActive();
            if (! i) return;
            i.resize();
        },

        //////////////////////////////////////////////////////////////////
        //
        // Mark the instance as changed (in the user interface)
        // upon change in the document content.
        //
        // Parameters:
        //   i - {Editor}
        //
        //////////////////////////////////////////////////////////////////

        changeListener: function(i) {
        	
            var _this = this;
            i.on('change', function() {
            	
                codiad.active.markChanged(_this.getActive().getSession().path);
                codiad.active.savePosition();
            });
        },
        
        clickListener: function(i) {
        	
            var _this = this;
            i.on('click', function() {
            	
                codiad.active.savePosition();
            });
        },

        //////////////////////////////////////////////////////////////////
        //
        // Get Selected Text
        //
        // Parameters:
        //   i - {Editor} (Defaults to active editor)
        //
        //////////////////////////////////////////////////////////////////

        getSelectedText: function(i) {
            i = i || this.getActive();
            if (! i) return;
            return i.getCopyText();
        },

        //////////////////////////////////////////////////////////////////
        //
        // Insert text
        //
        // Parameters:
        //   val - {String} Text to be inserted
        //   i - {Editor} (Defaults to active editor)
        //
        //////////////////////////////////////////////////////////////////

        insertText: function(val, i) {
            i = i || this.getActive();
            if (! i) return;
            i.insert(val);
        },

        //////////////////////////////////////////////////////////////////
        //
        // Move the cursor to a particular line
        //
        // Parameters:
        //   line - {Number} Line number
        //   i - {Editor} Editor instance
        //
        //////////////////////////////////////////////////////////////////

        gotoLine: function(line, i) {
            i = i || this.getActive();
            if (! i) return;
            i.gotoLine(line, 0, true);
        },

        //////////////////////////////////////////////////////////////////
        //
        // Focus an editor
        //
        // Parameters:
        //   i - {Editor} Editor instance (Defaults to current editor)
        //
        //////////////////////////////////////////////////////////////////

        focus: function(i) {
            i = i || this.getActive();
            this.setActive(i);
            if (! i) return;
            i.focus();
            codiad.active.focus(i.getSession().path);
            this.cursorTracking(i);
        },

        //////////////////////////////////////////////////////////////////
        //
        // Setup Cursor Tracking
        //
        // Parameters:
        //   i - {Editor} (Defaults to active editor)
        //
        //////////////////////////////////////////////////////////////////

        cursorTracking: function(i) {
        	
            i = i || this.getActive();
            if (! i) return;
            
            /**
             * Update the cursor position now so that when a new file opens,
             * we do not have the old cursor data.
             */
            
            $('#cursor-position')
                .html(i18n('Ln') + ': '
                          + (i.getCursorPosition().row + 1)
                          + ' &middot; ' + i18n('Col') + ': '
                          + i.getCursorPosition().column
                        );
            
            //Register the changecursor function so updates continue
            i.selection.on( "changeCursor", function( e ) {
            	
            	codiad.active.savePosition();
            	$('#cursor-position')
                .html(i18n('Ln') + ': '
                          + (i.getCursorPosition().row + 1)
                          + ' &middot; ' + i18n('Col') + ': '
                          + i.getCursorPosition().column
                        );
            });
        },

        //////////////////////////////////////////////////////////////////
        //
        // Setup Key bindings
        //
        // Parameters:
        //   i - {Editor}
        //
        //////////////////////////////////////////////////////////////////

        bindKeys: function(i) {

            var _this = this;

            // Find
            i.commands.addCommand({
                name: 'Find',
                bindKey: {
                    win: 'Ctrl-F',
                    mac: 'Command-F'
                },
                exec: function(e) {
                    _this.openSearch('find');
                }
            });

            // Find + Replace
            i.commands.addCommand({
                name: 'Replace',
                bindKey: {
                    win: 'Ctrl-R',
                    mac: 'Command-R'
                },
                exec: function(e) {
                    _this.openSearch('replace');
                }
            });

            i.commands.addCommand({
                name: 'Move Up',
                bindKey: {
                    win: 'Ctrl-up',
                    mac: 'Command-up'
                },
                exec: function(e) {
                    codiad.active.move('up');
                }
            });

            i.commands.addCommand({
                name: 'Move Down',
                bindKey: {
                    win: 'Ctrl-down',
                    mac: 'Command-up'
                },
                exec: function(e) {
                    codiad.active.move('down');
                }
            });

        },

        //////////////////////////////////////////////////////////////////
        //
        // Present the Search (Find + Replace) dialog box
        //
        // Parameters:
        //   type - {String} Optional, defaults to find. Provide 'replace' for replace dialog.
        //
        //////////////////////////////////////////////////////////////////

        openSearch: function(type) {
            if (this.getActive()) {
                codiad.modal.load(400,
                           'components/editor/dialog.php?action=search&type=' +
                           type);
                codiad.modal.hideOverlay();
            } else {
                codiad.message.error('No Open Files');
            }
        },

        //////////////////////////////////////////////////////////////////
        //
        // Perform Search (Find + Replace) operation
        //
        // Parameters:
        //   action - {String} find | replace | replaceAll
        //   i - {Editor} Defaults to active Editor instance
        //
        //////////////////////////////////////////////////////////////////

        search: function(action, i) {
            i = i || this.getActive();
            if (! i) return;
            if( this.multi_line ) {
            	
            	var find = $('#modal textarea[name="find"]')
                .val();
            	var replace = $('#modal textarea[name="replace"]')
                .val();
            } else {
            	
            	var find = $('#modal input[name="find"]')
                .val();
            	var replace = $('#modal input[name="replace"]')
                .val();
            }
            switch (action) {
            case 'find':

                i.find(find, {
                    backwards: false,
                    wrap: true,
                    caseSensitive: false,
                    wholeWord: false,
                    regExp: false
                });

                break;

            case 'replace':

                i.find(find, {
                    backwards: false,
                    wrap: true,
                    caseSensitive: false,
                    wholeWord: false,
                    regExp: false
                });
                i.replace(replace);

                break;

            case 'replaceAll':

                i.find(find, {
                    backwards: false,
                    wrap: true,
                    caseSensitive: false,
                    wholeWord: false,
                    regExp: false
                });
                i.replaceAll(replace);

                break;
            }
        },
        
        //////////////////////////////////////////////////////////////////
        //
        // Enable editor
        //
        // Parameters:
        //   i - {Editor} (Defaults to active editor)
        //
        //////////////////////////////////////////////////////////////////

        enableEditing: function(i) {
            i = i || this.getActive();
            if (! i) return;
            i.textInput.setReadOnly( false );
        },
        
        //////////////////////////////////////////////////////////////////
        //
        // Disable editor
        //
        // Parameters:
        //   i - {Editor} (Defaults to active editor)
        //
        //////////////////////////////////////////////////////////////////

        disableEditing: function(i) {
            i = i || this.getActive();
            if (! i) return;
            i.textInput.setReadOnly( true );
        },
        
        //////////////////////////////////////////////////////////////////
        //
        // Set Overscroll
        //
        // Parameters:
        //   i - {Editor} (Defaults to active editor)
        //
        //////////////////////////////////////////////////////////////////

        setOverScroll: function( s, i ) {
        
            if (i) {
                i.setOption( "scrollPastEnd", s );
            } else {
                this.settings.overScroll = s;
                this.forEach(function(i) {
                   i.setOption( "scrollPastEnd", s );
                });
            }
            //Database
            //codiad.settings.update_option( 'codiad.editor.overScroll', s );
        },
        
        setLiveAutocomplete: function( s, i ) {
        	
            if (i) {
                i.setOptions({
					enableLiveAutocompletion: s
				});
            } else {
                this.settings.autocomplete = s;
                this.forEach(function(i) {
                   i.setOptions({
						enableLiveAutocompletion: s
					});
                });
            }
            //Database
            //codiad.settings.update_option( 'codiad.editor.autocomplete', s );
        },
		
		toggleMultiLine: function( e ) {
			
			if( e.innerText === "Multi Line" ) {
				
				this.multi_line = true;
				e.innerText = "Single Line";
				$('input[name="find"]').hide();
				$('textarea[name="find"]').show();
				$('textarea[name="find"]').val( $('input[name="find"]').val() );
				
				$('input[name="replace"]').hide();
				$('textarea[name="replace"]').show();
				$('textarea[name="replace"]').val( $('input[name="replace"]').val() );
			} else {
				
				this.multi_line = false;
				e.innerText = "Multi Line";
				$('input[name="find"]').show();
				$('textarea[name="find"]').hide();
				$('input[name="find"]').val( $('textarea[name="find"]').val() );
				
				$('input[name="replace"]').show();
				$('textarea[name="replace"]').hide();
				$('input[name="replace"]').val( $('textarea[name="replace"]').val() );
			}
		},
		
		paste: function(  ) {
			
			navigator.clipboard.readText().then(text => {codiad.editor.getActive().insert( text )});
		},
		
		openSort: function() {
			
			if ( this.getActive() && codiad.active.getSelectedText() != "" ) {
				
                codiad.modal.load( 400, 'components/editor/dialog.php?action=sort' );
                codiad.modal.hideOverlay();
            } else {
        	 	
                codiad.message.error('No text selected');
            }
		},
		
		sort: function( eol ) {
			
			let text = $('#modal textarea[name="sort"]').val();
			let array = text.split( eol );
			array = array.sort( codiad.editor.sort_a );
			let sorted = array.join( eol );
			
			console.log( text, eol, array, sorted );
			codiad.modal.unload();
			codiad.editor.getActive().insert( sorted );
			codiad.editor.getActive().focus();
		},
		
		sort_a: function( a, b ) {
			
			let pos = 0;
			let case_sensitive = $( '#modal input[name="case_sensitive"]' ).prop( 'checked' )
			
			if( ! case_sensitive ) {
				
				a = a.toLowerCase();
				b = b.toLowerCase();
			}
			
			if( a < b ) {
				
				pos = -1;
			} else if( a > b ) {
				
				pos = 1;
			}
			
			return pos;
		}
    };

})(this, jQuery);