/**
 * Handler for a Prolog assignment. Works with the corresponding prolog.html content.
 */

(function () {
    /**
     * Creates a new handler for the given Prolog assignment definition.
     *
     * @param {PrologTaskDef} info
     * @returns {{destroy: Function, processServerHints: Function}}
     */
    codeq.createPrologHandler = function (info) {
        var jqDescription = $('#description'),
            jqEditor = $('#code_editor'),
            jqConsole = $('#console'),
            jqHints = $('#info'),
            editor = CodeMirror(jqEditor[0], { cursorHeight: 0.85, lineNumbers: true, matchBrackets: true }),
            controller = jqConsole.console({
                promptLabel: '?- ',
                commandValidate: function (line) {
                    return !!line;
                },
                commandHandle: function (line) {
                    return [{msg:'Not implemented.', className:'console-response'}];
                },
                autofocus: false,
                animateScroll: false,
                promptHistory: false,
                welcomeMessage: 'Prolog REPL.'
            }),
            /** Object.<string, HintDefinition> */ hintDefs = info.hint,
            hintCounter = 0, // for generating unique class-names
            hintCleaners = [],
            clearHints = function () {
                var i;
                for (i = hintCleaners.length - 1; i >= 0; i--) {
                    hintCleaners[i]();
                }
                hintCleaners.length = 0;
                hintCounter = 0;
            },
            addMark = function (start, end) {
                var posStart = editor.posFromIndex(start),
                    posEnd = editor.posFromIndex(end),
                    doc = editor.getDoc(),
                    mark = doc.markText(posStart, posEnd, {className: 'editor-mark _emark_' + hintCounter}),
                    result = {start: posStart, end: posEnd, mark: mark, className: '_emark_' + hintCounter};
                hintCleaners.push(function () { mark.clear(); mark = null; doc = null; result.mark = null; });
                hintCounter++;
                return result;
            },
            hintHandlers = {
                'static': function (type, template, serverHint) {
                    codeq.log.debug('Processing static hint');
                    jqHints.append(template); // TODO: incorporate any serverHint.args
                    // no hint cleaner here, a static hint remains on the screen
                },
                'popup': function (type, template, serverHint) {
                    codeq.log.debug('Processing popup hint');
                    var mark = addMark(serverHint.start, serverHint.end), // add the mark
                        jqMark = jqEditor.find('.' + mark.className),
                        jqPopup = null,
                        onBlur = function () {
                            codeq.log.debug('Removing popup');
                            if (jqPopup) {
                                jqPopup.off('blur', onBlur);
                                jqPopup.remove();
                                jqPopup = null;
                            }
                        };

                    window.jqMark = jqMark; // TODO: DEBUG

                    jqMark.on('click', function () {
                        if (jqPopup) return;
                        codeq.log.debug('Showing popup');
                        var pos = mark.mark.find(), // results in {from: {line: number, ch: number}, to: {line: number, ch: number}}
                            left = pos.from.ch < pos.to.ch ? pos.from.ch : pos.to.ch,
                            down = pos.from.line < pos.to.line ? pos.to.line : pos.from.line;
                        jqPopup = $('<div style="position: absolute;" class="editor-popup ' + mark.className + '"></div>').html(template);
                        editor.addWidget({line: down, ch: left}, jqPopup[0], true);
                        jqPopup = jqEditor.find('.editor-popup.' + mark.className);
                        setTimeout(function () {jqPopup.trigger('focus'); jqPopup.on('click', onBlur);}, 50); // event handlers can be registered only when the DOM elements is part of the document
                        window.jqPopup = jqPopup; // TODO: DEBUG
                    });

                    hintCleaners.push(function () {
                        if (jqPopup) {
                            jqPopup.off('blur', onBlur);
                            jqPopup.remove();
                            jqPopup = null;
                        }
                        if (jqMark) {
                            jqMark = null;
                        }
                        mark = null;
                    });
                },
                'dropdown': function (type, template, serverHint) {
                    codeq.log.debug('Processing dropdown hint');
                    var completion = null, // the completion object, created in showHint()
                        close = function () {
                            if (completion) {
                                completion.close();
                                completion = null;
                            }
                        };

                    if ((editor.listSelections().length > 1) || editor.somethingSelected()) {
                        // showHint() doesn't work if a selection is active
                    }

                    editor.showHint({
                        hint: function () {
                            var hints = {
                                list: serverHint.choices,
                                from: editor.posFromIndex(serverHint.start),
                                to: editor.posFromIndex(serverHint.end)
                            };
                            completion = editor.state.completionActive;
                            return hints;
                        },
                        completeOnSingleClick: true,
                        completeSingle: false
                    });

                    hintCleaners.push(close);
                }
            };

        editor.setValue('sister(X, Y) :-\n    female(X),\n    parent(Z, X),\n    parent(Z, Y),\n    X \\== Y.'); // demo
        jqDescription.html(info.description);

        return {
            destroy: function () {
                jqDescription.empty();
                jqEditor.empty(); // TODO: perhaps you do not want to "free" the editor, just empty it
                jqConsole.empty(); // TODO: the same with the console
                jqHints.empty(); // TODO: just make static references to these
                jqDescription = null;
                jqEditor = null;
                jqConsole = null;
                jqHints = null;
            },

            /**
             * Processes and display appropriately the server hints.
             * TODO: sort hints so static and popup hints come first, and a (single) drop-down hint last
             *
             * @param {ServerHint[]} serverHints an array of hints from the server
             */
            processServerHints: function (serverHints) {
                var n = serverHints.length,
                    /** number */ i,
                    /** ServerHint */ serverHint,
                    /** HintDefinition */ hintDef,
                    hintType, hintTemplate, t, fn;
                clearHints();
                for (i = 0; i < n; i++) {
                    serverHint = serverHints[i];
                    hintDef = hintDefs[serverHint.id];
                    if (!hintDef) {
                        codeq.log.error('Undefined hint: ' + serverHint.id);
                        continue;
                    }
                    t = typeof hintDef;
                    if (t === 'object') {
                        hintType = hintDef.type;
                        hintTemplate = hintDef.message;
                    }
                    else if (t === 'string') {
                        hintType = 'static';
                        hintTemplate = hintDef;
                    }
                    else {
                        codeq.log.error('Unsupported hint definition: ' + t);
                        continue;
                    }

                    fn = hintHandlers[hintType];
                    if (!fn) codeq.log.error('Unsupported hint type: ' + hintType);
                    else fn(hintType, hintTemplate, serverHint);
                }
            }
        };
    };
})();