var worker = new Worker("/applications/dictionary/spellchecker/js/correctionWorker.js");

var textElements = new Array();
var errorsNumber = 1;
var isWorkingOnCorrection = false;
var isAlreadyAdviceToPerformCorrection = true;

var pos = 0;
var indexOfElements = 0;
var isInterruptCorrection = false;

// The master Array
var checkedElements = new Array(0);
var currentElement = 0;
// inizializzato a -1 perché incrementato prima di usarlo
var currentEvent = -1;
// The skip Array
var skipArray = new Array(0);
// The processed Objects Associative Array
var changeWords = new Array(0);

// elemento da scorrere nel dom per andare a prendere gli oggetti dell'editor
var elementToIncrement = 0;
var menuVisualize = false;


$(document).ready(function () {
    loadAllForms();
});

/******************************************************************************************************************************************************************************************
 *
 * FUNZIONE DI ANALISI DEL TESTO
 *  Correzione del paragrafo e caricamento delle parole nei menù contestuali per la scelta utente TRAMITE ACCESSO AL DB
 *
 ******************************************************************************************************************************************************************************************/
function loadAllForms() {
    
    var langId = $('#LANGUAGE').val();
    var noExc = (!langId && !sessionStorage.getItem('__sc_cort_formary_exception')) ||         // lingua singola CROS
        (langId && !sessionStorage.getItem('__sc_cort_formary_exception_' + langId));   // lingue plurime LADINS
    var noLocStorage = localStorage && !localStorage.getItem('__sc_cort_formary_');
    var noSexStorage = sessionStorage && !sessionStorage.getItem('__sc_cort_formary_');
    var loadFormary = noExc && noLocStorage && noSexStorage;


    if (loadFormary && false) {
        var existStorage = (!isChrome && localStorage != undefined) || (isChrome && sessionStorage != undefined);

        // to-do? passare anche valore del background?
        //var background = $('#BACKGROUND').val();
        var params = new Object();
        params.IDLANG = langId;
        var url = contextPath + "/applications/dictionary/spellchecker/ajax/ajaxCorrectWordsLoader.jsp?IDLANG=3";

        $.getJSON(url, params, function (formary) {


            /*if(existStorage) {
             try {
             localStorage.setItem('

            __sc_cort_formary_', JSON.stringify(formary));
             sessionStorage.removeItem('

            __sc_cort_formary_exception');

             } catch(exc) {
             if(sessionStorage) {
             try {
             sessionStorage.setItem('

            __sc_cort_formary_', JSON.stringify(formary));
             sessionStorage.removeItem('

            __sc_cort_formary_exception');

             } catch(cexc){
             sessionStorage.setItem('

            __sc_cort_formary_exception', 'yes');
             sessionStorage.setItem('

            __sc_cort_formary_exception_'+ langId, 'yes');
             //$('#browserMessage_2').html(cexc + '<br/><br/>');
             console.log(exc);
             console.log(cexc);
             $('#browserMessage_2').html('

            <img src="/applications/dictionary/images/warning.gif" height="16"  border="0"  name="d1442078384" style="padding-right:4px"  id="d1442078384" >Non è stato possibile caricare il dizionario nel tuo browser. La correzione sarà più lenta.<br/><br/>');
             }
             }
             }
             }*/
            _init();
        });

    } else
        _init();
}

/******************************************************************************************************************************************************************************************
 *
 * FUNZIONE DI COSTRUZIONE DELL'EDITOR
 *
 ******************************************************************************************************************************************************************************************/
function _init() {
    buildTextArea();

    $('#areaText').wysiwyg({
        autoGrow: true, 
        /* maxHeight: 1000, initialContent: "", */
        maxLength: 23000,
        controls: {
            bold: {visible: true},
            italic: {visible: true},
            underline: {visible: true},
            strikeThrough: {visible: true},
            justifyLeft: {visible: true},
            justifyCenter: {visible: true},
            justifyRight: {visible: true},
            justifyFull: {visible: true},
            indent: {visible: true},
            outdent: {visible: true},
            subscript: {visible: true},
            superscript: {visible: true},
            undo: {visible: true},
            redo: {visible: true},
            cut: {visible: true},
            copy: {visible: true},
            paste: {visible: true},
            html: {visible: true},
            increaseFontSize: {visible: true},
            decreaseFontSize: {visible: true},
            insertOrderedList: {visible: true},
            insertUnorderedList: {visible: true},
            insertHorizontalRule: {visible: true},
            // hidden buttons
            code: {visible: false},
            insertImage: {visible: false},
            removeFormat: {visible: false}
        },

        events: {
            click: function (event) {
                if ($(event.target).is('a')) {
                    window.open($(event.target).attr('href'));
                } else if ($($(event.target).parents()[0]).is('a')) {
                    if (event.button == '0')
                        window.open($(event.target).closest('a').attr('href'));
                    else if (event.button == '2')
                        $(event.target).trigger('rightClick');
                }


                if (isWorkingOnCorrection) {
                    event.preventDefault();
                    alert("Correzione ancora in corso");
                }

                if (!isWorkingOnCorrection && !isAlreadyAdviceToPerformCorrection) {
                    event.preventDefault();
                    isAlreadyAdviceToPerformCorrection = true;
                    
                }

                // ripulitura del testo di invito alla scrittura
                var $textArea = $('#areaText');
                var content = $textArea.wysiwyg("getContent");
                if ("<p> </p>" == content || " " == content)
                    $textArea.wysiwyg("clear");

                // Se c'è un contextMenù attivo lo nasconde in modo da simulare il click fuori focus per disattivare il menù.
                $('#openXMLContainer').hide();
                $(".cntxtMn").hide();
            },
            keydown: function (event) {
                var $textArea = $('#areaText');
                var document = $textArea.data("wysiwyg").editorDoc;
                var sel = document.getSelection();//
                var range = sel.getRangeAt(0);
                var textnode = range.startContainer;//document.getElementsByTagName("span").item(0);
                var node = range.startContainer.parentNode;//document.getElementsByTagName("span").item(0);
                //var bodyNode = document.getElementsByTagName("body")[0];
                if (node.tagName == "SPAN" && $(node).attr('class') == "hlErr") {
                    //alert('gente, son dentro diehene');
                    var len = textnode.textContent.trim().length;
                    var caret = range.startOffset;
                    if (len == caret && event.keyCode == '32') {
                        range.setStartAfter(node);
                        range.setEndAfter(node);
                        //event.preventDefault();
                    }
                }
            },
            // aggiunto per verificare la lunghezza di un testo eventualmente incollato
            keyup: function (event) {
                var $textArea = $('#areaText');
                var text = $textArea.wysiwyg("getText");

                if (23000 >
                0 && text.length >=
                23000 )
                {
                    text = text.substring(0, 23000);
                    $('#wysiwyg_areaText').contents().find('body').text(text);
                    alert('lunghezza massima superata: 23000');
                }
            },
            mousedown: function (event) {
                //buildMenu($(event.target));
            }
            , mouseover: function (event) {
                if ($(event.target).is('a')) {
                    $(event.target).css('cursor', 'pointer');
                } else if ($($(event.target).parents()[0]).is('a')) {
                    $(event.target).closest('a').css('cursor', 'pointer');
                } else {
                    buildMenu($(event.target));
                }
            }
        }
    });

    // eliminazione contextMenu
    var bodyHtml = $('#wysiwyg_areaText').contents().find('body');
    // distruggo i context menù associati agli span
    bodyHtml.destroyContextMenu();
    // distruggo il context menù del sistema operativo
    bodyHtml.bind('contextmenu', function () {
        return false;
    });

    // funzione per scrollare insieme alla pagina un elemento, che nel nostro caso è un div
    $(".scrollableEl").jScroll();

    //gestione hover sui buttons
    $('.buttonHtml').hover(function () {
        $(this).toggleClass('buttonHtml-hover');
    });

    if (isOpera)
        $('#browserMessage_1').html('Per una migliore esperienza d\'uso, potrebbe essere necessario disabilitare il \"Controllo ortografico\" del browser.<br>(strumenti/preferenze/avanzate/controllo ortografico)<br/><br/>');
}

function buildMenu($node) {
    if ($node.is("span")) {
        var spanId = $node.attr('id').replace('word_', '');

        var invalidWord = $node.text();
        var isForced = $node.attr('data-type-isForced');
        var isCorrect = $node.attr('data-type-isCorrect');
        var iframeContents = $("#areaText").prev().find("iframe").contents();

        var errorLevel = $node.attr('data-type-errorLevel');
        var contextErrorLevel = $node.attr('data-type-contexterrorLevel');
        var segmentsErrorLevel = $node.attr('data-type-segmentserrorLevel');

        var suggestions = $node.attr('data-type-suggestionsLoaded');

        var isStartSentencedWord = $node.attr('data-type-isstartsentenceword');

        if ($('#crtMn_' + spanId).length == 0)
            createContextMenuForErrors(spanId, suggestions, invalidWord, isForced, errorLevel, contextErrorLevel, segmentsErrorLevel, false, isCorrect, isStartSentencedWord, iframeContents);
    }
}

function buildTextArea() {
    setTimeout(function () {
        $('iframe').contents().find('body').css('padding', '3px 5px');
    }, 0);
    var $textArea = $('<textarea>');
    $textArea.attr('id', 'areaText');
    $textArea.attr('name', 'areaText');
    $textArea.attr('rows', '20');
    $textArea.attr('oncontextmenu', 'return false;');
    $textArea.attr('spellcheck', 'false;');
    /*$textArea.val('

     ');*/
    $textArea.val(' ');
    $('#workSpace').html($textArea);
}

/******************************************************************************************************************************************************************************************
 *
 * FUNZIONE DI ANALISI DEL TESTO
 *
 ******************************************************************************************************************************************************************************************/

function spellCheckText() {
    if (textElements != null && textElements.length > 0) {
        loadCheckedWordsWithContextMenu();
    }
}

function resetSpellCheck() {
    removeLoader();
    menuVisualize = false;
    isWorkingOnCorrection = false;
    isInterruptCorrection = false;
    textElements = new Array();
    errorsNumber = 1;
    checkedElements = new Array(0);
    currentElement = 0;
    // inizializzato a -1 perché incrementato prima di usarlo
    currentEvent = -1;

    // The skip Array
    skipArray = new Array(0);

    // The processed Objects Associative Array
    changeWords = new Array(0);

    // elemento da scorrere nel dom per andare a prendere gli oggetti dell'editor
    elementToIncrement = 0;
}

function spellCheckTextOld() {
    // Controllo se ci sono i paragrafi presi dal testo
    if (textElements != null && textElements.length > 0) {
        // Visualizza il loader sotto la pulsantiera
        visualizeLoader();

        var totalTextElements = textElements.length;
        // Richiama su tutti i paragrafi la correzione via ajax in modo asincrono
        $.eachAsync(textElements, {
            // la gestione con i valori di default stabiliti dal plugin velocizza enormemente i tempi di elaborazione
//      delay: 500, // baddi mise 1500
//      bulk: 0,

            loop: function (index, elements) {
                if (isInterruptCorrection)
                    return false;

                // aggiornamento della percentuale di completamento correzione
                var percentage = (Math.round((index * 100) / totalTextElements));
                $('#loadCorrectionPercentage').html(percentage + "%");

                var checkDB = true;
                // ritorna l'oggetto formario (se esiste), null altrimenti
                // fa il check degli errori del paragrafo che gli è stato passato tramite accesso al localStorage
                if (!sessionStorage.getItem('__sc_cort_formary_exception')) {
                    var _sc_formary = localStorage ? localStorage.getItem("__sc_cort_formary_") : null;
                    if (!_sc_formary || _sc_formary == null)
                        _sc_formary = sessionStorage ? sessionStorage.getItem("__sc_cort_formary_") : null;
                    if (_sc_formary) {
                        var parsedFormary = JSON.parse(_sc_formary);
                        checkDB = false;
                        loadCheckedWordsWithContextMenuByLocalStorage(parsedFormary, elements, index);
                    }
                }

                // fa il check degli errori del paragrafo che gli è stato passato tramite accesso al db (vecchio modo)
                if (checkDB) {
                    loadCheckedWordsWithContextMenuOld(index, elements);
                    $('#browserMessage_2').html('<img src="/applications/dictionary/images/warning.gif" height="16"  border="0"  name="d272828406" style="padding-right:4px"  id="d272828406" >Non è stato possibile caricare il dizionario nel tuo browser. La correzione sarà più lenta.<br/><br/>');
                }
            },

            end: function () {
                removeLoader();
                menuVisualize = false;
                isWorkingOnCorrection = false;
                isInterruptCorrection = false;
                textElements = new Array();
                errorsNumber = 1;
                checkedElements = new Array(0);
                currentElement = 0;
                // inizializzato a -1 perché incrementato prima di usarlo
                currentEvent = -1;

                // The skip Array
                skipArray = new Array(0);

                // The processed Objects Associative Array
                changeWords = new Array(0);

                // elemento da scorrere nel dom per andare a prendere gli oggetti dell'editor
                elementToIncrement = 0;
            }
        });
    }
}

/******************************************************************************************************************************************************************************************
 *
 * FUNZIONE PER VERIFICARE CORRETTEZZA PAROLA CON APOSTROFO
 * per non duplicare qui la logica server-side
 * si effettua un accesso al DB richiamando la funzione originaria
 * al momento (sardo) si verificano solo le parole apostrofate
 * inserire qui qualsiasi altra gestione che richieda di passare da uno SpellChecker ad hoc
 *
 ******************************************************************************************************************************************************************************************/
function freaksManager(word, elements, index) {
    if (word.indexOf("'") > -1) {
        var fakedElements = {};
        fakedElements[0] = word;
        fakedElements[1] = elements[1];

        loadCheckedWordsWithContextMenuOld(index, fakedElements);
        return true;

    } else if (isNumber(word)) {
        return true;

    } else if (isIgnoredWord(word)) {
        return true;
    }

    return false;
}

// questa funzione ha un equivalente serverSide in SpellCheckerBase
function isIgnoredWord(word) {
    var ignoreUpperCase = false;
    var ignoreMixedCase = false;
    var ignoreDigits = true;
    //alert(isMixedCaseWord(word, false))
    // se fa parte degli uppercase
    if (ignoreUpperCase && word == word.toUpperCase())
        return true;
    // se parola cammellata
    if (ignoreMixedCase && isMixedCaseWord(word, false))
        return true;
    // se ci sono dei numerici all'interno della parola
    if (ignoreDigits && word.match(".*[0-9].*"))
        return true;
    // NB:: NON è possibile fare il controllo per IGNORE_SENTENCE_CAPITALIZATION poichè si lavora su una singola parola fuori dal contesto e non si dipone di un tokenizer js
    // NB: indirizzi internet ed email sono esclusi senza considerare le costanti
    return false;
}

function isMixedCaseWord(word, startsSentence) {
    var wordLength = word.length;
    var firstChar = word.charAt(0);
    var isUpper = firstChar == firstChar.toUpperCase();
    if ((startsSentence) && isUpper && (wordLength > 1)) {
        var secondChar = word.charAt(1);
        isUpper = secondChar == secondChar.toUpperCase();
    }
    if (isUpper) {
        for (var i = wordLength - 1; i > 0; i--) {
            var charI = word.charAt(i);
            if (charI == charI.toLowerCase())
                return true;
        }
    } else {
        for (var y = wordLength - 1; y > 0; y--) {
            var charY = word.charAt(y);
            if (charY == charY.toUpperCase())
                return true;
        }
    }
    return false;
}

//
function webPatternsCleaner(text) {
    // http://, https://, ftp://
    var urlPattern = /\b(?:https?|ftp):\/\/[a-z0-9-+&@#\/%?=~_|!:,.;]*[a-z0-9-+&@#\/%=~_|]/gim;
    // www. without http:// or https://
    var pseudoUrlPattern = /(^|[^\/])(www\.[\S]+(\b|$))/gim;
    // email addresses
    var emailAddressPattern = /(([a-zA-Z0-9_\-\.]+)@[a-zA-Z_]+?(?:\.[a-zA-Z]{2,6}))+/gim;
    return text.replace(urlPattern, '').replace(pseudoUrlPattern, '').replace(emailAddressPattern, '');
}

/******************************************************************************************************************************************************************************************
 *
 * FUNZIONE DI ANALISI DEL TESTO
 *  Correzione del paragrafo e caricamento delle parole nei menù contestuali per la scelta utente TRAMITE ACCESSO AL DB
 *
 ******************************************************************************************************************************************************************************************/


function retrieveSelectedSoundsLike() {
    var selectedSL = $('#SELECTED_SL').val();
    if (typeof selectedSL === 'undefined')
        selectedSL = $('#buttonCellOneLanguage').attr('value');

    return selectedSL;
}

function loadCheckedWordsWithContextMenu() {
    var document = $('#areaText').data("wysiwyg").editorDoc;
    var text = $(document.body).html();
    var iframeContents = $("#areaText").prev().find("iframe").contents();

    //var regexComments = /
    <!--[\s\S]*?-->
    / /g;
    // codifica msWord
    //var matcher = new RegExp(regexComments);
    //alert(matcher.test(text2));

    var regexParagraph = /<p[\s\S]*?>/g;            // rimuove i <p> e porta tutto in <br>

    var regexEmpty = /&nbsp;/g;            // rimuove i <p> e porta tutto in <br>

    var regexSpan = /<span[\s\S]*?>/g;               // rimuove i <span>
    var regexFont = /<font[\s\S]*?>/g;               // rimuove i <font>
    var regexStyle = /<style[\s\S]*?>/g;               // rimuove i <style>
    var regexComments = /<!--[\s\S]*?>/g;               // rimuove i <!-->
    /*var refexB = /<b[\s\S]*?>/g;         */      // rimuove i <b>

    text = text.replace(regexParagraph, "").replace(/<\/p>/g, "<br><br>");
    //text = text.replace(regexComments, "");

    text = text.replace(regexEmpty, " ");
    text = text.replace(regexSpan, "").replace(/<\/span>/g, "");
    text = text.replace(regexFont, "").replace(/<\/font>/g, "");
    text = text.replace(regexStyle, "").replace(/<\/style>/g, "");
    text = text.replace(regexComments, "").replace(/-->/g, "");
    /*text = text.replace(refexB, "").replace(/<\/b>/g, "");*/

    /*text = text.replace(/<script[^>]*?>.*?<\/script>/gi, '').
     replace(/<[\/\!]*?[^<>]*?>/gi, '').
     replace(/<style[^>]*?>.*?<\/style>/gi, '').
     replace(/<![\s\S]*?--[ \t\n\r]*>/gi, '');*/

    text = text.replace(/<\s*([a-z][a-z0-9]*)\s.*?>/gi, '<$1>');

    text = encodeURI(text.trim());

    //text = text.replace(/%/gi, ' %25 ');
    text = text.replace(/#/gi, '%23');
    text = text.replace(/&/gi, '%26');
    text = text.replace(/</gi, '%3C');
    text = text.replace(/>/gi, '%3E');

    if (!text.endsWith("<br>"))
        text += "<br>";

    /*console.log(text);*/

    if (text != null) {

        if (text.length > 9000) {
            $('#BT_START_CORRECTION').html('<i>correzione in corso...</i>')
            $('#BT_START_CORRECTION').attr('onclick', '');
            /*console.log(document.getElementById("BT_START_CORRECTION"));
             console.log($('#BT_START_CORRECTION'));
             document.getElementById("BT_START_CORRECTION").disabled = true;*/
        }

        var urlSuggestion = "/applications/dictionary/spellchecker/ajax/getSuggestionForParagraph.jsp?SELECTED_SL=" + retrieveSelectedSoundsLike();
        const MAX_SEGMENT_LENGTH = 200;
        var textSegments = [];

        //if(text.length>MAX_SEGMENT_LENGTH) {
        var textSplit = text.split('%20');

        var textToPush = '';
        var newSentenceRequired = false;

        for (var i = 0; i < textSplit.length; i++) {

            textToPush += textSplit[i] + '%20';

            if ((textToPush.length > MAX_SEGMENT_LENGTH) || (i == textSplit.length - 1)) {
                if (i == textSplit.length - 1) {
                    textToPush = textToPush.substring(0, textToPush.length - 3);
                }

                textSegments.push(textToPush);
                textToPush = '';
            }
        }
        //}

        worker.postMessage(urlSuggestion + '&text=' + textSegments[0] + "&lastWordCount=0&newSentenceRequired=yes");

        var textCorrecto = '';
        var segmentCount = 0;

        worker.addEventListener("message", function (e) {
            var els = e.data.element.subElements;

            if (segmentCount < textSegments.length) {
                worker.postMessage(urlSuggestion + '&text=' + textSegments[++segmentCount] + "&lastWordCount=" + e.data.lastWordCount + "&newSentenceRequired=" + e.data.newSentenceRequired);
                textCorrecto += e.data.hltext;

                if (segmentCount == textSegments.length) {
                    $(iframeContents.find("body")).html(textCorrecto);
                    //replaceWithHighlightedText(text, textCorrecto, els, iframeContents/*, idxStart, idxEnd*/);
                    isWorkingOnCorrection = false;
                    $('#BT_START_CORRECTION').html('correggi');
                    $('#BT_START_CORRECTION').attr('onclick', 'startCorrection()');
                }
            }
        });
        // }
    }
}


function replaceWithHighlightedText(oldtext, hltext, subElements, iframeContents/*, idxStart, idxEnd*/) {
    //var text = $('#areaText').wysiwyg("getText");
    //text = text.replace(oldtext, hltext);
    $(iframeContents.find("body")).html(hltext);
}

function loadCheckedWordsWithContextMenuOld(indexOfElements, elements) {
    var text;
    var formElement;
    var absPos;

    if (elements != null) {
        text = elements[0];
        formElement = elements[1];
        absPos = elements[2];
    }

    if (text != null || formElement != null) {
        var urlSuggestion = "/applications/dictionary/spellchecker/ajax/getSuggestionForParagraphOld.jsp";
        /*var worker = new Worker(urlSuggestion);
         worker.postMessage(urlSuggestion); */

        var params = new Object();
        params.text = text;
        params.formElement = formElement;
        params.absPos = absPos;
        params.elementToIncrement = indexOfElements;
        // codice del soundsLike
        params.selectedSoundsLike = retrieveSelectedSoundsLike();
        params.jsonCall = "jsonCall";

        $.ajax({
            type: "POST",
            cache: false,
            url: urlSuggestion,
            dataType: 'json',
            data: params,
            async: false,
            timeout: 30000,

            success: function (jsonRet) {
                if (jsonRet != null && jsonRet.element != null) {
                    var subElements = jsonRet.element.subElements;

                    if (jsonRet.debug)
                        $('#hibContainer').html(jsonRet.debug);

                    if (subElements && subElements.length > 0) {
                        var iframeContents = $("#areaText").prev().find("iframe").contents();
                        for (var x = 0; x < subElements.length; x++) {
                            var subElement = subElements[x];
                            var invalidWord = subElement.invalidWord;
                            var suggestions = subElement.suggestions;
                            var isForcedSuggestion = subElement.isForcedSuggestion;
                            var errorLevel = subElement.errorLevel;
                            var suggestionsLoaded = subElement.suggestionsLoaded;
                            var isCorrect = subElement.isCorrect;

                            if (isCorrect)
                                selecWordAsCorrect(invalidWord, errorsNumber, iframeContents);
                            // SUGGESTION: green underline
                            else if (isForcedSuggestion && errorLevel != null && errorLevel < 2)
                                selecWordAsForcedSuggestion(invalidWord, errorsNumber, iframeContents);
                            // ERROR: red underline
                            else
                                selecWordAsError(invalidWord, errorsNumber, iframeContents);

                            createMenu(suggestions, invalidWord, isForcedSuggestion, errorLevel, suggestionsLoaded, isCorrect);
                        }
                    }
                }
            },

            error: function (xhr, status, error) {
                var err = eval("(" + xhr.responseText + ")");
                alert(err.Message + " status " + status + " error " + error);
            }
        });
    }
}

/******************************************************************************************************************************************************************************************
 *
 * FUNZIONE PER IL CARICAMENTO DEI SUGGERIMENTI
 *
 ******************************************************************************************************************************************************************************************/
function suggestionsLoaderForSingleWord(isCorrect, invalidWord, isForcedSuggestion, errorLevel, contextErrorLevel, segmentsErrorLevel, isStartSentencedWord, spanId, elementToAttachContextMenu) {
    var suggestionsLoaded = false;
    //var suggestionsLoaded = false;

    if (invalidWord && !suggestionsLoaded) {
        var params = new Object();
        params.invalidWord = invalidWord;
        params.isCorrect = isCorrect;
        params.selectedSoundsLike = retrieveSelectedSoundsLike();
        params.isForcedSuggestion = isForcedSuggestion;
        params.errorLevel = errorLevel;
        params.contextErrorLevel = contextErrorLevel;
        params.segmentsErrorLevel = segmentsErrorLevel;
        params.isStartSentenceWord = isStartSentencedWord;

        $.ajax({
            type: "POST",
            async: false,
            data: params,
            url: contextPath + "/applications/dictionary/spellchecker/ajax/getSuggestionForWord.jsp",
            dataType: 'json',
            cache: false,

            success: function (jsonRet) {
                if (jsonRet != null) {
                    var suggestions = jsonRet.suggestions;
                    var suggestionsSubs = jsonRet.suggestionsSubst;
                    var idsArray = jsonRet.idsArray;
                    var suggestionsContainer = $('#suggestionsContainer_' + spanId);
                    var suggestionsErrorLevel = jsonRet.suggestionsErrorLevel;
                    var suggestionsContextErrorLevel = jsonRet.suggestionsContextErrorLevel;
                    var suggestionsSegmentsErrorLevel = jsonRet.suggestionsSegmentsErrorLevel;

                    //var list = $("#crtMn_" + spanId);

                    if (suggestions != null && suggestions.length > 0) {
                        suggestionsContainer.remove();
                        // loop per sostituire le righe fasulle con i suggerimenti
                        // (questo perchè le righe aggiunte dinamicamente non sono inizializzate nella callBackFunction)
                        var index = 0;
                        for (var y = 0; y < suggestions.length; y++) {
                            var suggestion = suggestions[y];

                            index = y + 1;
                            var $li = $('#hdl_' + spanId + "_" + index);

                            var $ahref = $('#hda_' + spanId + "_" + index);
                            $ahref.attr('href', '#' + suggestionsSubs[y]);
                            if (idsArray[y].length > 0)
                                $ahref.attr('data-entryid-type', idsArray[y]);
                            else {
                                $('#hdXml_' + spanId + "_" + index).css('visibility', 'hidden');
                            }

                            $ahref.html(suggestion);

                            //if (!jsonRet.isCorrect || isForcedSuggestion) {
                            var className = document.getElementById('wysiwyg_areaText').contentWindow.document.getElementById('word_' + spanId).classList[0]

                            var txt = textLabelBuilder(suggestionsErrorLevel[y], suggestionsContextErrorLevel[y], suggestionsSegmentsErrorLevel[y]);

                            if ($li.children('small.maybeMean').length > 0) {
                                $li.find('.maybeMean').html(txt);
                            } else if (true || suggestionsErrorLevel[y] == 1) {
                                var $small = $("<small></small>");
                                $small.addClass('maybeMean');
                                $small.attr('style', '');
                                $small.html(txt);
                                $li.prepend($small);
                            }
                            //}


                            $li.show(); // show list tag
                        }

                        if (jsonRet.isCorrect == 'false') {
                            // rimozione righe in eccesso
                            var maxRowNumbers = 20;
                            for (var z = index + 1; z <= maxRowNumbers; z++)
                                $('#hdl_' + spanId + "_" + z).remove();

                            // mostra etichetta "invia suggerimento"
                            $('#sendSugg_' + spanId).show();
                        }
                    } else {
                        suggestionsContainer.html(labelBuilder('<i>Non vi sono suggerimenti</i>', false, 0));
                        // mostra etichetta "invia agli esperti"
                        $('#sendEx_' + spanId).show();
                    }
                }
            }
        });
    }
}

/******************************************************************************************************************************************************************************************
 *
 * FUNZIONE PER LA COSTRUZIONE DEL MENU DEI SUGGERIMENTI
 *
 ******************************************************************************************************************************************************************************************/
function createMenu(suggestions, invalidWord, isForcedSuggestion, errorLevel, suggestionsLoaded, isCorrect, iframeContents) {
    var spanElementForHighligth = getSpanElementForHighligthtByNumber(errorsNumber);
    // se gli elementi trovati sono più di uno allora vuol dire che nel testo ci sono
    // più istanze della stessa parola a cui è stato assegnato lo stesso id allo span
    var isIdDuplication = spanElementForHighligth != null && spanElementForHighligth.length > 1;
    // tengo il primo numero sequenziale degli errori
    var tmpErrorNumber = errorsNumber;
    // siamo nel caso di duplicazione di id dobbiamo riassegnare gli id duplicati partendo dal secondo elemento duplicato trovato nel documento...
    if (isIdDuplication) {
        for (var indexNew = 1; indexNew < spanElementForHighligth.length; indexNew++) {
            errorsNumber++;
            var tmpElement = spanElementForHighligth[indexNew];
            // riassegno l'id all'elemento che lo aveva duplicato
            tmpElement.id = "word_" + errorsNumber;
            // attacco il contextMenù sull'elemento dall'id riassegnato
            createContextMenuForErrors(errorsNumber, suggestions, invalidWord, isForcedSuggestion, errorLevel, suggestionsLoaded, isCorrect, iframeContents);
        }
    }

    //... altrimenti 'attacchiamo' il contextMenu sull'elemento su cui si è fatto l'highligth senza fare cambiamenti di sorta
    createContextMenuForErrors(tmpErrorNumber, suggestions, invalidWord, isForcedSuggestion, errorLevel, suggestionsLoaded, isCorrect, iframeContents);
    errorsNumber++;
}

// Crea un menù contestuale con i suggerimenti sullo span identificato dallo spanId
function createContextMenuForErrors(spanId, suggestions, invalidWord, isForcedSuggestion, errorLevel, contextErrorLevel, segmentsErrorLevel, suggestionsLoaded, isCorrect, isStartSentencedWord, iframeContents) {
    menuBuilder(spanId, suggestions, invalidWord, isForcedSuggestion, errorLevel, suggestionsLoaded, isCorrect, contextErrorLevel, segmentsErrorLevel);

    var elementToAttachContextMenu = getSpanElementForHighligthtByNumber(spanId);

    // DEVE essere chiamato prima di contextMenu per inizializzare le contextMenuCallBackFunction
    if (!suggestionsLoaded) {
        // tasto destro su parola errata
        elementToAttachContextMenu.rightClick(function (e) {
            // il timeout permette di caricare subito il menu con il loader di attesa dei suggerimenti
            setTimeout(function () {
                // qui vengono lanciate le queries per il caricamento dei suggerimenti
                $('#crtMn_' + spanId).css('top', parseFloat(e.clientY) + parseFloat($('#workSpace').offset().top) + parseFloat(40));
                $('#crtMn_' + spanId).show();
                suggestionsLoaderForSingleWord(elementToAttachContextMenu.attr('data-type-isCorrect'), invalidWord, isForcedSuggestion, errorLevel, contextErrorLevel, segmentsErrorLevel, isStartSentencedWord, spanId, elementToAttachContextMenu);
                // aggiunta di un nuovo attributo per limitare il caricamento dei suggerimenti ad una singola chiamata
                elementToAttachContextMenu.attr('data-type-suggestionsLoaded', 'true');
            }, 0);
        });
    }

    // contextMenu
    elementToAttachContextMenu.contextMenu({
        menu: "crtMn_" + spanId

    }, function (action, el, pos) {
        contextMenuCallBackFunction(action, el, pos);
    });
}

// creazione del context menu con <ul> e <li>
function menuBuilder(spanId, suggestions, invalidWord, isForcedSuggestion, errorLevel, suggestionsLoaded, isCorrect, contextErrorLevel, segmentsErrorLevel) {
    var list = $("<ul id=\"crtMn_" + spanId + "\" class=\"cntxtMn\"></ul>").appendTo("#contextMenuContainer");

    if (!suggestionsLoaded) {
        // loader per attesa caricamento suggerimenti
        list.append("<span id='suggestionsContainer_" + spanId + "' style='align:center'>" + labelBuilder("<img src='/applications/dictionary/images/loader.gif' width='15px' border='0'> <i>attendere per favore</i>", false, 0) + "</span>");

        var maxRowNumbers = '20';
        // loop con righe fasulle poi sostituite da suggerimenti
        // (questo perchè le righe aggiunte dinamicamente non erano inizializzate nella callBackFunction)
        for (var y = 1; y <= maxRowNumbers; y++) {
            var idli = "hdl_" + spanId + "_" + y;

            var additionalStyle = errorLevel == 0 && contextErrorLevel == 0 ? 'pointer-events: none;cursor:default' : '';

            list.append("<li id='" + idli + "' class='hdlOpenXML' style=\"display:none;\"><a class='aCorrectWord' style=\"" + additionalStyle + "\" id=\"hda_" + spanId + "_" + y + "\">&nbsp;</a><a href='#%openXML" + idli + "' class='hdXml' id=\"hdXml_" + spanId + "_" + y + "\">►</a></li>");
        }

    } else if (suggestions != null && suggestions.length > 0) {
        for (var i = 0; i < suggestions.length; i++) {
            var suggestion = suggestions[i];
            var label = labelBuilder(suggestion, isForcedSuggestion, errorLevel);
            list.append(label);
        }
    }

    if (isCorrect) {
        var idliCorr = "hdl_" + spanId + "_" + 1;
        list.append("<li id='" + idliCorr + "' class='hdlOpenXML' style='display:none;'><a class='aCorrectWord' href=\"#%isCorrect%\"></a><a href='#%openXML" + idliCorr + "' class='hdXml' id=\"hdXml_" + spanId + "_" + 1 + "\">►</a></li>");
    } else {
        // opzioni comuni a tutti i context menu
        list.append("<li id='separator' class=\"separator\">&nbsp;</li>");
        list.append("<li id='ignore_" + spanId + "' class='ignore'><a href=\"#%ignore%\">ignora</a></li>");
    }

    var wordOccurrencies = getWordOccurrencies(invalidWord);
    if (!isCorrect && wordOccurrencies != null && wordOccurrencies.length > 1)
        list.append("<li id='ignoreAll' ><a href=\"#%ignoreAll%\">ignora tutto</a></li>");

    if (!isCorrect && !suggestionsLoaded) {
        // vengono inserite entrambe le opzioni (in modo tale che venga inizializzata la rispettiva callBack function)
        // successivamente verrà visualizzata solo la voce corretta a seconda del numero di suggerimenti trovati
        list.append("<li id='sendSugg_" + spanId + "' style='display:none;' class='sendSugg' ><a href=\"#%sendSuggestion%\">invia suggerimento</a></li>");
        list.append("<li id='sendEx_" + spanId + "' style='display:none;' class='sendEx' ><a href=\"#%sendToExperts%\">invia agli esperti</a></li>");
    } else {
        if (!isCorrect && (suggestions == null || suggestions.length == 0))
            list.append("<li><a href=\"#%sendToExperts%\">invia agli esperti</a></li>");
        else if (!isCorrect)
            list.append("<li><a href=\"#%sendSuggestion%\">invia suggerimento</a></li>");
    }
}


function labelBuilder(suggestion, isForcedSuggestion, errorLevel) {
    return "<li><a href=\"#" + suggestion + "\">" + suggestion + "</a></li>";
}

function textLabelBuilder(errorLevel, contextErrorLevel, segmentsErrorLevel) {
    var maybeBetterOrNothing = "";

    if (errorLevel == 0 && contextErrorLevel == 1) {
        maybeBetterOrNothing = "richiesta maiuscola";
    } else if (errorLevel == 0 && contextErrorLevel == 2) {
        maybeBetterOrNothing = "richiesta minuscola";
    } else if (errorLevel == 1) {
        maybeBetterOrNothing = "meglio"
    } else if (errorLevel == 2) {
        maybeBetterOrNothing = "più corretto";
    } else if (errorLevel == 3) {
        maybeBetterOrNothing = "forse intendevi";
    } else if (errorLevel == 4) {
        maybeBetterOrNothing = "";
    } else if (errorLevel == 5) {
        maybeBetterOrNothing = "oppure intendevi";
    }

    if (maybeBetterOrNothing.length > 0)
        maybeBetterOrNothing += " &raquo; ";

    return maybeBetterOrNothing;
}

/**
 *  Funzione di callBack sul context menu
 *
 * @param action ritorna l'azione da fare, nel nostro caso sono le parole da sostituire, oppure ignora
 * @param el l'elemento da cui possiamo prendere id e contenuto testuale
 * @param pos posizione dell'elemento 'X: ' + pos.x + '  Y: ' + pos.y + ' (relative to element)\n\n' +
 *                                    'X: ' + pos.docX + '  Y: ' + pos.docY+ ' (relative to document)'
 */
function contextMenuCallBackFunction(action, el, pos) {
    if ($.browser.msie) {
        action = action.split("jsp#");

        if (action != null && action.length > 1)
            action = action[action.length - 1];
    }

    // azioni da eseguire
    var isIgnore = (action == '%ignore%');
    var isIgnoreAll = (action == '%ignoreAll%');
    var isSendToExperts = (action == '%sendToExperts%');
    var isSendSuggestion = (action == '%sendSuggestion%');
    var isCorrect = (action == '%isCorrect%');
    var isOpenXml = (action.beginsWith('%openXML'));

    var iframeContents = $("#areaText").prev().find("iframe").contents();
    var originalWord = $(el).text();
    var spanId = $(el).attr('id');

    if (isIgnore)
        ignoreThisWord(originalWord, true, spanId, iframeContents);
    else if (isIgnoreAll)
        ignoreThisWord(originalWord, false, spanId, iframeContents);
    else if (isSendToExperts)
        sendSuggestion(originalWord, spanId, false, iframeContents);
    else if (isSendSuggestion)
        sendSuggestion(originalWord, spanId, true, iframeContents);
    else if (isOpenXml) {
        openXML(spanId.replace('word_', ''), action.replace('%openXML', ''));
    } else if (isCorrect) {
        // al momento non fa niente
    } else
        replaceWord(originalWord, action, spanId, iframeContents);

    if (!isOpenXml) {
        $(".cntxtMn").hide();
        $("#openXMLContainer").hide()
    }

}

/******************************************************************************************************************************************************************************************
 *
 * FUNZIONI DI SOTTOLINEATURA
 *
 ******************************************************************************************************************************************************************************************/
// highlight rosso per l'errore
function selecWordAsError(originalWord, errNumber, iframeContents) {
    highlightWords(originalWord, true, errNumber, false, iframeContents);
}

// highlight verde per il suggerimento forzato
function selecWordAsForcedSuggestion(originalWord, errNumber, iframeContents) {
    highlightWords(originalWord, false, errNumber, true, iframeContents);
}

// nessun highlight in quanto parola corretta
function selecWordAsCorrect(originalWord, errNumber, iframeContents) {
    //var bodyHtml = iframeContents.find("body").contents();
    highlightWords(originalWord, false, errNumber, false, iframeContents);
}

// highligth sia come errore che come evidenziatore di una parola
function highlightWords(originalWord, isError, errNumber, isForcedSuggestion, iframeContents) {
    var bodyHtml = iframeContents.find("body").contents();
    bodyHtml.textHighlighter(originalWord, false, errNumber, isError, isForcedSuggestion);
}

// rimuove l'highligth dal testo
function resetCorrection() {
    var bodyHtml = $("#areaText").prev().find("iframe").contents().find("body");
    /*if ($.browser.webkit || $.browser.sarafi) {
     // webkit non trova i contenuti cercati nel dom per l'highlight se non si passa il contents
     bodyHtml = bodyHtml.contents();
     }*/

    // distruggo i context menù associati agli span
    bodyHtml.destroyContextMenu();

    // Svuoto il contenitore per i context menù
    $('#contextMenuContainer').empty();

    // rimuovo tutti gli highlights
    bodyHtml.removeHighlight();

    // resetto le variabili per il correttore
    textElements = new Array();
    errorsNumber = 1;
    isWorkingOnCorrection = false;
    isAlreadyAdviceToPerformCorrection = true;
}

function copyToClipboard() {
    var $textArea = $('#areaText');
    var rangeText = $textArea.data("wysiwyg").getRangeText();
    var text = rangeText.length === 0 ? $textArea.wysiwyg("getContent") : rangeText;

    var textarea = document.createElement('textarea');
    textarea.textContent = $('<div>' + text + '</div>').text().trim();
    document.body.appendChild(textarea);

    var selection = document.getSelection();
    var range = document.createRange();
    range.selectNode(textarea);
    selection.removeAllRanges();
    selection.addRange(range);

    document.execCommand('copy');
    selection.removeAllRanges();

    document.body.removeChild(textarea);
}

function visualizeLoader(wordToSend, spanId, isAltroSugg) {
    var loading =
        "<div>" +
        "<div>&nbsp;</div>" +
        "<div>" +
        "<div align='center'>correzione  <span id =\"loadCorrectionPercentage\">0%</span></div>" +
        "<div>&nbsp;</div>" +
        "<div align='center'><span id=\"loadCorrection\"><img width=\"25px\" src=\"/applications/dictionary/images/loader.gif\"></span></div>" +
        "</div>" +
        "</div>";

    // istanzia il dialog modale per l'inserimento dei suggerimenti da inviare agli esperti
    $(loading).dialog({
        modal: true,
        draggable: false,
        resizable: false,
        title: "attendere per favore",

        buttons: {
            Cancel: function () {
                interruptCorrection();
                $(this).dialog("close");
            }
        },

        // il close con rimozione dell'elemento dal dom permette di reistanziarlo correttamente in caso di nuova chiamata
        close: function (ev, ui) {
            interruptCorrection();
            $(this).remove();
        }
    });
}

function removeLoader() {
    if ($('#loadCorrectionPercentage').html() != null || $('#loadCorrectionPercentage').html() != "")
        $('.ui-dialog-content').dialog("close");
}

// Restituisce un array contenente tutte le occorrenze della parola cercata (maiuscola / minuscola / cammellata).
function getWordOccurrencies(wordToFind) {
    var strText = $("#areaText").prev().find("iframe").contents().text();
    // passo alla regular expression i modificatori i e g:
    // i : case insesitive
    // g : tutti i match
    var regexToUse = new RegExp(wordToFind, "ig");
    return strText.match(regexToUse);
}

/**
 *  Restituisce un array contenente tutti gli elementi individuati dall'id passato come parametro alla funzione
 * @param sequenceNumb numero sequenziale utilizzato per creare l'id dello span per fare l'highligth della parola
 */
function getSpanElementForHighligthtByNumber(sequenceNumb) {
    return $("#areaText").prev().find("iframe").contents().find("span").filter(function () {
        return (this.id == "word_" + sequenceNumb)
    });
}

/**
 * Sostituisce la originalWord con la correctWord, onSingleWord boolean che specifica se eseguire la sostituzione su una singola parola oppure su tutte
 * @param onSingleWord boolean che specifica se eseguire la sostituzione su una singola parola oppure su tutte
 */
function replaceWordOld(originalWord, correctWord, onSingleWord, spanId, iframeContents) {
    disableHighligthOnWordsAndSubstitute(originalWord, onSingleWord, correctWord, spanId);
}

function replaceWord(originalWord, correctWord, spanId, iframeContents) {
    var $span = iframeContents.find('#' + spanId);
    var indexId = spanId.replace('word_', '');
    $span.attr("class", "hlCorr");
    $span.text(correctWord);
    $span.attr('data-type-isCorrect', 'true');
    var $lis = $('#crtMn_' + indexId + ' li.hdlOpenXML');
    $lis.each(function () {
        if ($(this).find(' a.aCorrectWord').attr('href') == '#' + correctWord) {
            $lis.not($(this)).remove();
            return false;
        }
    });

    $('#crtMn_' + indexId + ' small.maybeMean:first-child').remove();
}

/**
 *  Rimuove l'highligth sulle parole che matchano word e se presente newWord sostituisce word con newWord
 * @param onSingleWord boolean che specifica se eseguire la sostituzione su una singola parola oppure su tutte
 */


function disableHighligthOnWordsAndSubstitute(word, onSingleWord, newWord, spanId, iframeContents) {
    // required by IE
    if (newWord)
        newWord = newWord.toString();

    iframeContents = $("#areaText").prev().find("iframe").contents();
    var isOnSingleWordOnly = (onSingleWord != null && onSingleWord);
    var isWordSubstitution = (newWord != null && newWord != "");
    var spanWithWord;

    // Nel caso della singola parola vado ad agire per id dello span
    if (isOnSingleWordOnly) {
        spanWithWord = iframeContents.find('#' + spanId);

        var $textArea = $('#areaText');
        var document = $textArea.data("wysiwyg").editorDoc;
        var sel = document.getSelection();
        var range = sel.getRangeAt(0);
        $textArea.data("wysiwyg").editor.get(0).contentWindow.focus();
        var startNode = document.getElementById(spanId);

        range.setStartAfter(startNode);
        range.setEndAfter(startNode);

        if (isWordSubstitution)
            spanWithWord.html(newWord);

        iframeContents.removeSingleHighlight(spanId);

    } else {
        // in caso di cambio in massa delle parole, cerco tutti gli span con highlight sia di evidenziazione sia di errore
        spanWithWord = iframeContents.find("span").filter(function () {
            return ($(this).text() == word)
        });

        // controllo se ci sono elementi con le caratteristiche desiderate
        if (spanWithWord != null && spanWithWord.length > 0) {
            if (isWordSubstitution)
                spanWithWord.html(newWord);

            //.. se ci sono ciclo sull'array di elementi trovati
            for (var spanIndex = 0; spanIndex < spanWithWord.length; spanIndex++)
                iframeContents.removeSingleHighlight(spanWithWord[spanIndex].id);

            // con questa riga di codice si sostituisce il testo direttamente dentro il tag span
            //spanWithWord[0].firstChild.textContent = newWord;
        }
    }
}

// Rimuove l'highligth dalla parola in esame e con essa il context menù
function ignoreThisWord(originalWord, onSingleWord, spanId, iframeContents) {
    disableHighligthOnWordsAndSubstitute(originalWord, onSingleWord, null, spanId, iframeContents);
}

function openXML(index, idli) {

    $('.hdXml').text("►");
    var $aXml = $('#' + idli.replace('hdl', 'hdXml'));

    if ($('#openXMLContainer.' + idli).length > 0) {
        $('#openXMLContainer').remove();
    } else {
        var id = $('#' + idli + ' a.aCorrectWord').attr('data-entryid-type');

        if ($('#openXMLContainer').length == 0)
            $('#contextMenuContainer').append("<div id='openXMLContainer' class='openXMLContainer " + idli + "'>&nbsp;</div>");
        else
            $('#openXMLContainer').attr('class', 'openXMLContainer ' + idli);

        var $div = $('#openXMLContainer');

        var $crtMn = $('#crtMn_' + index);
        //$div.css('top', $crtMn.css('top')).css('left', parseFloat($crtMn.css('left')) + parseFloat($crtMn.width()));
        var url = '/applications/dictionary/entry/xml/xmlResult.jsp?_VP_V_ID=1454232697&_VP_OBJ_ID=' + id + '&LANGUAGE_ID=2';
        var res = loadSyncroContent(url, 'openXMLContainer', '', function () {
            $aXml.text("▼");
            $div.css('left', parseFloat($crtMn.css('left')));
            var liIndex = idli.split(/[_]+/).pop() // equivalente di: idli.split('_')[idli.split('_').length - 1];
            $div.css('top', ((parseFloat('23.5') * (liIndex)) + (parseFloat($crtMn.css('top').replace('px', '')))) + "px");

            if ($('#crtMn_' + index).is(':visible'))
                $div.fadeIn(200);
        });
    }
}

/**
 * Apre un form di inserimento per inviare eventuali suggerimenti agli esperti
 * @param isAltroSugg se true è un form per mandare un altro suggerimento agli esperti, false è per segnalare la parola
 */
function sendSuggestion(wordToSend, spanId, isAltroSugg, iframeContents) {
    var formTitle = "Invia agli esperti";

    if (isAltroSugg != null && isAltroSugg)
        formTitle = "Invia agli esperti un ulteriore suggerimento";

    var actualDate = "05/02/2025";
    // Entry form per l'invio dei suggerimenti agli esperti
    var dialogForm = "<div id=\"dialog-form\" title=\"Create new user\" style=\"display:none;\" class=\"modal-form\">" +
        "<form>" +
        "<fieldset>" +
        "<table width='100%' border='0'>" +
        "<tr>" +
        "<td><label for=\"selected_word\">parola</label></td>" +
        "<td align='left'><input type=\"text\" readonly name=\"selected_word\" id=\"selected_word\" class=\"text ui-widget-content ui-corner-all\" value=\"" + wordToSend + "\"/></td>" +
        "</tr>" +
        "<tr>" +
        "<td><label for=\"suggestions\">suggerimento</label></td>" +
        "<td align='left'><input type=\"text\" name=\"suggestions\" id=\"suggestions\" value=\"\" class=\"text ui-widget-content ui-corner-all\"/></td>" +
        "</tr>" +
        "<tr>" +
        "<td><label for=\"comments\">commento</label></td>" +
        "<td><textarea name=\"comments\" id=\"comments\" rows=\"3\" cols=\"33\" class=\"text ui-widget-content ui-corner-all\"/></td>" +
        "</tr>" +
        "<tr>" +
        "<td><label for=\"sender_email\">e-mail</label></td>" +
        "<td><input type=\"text\" name=\"sender_email\" id=\"sender_email\" value=\"\" class=\"text ui-widget-content ui-corner-all\"/></td>" +
        "</tr>" +
        "<tr>" +
        "<td><label for=\"date\">data</label></td>" +
        "<td>" + actualDate + "</td>" +
        "</tr>" +
        "</table>" +
        "</fieldset>" +
        "</form>" +
        "</div>";

    // istanzia il dialog modale per l'inserimento dei suggerimenti da inviare agli esperti
    $(dialogForm).dialog({
        modal: true,
        draggable: false,
        height: 400,
        width: 450,
        resizable: false,
        title: formTitle,
        dialogClass: 'teoros',

        buttons: {
            'invia suggerimento': function () {

                var isOk = true;
                var alertMessage = "";
                var altroSuggCheck = isAltroSugg != null && isAltroSugg;

                var suggestions = $('#suggestions').val();
                if (altroSuggCheck && (suggestions == null || suggestions == '')) {
                    alertMessage = "Non vi sono suggerimenti";
                    isOk = false;
                }

                var email = $('#sender_email').val();
                // controllo sull'esistenza della mail
                if (isOk && (email == null || email == "")) {
                    alertMessage = alertMessage + "\n" + "Inserire la e-mail";
                    isOk = false;
                }

                // controllo mail
                if (isOk) {
                    if (email != null && email != '') {
                        // Se ci sono le condizioni per controllare allora
                        var regEx = /^([a-zA-Z0-9_\.\-])+\@(([a-zA-Z0-9\-])+\.)+([a-zA-Z0-9]{2,4})+$/;
                        if (!regEx.test(email)) {
                            alertMessage = alertMessage + "\n" + "E-mail non valida";
                            isOk = false;
                        }

                    } else {
                        alertMessage = alertMessage + "\n" + "Inserire la e-mail";
                        isOk = false;
                    }
                }

                if (isOk) {
                    if (sendSuggestions()) {
                        var bodyHtml = $("#areaText").prev().find("iframe").contents().find("body");
                        bodyHtml.removeSingleHighlight(spanId);
                        $(this).dialog("close");

                    } else
                        alert("Si è verificato un errore; si prega di riprovare");
                } else
                    alert(alertMessage);
            },

            'chiudi': function () {
                $(this).dialog("close");
            }

        }
    });
    // da qualche parte la classe ui-button aveva width e height a in size assoluta ==> le label uscivano dal button
    $("div.ui-dialog-buttonpane button.ui-button ").css({width: 'auto', height: 'auto'});
}

// invio dei suggerimenti agli esperti
function sendSuggestions() {
    var retVal = false;
    var params = new Object();

    params.selected_word = $('#selected_word').val();
    params.suggestions = $('#suggestions').val();
    params.comments = $('#comments').val();
    params.sender_email = $('#sender_email').val();
    params.id_background = $('#INTERFACE_LANGUAGE').val();
    params.id_language = $('#LANGUAGE').val();

    $.ajax({
        type: "POST",
        cache: false,
        url: "/applications/dictionary/spellchecker/ajax/sendToExperts.jsp",
        data: params,
        async: false,
        timeout: 30000,

        success: function (ret) {
            retVal = true;
        },

        error: function (xhr, status, error) {
            var err = eval("(" + xhr.responseText + ")");
            alert(err.Message + " status " + status + " error " + error);
            retVal = false;
        }
    });

    return retVal;
}






function startCorrection() {
    var $textArea = $('#areaText');
    var document = $textArea.data("wysiwyg").editorDoc;
    var sel = document.getSelection();
    var range = sel.getRangeAt(0);

    var text = $textArea.wysiwyg("getContent");
    text = correttoreTextCleaner(text);
    $textArea.wysiwyg("setContent", text);


    if ($('#INTERFACE_LANGUAGE').val() == '')
        alert('selezionare lingue e background prima di iniziare la correzione');
    else
        startSpellCheck();

    $textArea.data("wysiwyg").editor.get(0).contentWindow.focus();

    //get the node of the element you wish to put the caret after
    var startNode = document.body;

//set the caret after the node for this range
    range.setStartAfter(startNode);
    range.setEndAfter(startNode);

//apply this range to the selection object
    sel.removeAllRanges();
    sel.addRange(range);
}

function correttoreTextCleaner(text) {
    // MsWord chars cleaner & conversion
    text = msWordCharsReplacer(text);
    // in caso di a capo è necessario distanziare le parole (qualora non vi siano spazi prima dello a capo stesso)
    text = text.replace(/<br.*?>/gi, ' <br/>');
    return text;
}




function startSpellCheck() {
    pos = 0;
    getTextElementsFromDom();
    spellCheckText();
}



function getTextElementsFromDom() {
    var bodyHtml = $('#wysiwyg_areaText').contents().find("body");

    // distruzione dei context menù associati agli span
    bodyHtml.destroyContextMenu();

    // ripulitura del contenuto dei vari contextMenu nel div target delle correzioni
    $('#contextMenuContainer').empty();

    // rimozione highlight
    bodyHtml.removeHighlight();

    // inizializzazione dell'array di elementi (paragrafi) del testo
    textElements = new Array();
    // reset dell'index degli elementi
    indexOfElements = 0;
    // inizializzazione del numero di errori:
    errorsNumber = 1;
    // l'utente non è stato avvisato della fine della correzione
    isAlreadyAdviceToPerformCorrection = false;
    // è partita una nuova correzione
    isWorkingOnCorrection = true;

    // Funziona con Firefox ma non con Chrome
    //var domContentArray = bodyHtml.contents().filter(function() { if (this.nodeType == 3) {return this; } });
    //var domContentArray = bodyHtml.contents();
    var domContentArray = null;

    var isFirefox = $.browser.mozilla;
    var isExplorer = $.browser.msie;
    //var isChromeSafari = $.browser.safari;

    // se è firefox prendo il testo direttamente dal dom e lo divido in paragrafi sfruttando la punteggiatura.
    if (isFirefox || isExplorer) {
        // in origine split del testo sulla sola presenza del punto
        // per non separare indirizzi internet aggiunta anche la presenza dello spazio
        domContentArray = bodyHtml.contents().text().split("\. ");
        // Chrome & Safari
    } else {
        domContentArray = bodyHtml.contents();
    }

    if (domContentArray != null) {
        for (var i = 0; i < domContentArray.length; i++) {
            var tmpParameters = new Array();
            var tmpNode = domContentArray[i];
            var nodeValue = null;

            if (isFirefox || isExplorer) {
                nodeValue = domContentArray[i];

            } else {
                nodeValue = tmpNode.wholeText;

                // controllo se la proprietà è definita per questo tipo di nodo testo
                if (nodeValue == undefined) {
                    // se non è definita allora si tratta di innerText
                    nodeValue = tmpNode.innerText;
                }

                // controllo se è uno di testo vuoto
                if (nodeValue != undefined && nodeValue.trim() == "")
                    nodeValue = "";
            }

            tmpParameters[0] = nodeValue;
            tmpParameters[1] = i;
            tmpParameters[2] = pos;
            textElements[indexOfElements] = tmpParameters;
            //pos += nodeValue.length;
            indexOfElements++;
        }
    }
}



function interruptCorrection() {
    if (isWorkingOnCorrection) {
        isInterruptCorrection = true;
        isWorkingOnCorrection = false;
        //return false;
    }
}



function printText() {
    if (!isWorkingOnCorrection) {
        var htmlToPrint = $('#wysiwyg_areaText').contents().find("body").html();
        var printContainer = $("#printContainer");
        printContainer.html(htmlToPrint);
        $(".printable").print();
        // ripulisco il div dall'html
        printContainer.html("");

    } else {
        alert("Correzione ancora in corso");
    }
}

function downloadText(a, isPlain) {
    var body = $('#wysiwyg_areaText').contents().find("body");
    var text = '';
    var textType = '';
    var extension = '';

    if (isPlain) {
        text = body.text();
        textType = 'text/plain';
        extension = 'txt';
    } else {
        text = body.html();
        textType = 'text/html';
        extension = 'html';
    }

    if (text.trim().length > 0) {
        var file = new Blob([text], {type: textType});
        a.href = URL.createObjectURL(file);
        a.download = "spellcheckerText." + extension;
    } else {
        alert('il testo è vuoto!');
    }
}



function removeText() {
    if (!isWorkingOnCorrection) {
        if (confirm("Si desidera rimuovere il testo?")) {
            $('#wysiwyg_areaText').contents().find("body").text('');
            resetCorrection();
            isAlreadyAdviceToPerformCorrection = true;
        }

    } else {
        alert("Correzione ancora in corso");
    }
}



function createCookie(name, value, days) {
    var expires = "";
    if (days) {
        var date = new Date();
        date.setTime(date.getTime() + (days * 24 * 60 * 60 * 1000));
        expires = "; expires=" + date.toGMTString();
    }
    document.cookie = name + "=" + value + expires + "; path=/";
}