define(function(require, exports, module) {
    main.consumes = [
        "Plugin", "ui", "layout", "commands", "fs", "navigate", "save", 
        "tabbehavior", "ace", "commands", "tabManager"
    ];
    main.provides = ["vim.cli"];
    return main;

    function main(options, imports, register) {
        var Plugin = imports.Plugin;
        var ui = imports.ui;
        var commands = imports.commands;
        var layout = imports.layout;
        var fs = imports.fs;
        var navigate = imports.navigate;
        var save = imports.save;
        var tabbehavior = imports.tabbehavior;
        var tabManager = imports.tabManager;
        var ace = imports.ace;
        
        var Vim = require('ace/keyboard/vim').Vim;
        var Editor = require("ace/editor").Editor;
        var lang = require("ace/lib/lang");
        var pathLib = require("path");

        /***** Initialization *****/
        
        var plugin = new Plugin("Ajax.org", main.consumes);
        var emit = plugin.getEmitter();
        
        var cmdLine;
        
        var searchStore = {
            current: "",
            options: {
                needle: "",
                backwards: false,
                wrap: true,
                caseSensitive: false,
                wholeWord: false,
                regExp: false
            }
        };
        
        var loaded = false;
        function load() {
            if (loaded) return false;
            loaded = true;
            
        }
        
        var drawn = false;
        function draw() {
            if (drawn) return;
            drawn = true;
            
            cmdLine = new apf.codebox();
            layout.findParent(plugin).appendChild(cmdLine);
            cmdLine.setHeight(23);
            cmdLine.$ext.className = "searchbox tb_console vimInput";
            
            updateTheme();
            initCmdLine(cmdLine.ace);
            
            ace.on("themeChange", updateTheme, plugin);
            
            emit("draw");
        }
        
        function updateTheme() {
            if (!cmdLine)
                return;
                
            var activeTheme = ace.theme; // themes.getActiveTheme();
            if (!activeTheme)
                return;
                
            cmdLine.ace.setTheme(activeTheme);
            
            var htmlNode = cmdLine.ace.container.parentNode;
            var style = htmlNode.style;
            style.background = activeTheme.bg;
            
            activeTheme.isDark
                ? ui.setStyleClass(htmlNode, "dark")
                : ui.setStyleClass(htmlNode, "", ["dark"]);
        }
        
        function show() {
            draw();
            layout.setFindArea(cmdLine, { isDefault: true });
        }
        
        function hide() {
            if (cmdLine) {
                layout.setFindArea(null, { isDefault: true });
            }
        }
        
        function toggle(force, a, b, callback) {
            if (force == -1)
                hide();
            else
                show();
                
            callback && callback();
        }
        
        /***** Methods *****/
        
        var cliCmds = {};
        
        cliCmds.ascii = {
            name: "ascii",
            description: "",
            exec: function(editor) {
                var onSelectionChange = lang.delayedCall(function(e) {
                    var c = editor.getCursorPosition();
                    var ch = editor.session.getLine(c.row)[c.column - 1] || "\n";
                    var code = ch.charCodeAt(0);
                    var msg = JSON.stringify(ch).slice(1, -1) + "=" + " ";
                    var str = code.toString(16);
                    str = [, "\\x0", "\\x", "\\u0", "\\u"][str.length] + str;
                    msg += str + " ";
                    msg += "\\" + code.toString(8) + " ";
                    msg += "&#" + code + ";";
                    editor.cmdLine.setMessage(msg);
                    clear.delay(2000);
                });
        
                var clear = lang.delayedCall(function(e) {
                    editor.removeListener(editor.asciiMessageListener);
                    editor.asciiMessageListener = null;
                    editor.cmdLine.setMessage("");
                });
        
                if (editor.asciiMessageListener) {
                    return clear.call();
                }
                editor.on("changeSelection", editor.asciiMessageListener = function() {
                    onSelectionChange.schedule(200);
                });
                onSelectionChange.call();
            }
        };
        
        cliCmds.set = {
            name: "set",
            description: "set editor option",
            exec: function(editor, args) {
                var cmd = args.text.split(" ");
                var optName = cmd[1];
                var optValue = parseOption(cmd[2]);
                editor.setOption(optName, optValue);
            },
            getCompletions: function() {
                return Object.keys(Editor.prototype.$options);
            }
        };
        
        function parseOption(optValue) {
            if (/^\d+$/.test(optValue))
                optValue = parseInt(optValue, 10);
            if (/^[\d.\^e]+$/.test(optValue))
                optValue = parseFloat(optValue);
            else if (/^(true|false)$/i.test(optValue))
                optValue = optValue.length = 4;
            return optValue;
        }
        
        cliCmds["/"] = {
            name: "/",
            history: [],
            cliExec: function(ed, data) { }
        };
        
        cliCmds["?"] = {
            name: "?",
            history: cliCmds["/"].history,
            cliExec: cliCmds["/"].cliExec
        };
        
        cliCmds[":"] = {
            name: ":",
            history: [],
            getCompletions: function() {
                return Object.keys(this.commands).concat(Object.keys(commands.commands));
            }
        };
        
        cliCmds[':'].reCommands = {
            /**
             * @see {@link http://vim.wikia.com/wiki/Search_and_replace|Vim wiki - sed}
             */
            'sed': {
                regex: /^(%|'<,'>|(?:\d+|\.),(?:\+?\d+|\$|\.))?s(\/|#)(.*?)\2(.*?)\2([giIc]*)$/,
                action: function (editor, cmd, data) {
                    Vim.handleEx(editor.state.cm, cmd);
                }
            }
        };
        
        cliCmds[":"].commands = {
            w: function(editor, data, callback) {
                var tab = tabManager.focussedTab;
                if (!tab || !tab.path)
                    return;
                var lines = editor.session.getLength();
                if (data.argv.length === 2 && data.argv[1]) {
                    var path = pathLib.join(pathLib.dirname(tab.path), data.argv[1]);
        
                    save.save(tab, { path: path }, function(err) {
                        if (!err)
                            editor.cmdLine.setTimedMessage(path + " [New] " + lines + "L, ##C written to ");
                        callback && callback();
                    });
                }
                else {
                    save.save(tab, {}, function(err) {
                        if (!err)
                            editor.cmdLine.setTimedMessage(tab.path + " " + lines + "L, ##C written");
                        callback && callback();
                    });
                }
            },
            e: function(editor, data) {
                var path = data.argv[1];
                if (!path) {
                    navigate.show();
                    return false;
                }
                else {
                    var currentPath = tabManager.focussedTab && tabManager.focussedTab.path || "/";
                    path = pathLib.join(pathLib.dirname(currentPath), data.argv[1]);
                    fs.exists(path, function(exists) {
                        if (exists) {
                            tabManager.openFile(path, { focus: true }, function() {});
                        }
                        else {
                            tabManager.open({
                                path: path,
                                focus: true,
                                document: {
                                    meta: {
                                        newfile: true,
                                        cli: true
                                    }
                                }
                            });
                        }
                    });
                }
            },
            x: function(editor, data) {
                var page = tabManager.focussedTab;
                if (!page)
                    return;
                    
                if (page.document.changed) {
                    cliCmds[":"].commands.wq(editor, data);
                    return;
                }
                else {
                    cliCmds[":"].commands.q();
                }
            },
            wq: function(editor, data) {
                cliCmds[":"].commands.w(editor, data, function() {
                    cliCmds[":"].commands.q();
                });
            },
            wa: function(editor, data) {
                commands.exec("saveall");
            },
            q: function(editor, data) {
                var page = tabManager.focussedTab;
                if (!page) return;
                
                if (data && data.force)
                    page.document.undoManager.bookmark();
                
                page.close();
            },
            "q!": function() {
                cliCmds[":"].commands.q(null, { force: true });
            },
            tabn: "gototabright",
            tabp: "gototableft",
            tabfirst: function() {
                tabbehavior.cycleTab("first", { editorType: "ace" });
            },
            tablast: function() {
                tabbehavior.cycleTab("last", { editorType: "ace" });
            },
            tabnew: function(editor, data) {
                var path = data.argv[1];
                if (!path) {
                    tabManager.open({
                        path: "",
                        document: {
                            meta: {
                                newfile: true
                            }
                        },
                        focus: true
                    });
                }
                else {
                   cliCmds[":"].commands.e(editor, data); 
                }
            },
            tabclose: "closetab",
            tabmove: function(editor, data) {
                // todo
            },
            ascii: cliCmds.ascii,
            sort: function(editor, data) {
                commands.exec("sortlines");
            },
        };
        
        // aliases
        cliCmds[":"].commands["tab drop"] = cliCmds[":"].commands.e;
        cliCmds[":"].commands.write = cliCmds[":"].commands.w;
        cliCmds[":"].commands.tabNext = cliCmds[":"].commands.tabn;
        cliCmds[":"].commands.tabPrevious = cliCmds[":"].commands.tabp;
        cliCmds[":"].commands.tabc = cliCmds[":"].commands.tabclose;
        
        cliCmds[":"].commands.set = {
            vimOpts: [
                "cursorline", "cul", "nocursorline", "nocul", //, "highlightActiveLine",
                "expandtab", "et", "noexpandtab", "noet", //"useSoftTabs",
                "number", "nu", "nonumber", "nonu" // "showGutter"
                // ["relativenumber", "rnu", "norelativenumber", "nornu"]
                // 'softtabstop' 'sts' number
                // 'tabstop' 'ts' number
            ],
            exec: function(ed, args) {
                var optName = args.argv[1];
                var optval = optName.slice(0, 2) != "no";
                if (optName[optName.length - 1] == "!") {
                    var toggle = true;
                    optName = optName.slice(0, -1);
                }
                var i = this.vimOpts.indexOf(optName);
                if (i == -1) {
                    ed.cmdLine.setTimedMessage("Unrecognised option '" + optName + "'.", 1500);
                    return;
                } else if (i < 4) {
                    optName = "highlightActiveLine";
                } else if (i < 8) {
                    optName = "useSoftTabs";
                } else if (i < 12) {
                    optName = "showGutter";
                }        
                if (toggle) 
                    optval = !ed.getOption(optName);
                ed.setOption(optName, optval);
            },
            getCompletions: function(e) {
                return this.vimOpts; //.concat(Object.keys(Editor.prototype.$options));
            }
        };
        
        cliCmds[":"].commands.syntax = commands.commands.syntax;
        
        cliCmds[":"].cliExec = function(ed, cmd, tokens) {
            var last = tokens[tokens.length - 1];
            if (last && last.type == "invisible")
                cmd += last.value;
            cmd = cmd.substr(1).trim();
            var args = cmd.split(/\s+/);
            var firstCmd = args[0];
        
            if (this.commands[firstCmd]) {
                cmd = this.commands[firstCmd];
                if (typeof cmd == "string")
                    return commands.exec(cmd, null, { argv: args });
                else if (typeof cmd == "function")
                    return cmd(ed, { argv: args });
                else if (cmd.exec)
                    return cmd.exec(ed, { argv: args });
            }
            else if (commands.commands[firstCmd]) {
                commands.exec(firstCmd, null, { argv: args });
            }
            else if (/^[+\-\d,]+$/.test(cmd)) {
                Vim.handleEx(ed.state.cm, cmd);
            }
            else {
                for (var key in this.reCommands) {
                    var reCmd = this.reCommands[key];
                    var match = reCmd.regex.exec(cmd);
                    if (match) {
                        return reCmd.action(ed, cmd, {
                            match: match,
                            argv: cmd.split(match[0], 1).slice(-1)[0].split(/\s+/)
                        });
                    }
                }
                
                ed.cmdLine.setTimedMessage(
                    'Vim command "' + cmd + '" not implemented.', 3500);
            }
        };
        
        var allCommands;
        function getCompletions(command) {
            if (command) {
                if (command.getCompletions)
                    return command.getCompletions() || [];
                if (command.commands)
                    return Object.keys(command.commands);
                return [];
            }
        
            if (!allCommands) {
                allCommands = Object.keys(commands.commands)
                    .concat(Object.keys(cliCmds));
            }
            return allCommands;
        }
        
        function getCommand(name, root) {
            if (root && root.commands && root.commands[name])
                return root.commands[name];
            if (root)
                return root;
            return cliCmds[name] || commands.commands[name];
        }
        
        function getActiveEditor() {
            var tab = tabManager.focussedTab;
            if (tab && tab.editorType == "ace")
                return tab.editor.ace;
        }
        
        function processCommandParts(ed, tokens, text) {
            for (var i = 0; i < tokens.length; i++) {
                var tok = tokens[i];
                var cmd = tok.command;
                if (!cmd)
                    continue;
                    
                if (cmd.name !== tok.value) {
                    var next = tokens[i + 1];
                    if (!next || next.type !== "invisible")
                        continue;
                }
                
                if (cmd.cliExec)
                    return cmd.cliExec(ed, text, tokens);
                else if (cmd.exec)
                    return cmd.exec(ed, {
                        argv: text.split(/\s+/), 
                        text: text, 
                        tokens: tokens
                    });
            }
        }
        
        function endCommandInput(cmdLine) {
            cmdLine.addToHistory();
            cmdLine.setValue("");
            var editor = getActiveEditor();
            if (editor) editor.textInput.focus();
        }
        
        function initCmdLine(cmdLine) {
            cmdLine.commands.addCommands([{
                bindKey: "Shift-Return|Ctrl-Return|Alt-Return",
                name: "insertNewLine",
                exec: function(cmdLine) { 
                    cmdLine.insert("\n"); 
                },
            }, {
                bindKey: "Esc|Shift-Esc|Ctrl-[",
                name: "cancel",
                exec: function(cmdLine) {
                    endCommandInput(cmdLine);
                }
            }, {
                bindKey: "Return",
                name: "run",
                exec: function run(cmdLine) {
                    var editor = cmdLine.editor || getActiveEditor();
                    var tokens = cmdLine.session.getTokens(0);
                    if (editor) editor.cmdLine = cmdLine;
                    processCommandParts(editor, tokens, cmdLine.getValue());
                    endCommandInput(cmdLine);
                },
            }, {
                bindKey: "Tab",
                name: "tabNext",
                exec: function tabNext(ed) { tabCycle(ed, 1); },
            }, {
                bindKey: "Shift-Tab",
                name: "tabPrevious",
                exec: function tabPrevious(ed) { tabCycle(ed, -1); },
            }, {
                bindKey: "Right",
                name: "arrowCompleteRight",
                exec: function arrowCompleteRight(ed) {
                    var session = ed.session;
                    var col = ed.selection.isEmpty() ? ed.selection.lead.column : -1;
                    ed.navigateRight();
                    var tok = session.getTokenAt(0, col + 1);
                    if (col == ed.selection.lead.column && tok && tok.type == "invisible")
                        session.doc.insertInLine({ row: 0, column: col }, tok.value);
                },
            }, {
                bindKey: "Up",
                name: "Up",
                exec: function(cmdLine) {cmdLine.navigateHistory(-1);},
            }, {
                bindKey: "Down",
                name: "Down",
                exec: function(cmdLine) {cmdLine.navigateHistory(1);},
            }, {
                bindKey: "Ctrl-Home|PageUp",
                name: "firstInHistory",
                exec: function(cmdLine) {cmdLine.navigateHistory(0);},
            }, {
                bindKey: "Ctrl-End|PageDown",
                name: "lastInHistory",
                exec: function(cmdLine) {cmdLine.navigateHistory();}
            }]);
        
            function tabCycle(ed, dir) {
                var session = ed.session;
                var range = ed.getSelectionRange();
                var line = session.getLine(0);
                var len = line.length;
                
                if (range.end.column != len || !range.isEmpty()) {
                    ed.navigateLineEnd();
                    return;
                }
        
                if (!ed.$tabCycle) {
                    var tok = session.getTokenAt(0, len) || { value: "", type: "" };
                    var matches = session.getState(0);
        
                    if (matches == "start")
                        matches = getCompletions();
                    if (!matches)
                        return;
        
                    if (matches.length == 1 && tok.value == matches[0]) {
                        if (tok.command) {
                            matches = getCompletions(tok.command);
                            tok = { value: "", type: "" };
                        }
                        if (!matches)
                            return;
                    }
        
                    ed.$tabCycle = {
                        matches: matches,
                        index: tok.value == matches[0] ? 0 : -1,
                        start: len - tok.value.length
                    };
                    ed.commands.on("exec", function onExec(e) {
                        var name = e.command && e.command.name;
                        if (name !== "tabNext" && name !== "tabPrevious") {
                            ed.$tabCycle = null;
                            ed.commands.removeListener("exec", onExec);
                        }
                    });
                }
        
                var matches = ed.$tabCycle.matches;
                var index = ed.$tabCycle.index;
                var start = ed.$tabCycle.start;
        
                index += dir;
                index %= matches.length;
                if (index < 0)
                    index = matches.length + index;
                ed.$tabCycle.index = index;
        
                var match = matches[index];
                if (!match)
                    return;
        
                var i = 0;
                while (match[i] && match[i] == line[start + i])
                    i++;
                start += i;
                match = match.substr(i);
        
                if (i === 0 && (/\w/.test(match[0]) && /\w/.test(line[start - 1])))
                    match = " " + match;
                if (/\w$/.test(match))
                    match += " ";
        
                range.start.column = start;
                range.end.column = len;
                session.replace(range, match);
        
                if (ed.$tabCycle.matches.length == 1)
                    ed.$tabCycle = null;
            }
        
            cmdLine.history = [];
            cmdLine.navigateHistory = function(dir) {
                var cliCmd = this.getCurrentCommandWithHistory() || {};
                var history = cliCmd.history || this.history;
                var index = history.index;
                var cmd = history[index] || "";
        
                if (dir === 0) {
                    index = 0;
                } else if (dir === null) {
                    index = history.length;
                } else if (typeof dir == "number") {
                    index += dir;
                    if (index < 0)
                        index = 0;
                    if (index > history.length)
                        index = history.length;
                }
        
                cmd = history[index] || "";
                if (cliCmd.history && cliCmd.name)
                    cmd = cliCmd.name + cmd;
                // TODO keep history.lastTyped
                this.setValue(cmd, 1);
                history.index = index;
            };
        
            cmdLine.addToHistory = function(val) {
                var cliCmd = this.getCurrentCommandWithHistory() || {};
                var history = cliCmd.history || this.history;
                val = val || this.getValue();
                if (cliCmd.name && cliCmd.history)
                    val = val.substr(cliCmd.name.length);
        
                if (val && val != history[history.index]) {
                    history.push(val);
                    history.index = history.length;
                }
            };
        
            cmdLine.getCurrentCommand = function() {
                var tokens = this.session.getTokens(0);
                var tok = tokens[tokens.length - 1];
                return tok && tok.command;
            };
        
            cmdLine.getCurrentCommandWithHistory = function() {
                var tokens = this.session.getTokens(0);
                for (var i = tokens.length; i--;) {
                    var tok = tokens[i];
                    if (tok && tok.command && tok.command.history)
                        return tok.command;
                }
            };
        
            cmdLine.on("blur", function() {
                cmdLine.renderer.$cursorLayer.element.style.opacity = 0;
                if (!cmdLine.getValue()) {
                    cmdLine.renderer.content.style.visibility = "hidden";
                    cmdLine.$messageNode.style.display = "";
                    cmdLine.$inMessageMode = true;
                    cmdLine.$messageNode.textContent = cmdLine.$message || "";
                }
            });
        
            cmdLine.on("focus", function() {
                cmdLine.renderer.$cursorLayer.element.style.opacity = "";
                cmdLine.renderer.content.style.visibility = "";
                cmdLine.$messageNode.style.display = "none";
                cmdLine.$inMessageMode = false;
            });
        
            cmdLine.commands.on("exec", function(e) {
                if (!e.command)
                    return;
                if (e.command.name == "insertstring") {
        
                }
                cmdLine.commands.lastCommandName = e.command.name;
            });
        
            cmdLine.session.bgTokenizer.$tokenizeRow = function(row) {
                var line = this.doc.getLine(row);
                var command = null;
                var tokens = [];
                function add(type, value) {
                    tokens.push({ type: type, value: value, command: command });
                }
        
                while (line.length) {
                    var names = getCompletions(command);
                    var matches = matchCommand(line, names);
        
                    if (!matches.length) {
                        add("text", line);
                        break;
                    }
                    var cur = matches[0];
                    command = getCommand(cur, command);
                    if (cur.length >= line.length) {
                        add("keyword", line);
                        add("invisible", cur.substring(line.length));
                    } else {
                        add("keyword", cur);
                    }
                    line = line.substr(cur.length);
                    var i = line.search(/\S|$/);
                    if (i > 0) {
                        add("text", line.substring(0, i));
                        line = line.substr(i);
                        if (!line.length)
                            matches = getCompletions(command);
                    }
                }
        
                this.lines[row] = tokens;
                this.states[row] = matches;
                return tokens;
            };
        
            function matchCommand(line, names) {
                var matches = [];
                names.forEach(function(name) {
                    if (name.length < line.length) {
                        var isMatch = line.lastIndexOf(name, 0) === 0;
                        if (isMatch && /\w/.test(name[name.length - 1]))
                            isMatch = !/\w/.test(line[name.length]);
                    } else {
                        var isMatch = name.lastIndexOf(line, 0) === 0;
                    }
                    if (isMatch)
                        matches.push(name);
                });
                return matches;
            }
        
            cmdLine.$messageNode = document.createElement("div");
            cmdLine.$messageNode.style.cssText = "position:absolute;"
                + "opacity:0.8;padding:0 5px;top:0;font-size:11px";
            cmdLine.container.appendChild(cmdLine.$messageNode);
            
            cmdLine.$clearMessageDelayed = lang.delayedCall(function() {
                cmdLine.setMessage("");
            });
            cmdLine.setTimedMessage = function(text, timeout) {
                this.setMessage(text);
                this.once("setMessage", function() {
                    cmdLine.$clearMessageDelayed.cancel();
                });
                cmdLine.$clearMessageDelayed.schedule(timeout || 2000);
            };
        
            cmdLine.setMessage = function(text, from) {
                this._signal("setMessage", text);
                this.$message = text;
                if (this.$inMessageMode)
                    this.$messageNode.textContent = text;
            };
        
            if (!cmdLine.isFocused())
                cmdLine._emit("blur");
        
            cmdLine.commands.removeCommands(
                ["find", "gotoline", "findall", "replace", "replaceall"]);
        }
        
        /***** Lifecycle *****/
        
        plugin.on("load", function() {
            load();
        });
        plugin.on("enable", function() {
            
        });
        plugin.on("disable", function() {
            
        });
        plugin.on("unload", function() {
            loaded = false;
        });
        
        /***** Register and define API *****/
        
        /**
         * 
         **/
        plugin.freezePublicAPI({
            /**
             * @ignore
             */
            searchStore: searchStore,
            
            /**
             * 
             */
            get aml() { return cmdLine; },
            
            /**
             * 
             */
            get ace() { return cmdLine.ace; }, 
            
            /**
             * 
             */
            show: show,
            
            /**
             * 
             */
            hide: hide,
            
            /**
             * 
             */
            toggle: toggle
        });
        
        register(null, {
            "vim.cli": plugin
        });
    }
});