/*global SISAL, $, window, validaNuovaScommessa, bonus, moltiplicatoreSport, importoVincita, validaBiglietto, combinazioniIppica, importoVenditaIppica, validaNuovaScommessaIppica, combinazioniSIP, importoVenditaSIP, validaNuovaScommessaSIP */

/**
 * La variabile rappresenta il namespace utilizzato per tutto il codice javascript del palinsesto.
 */
SISAL.MATCHPOINT.PALINSESTO = (function PALINSESTO() {

    var contesto = "/PalinsestoNuovo",
        arrayMessaggi = [],
    
    /**
     * La variabile rappresenta il namespace utilizzato per tutto il codice
     * javascript del palinsesto.
     */
    components =
        [
        // menu new version
        {
            url : contesto + "/pubblico/menu/menu.jsp?sezione=sport" + location.search.replace("?", "&"),
            options : {target : "menu_sport"}
        },
        {
            url : contesto + "/pubblico/menu/menu.jsp?sezione=eventi" + location.search.replace("?", "&"),
            options : {target : "menu_eventi"}
        },
        {
            url : contesto + "/pubblico/menu/menu.jsp?sezione=live" + location.search.replace("?", "&"),
            options : {target : "menu_live"}
        },
        {
            url : contesto + "/pubblico/menu/menu.jsp?sezione=concorsi" + location.search.replace("?", "&"),
            options : {target : "menu_concorsi"}
        },
        {
            url : contesto + "/pubblico/menu/menu.jsp?sezione=ippica" + location.search.replace("?", "&"),
            options : {target : "menu_ippica"}
        },
        // sport
        {
            url : contesto + "/pubblico/sportSchedina.jsp" + location.search,
            options : {target : "dettaglio_sport_schedina"}
        },
        {
            url : contesto + "/pubblico/bigliettoSport.jsp" + location.search,
            options : {target : "biglietto_sport"}
        },
        // sistema sport
        {
            url : contesto + "/pubblico/sistemaSport.jsp" + location.search,
            options : {target : "dettaglio_sistema_sport"}
        },
        // calcolo sistema sport
        {
            url : contesto + "/pubblico/sistemaSportCalcolo.jsp" + location.search,
            options : {target : "dettaglio_sistema_sport_calcolo"}
        },
        // totocalcio
        {
            url : contesto + "/pubblico/schedinaTotocalcio.jsp" + location.search,
            options : {target : "dettaglio_concorsi_schedina_totocalcio"}
        },
        {
            url : contesto + "/pubblico/bigliettoTotocalcio.jsp" + location.search,
            options : {target : "biglietto_totocalcio"}
        },
        {
            url : contesto + "/pubblico/ultimoConcorsoTotocalcio.jsp" + location.search,
            options : {target : "dettaglio_concorsi_ultimo_concorso_totocalcio"}
        },
        // totogol
        {
            url : contesto + "/pubblico/schedinaTotogol.jsp" + location.search,
            options : {target : "dettaglio_concorsi_schedina_totogol"}
        },
        {
            url : contesto + "/pubblico/bigliettoTotogol.jsp" + location.search,
            options : {target : "biglietto_totogol"}
        },
        {
            url : contesto + "/pubblico/ultimoConcorsoTotogol.jsp" + location.search,
            options : {target : "dettaglio_concorsi_ultimo_concorso_totogol"}
        },
        // ippica
        {
            url : contesto + "/pubblico/ippicaSchedina.jsp" + location.search,
            options : {target : "dettaglio_ippica_schedina"}
        },
        {
            url : contesto + "/pubblico/bigliettoIppica.jsp" + location.search,
            options : {target : "biglietto_ippica"}
        },
        // tris
        {
            url : contesto + "/pubblico/trisSchedina.jsp" + location.search,
            options : {target : "dettaglio_tris_schedina"}
        },
        {
            url : contesto + "/pubblico/bigliettoTris.jsp" + location.search,
            options : {target : "biglietto_tris"}
        },
        {
            url : contesto + "/pubblico/quoteTrisSchedina.jsp" + location.search,
            options : {target : "dettaglio_quote_tris_schedina"}
        },
        // componenti singole
        // jackpot totocalcio/totogol
        {
            url : contesto + "/pubblico/jackpot.jsp",
            options : {target : "dettaglio_concorsi_jackpot"}
        },
        // live/lstminute/topquote
        {
            url : contesto + "/pubblico/liveLastMinuteTopQuote.jsp",
            options : {target : "dettaglio_live_lastminute_topquote"}
        },
        {
            url : contesto + "/pubblico/live.jsp",
            options : {target : "dettaglio_live"}
        },
        {
            url : contesto + "/pubblico/lastMinute.jsp",
            options : {target : "dettaglio_lastminute"}
        },
        {
            url : contesto + "/pubblico/topQuote.jsp",
            options : {target : "dettaglio_topquote"}
        },
        // live small
        {
            url : contesto + "/pubblico/liveSmall.jsp",
            options : {target : "dettaglio_live_small"}
        },
        // lastminute small
        {
            url : contesto + "/pubblico/lastMinuteSmall.jsp",
            options : {target : "dettaglio_lastminute_small"}
        },
        // topquote small
        {
            url : contesto + "/pubblico/topQuoteSmall.jsp",
            options : {target : "dettaglio_topquote_small"}
        },
        // prossime corse small
        {
            url : contesto + "/pubblico/ippicaProssimeCorseSmall.jsp",
            options : {target : "dettaglio_prossime_corse_small"}
        },
        // prossime corse
        {
            url : contesto + "/pubblico/ippicaProssimeCorse.jsp",
            options : {target : "dettaglio_prossime_corse"}
        },
        // tavoli/giocatori poker
        {
            url : contesto + "/pubblico/stripTavoliGiocatori.jsp",
            options : {target : "giocatori_poker"}
        },
        // tornei poker
        {
            url : contesto + "/pubblico/listaTorneiPoker.jsp",
            options : {target : "tornei_poker"}
        },
        // superenalotto
        {
            url : contesto + "/pubblico/jackpotSEFlash.jsp",
            options : {target : "superenalotto_flash"}
        },
        {
            url : contesto + "/pubblico/combinazioneSE.jsp",
            options : {target : "superenalotto_combinazione"}
        },
        {
            url : contesto + "/pubblico/jackpotSEFlashSmall.jsp",
            options : {target : "superenalotto_flash_small"}
        },
        {
            url : contesto + "/pubblico/ultimiConcorsiGNTN.jsp",
            options : {target : "gntn_combinazioni"}
        }
    ],

    /**
     * La variabile rappresenta le componenti di tipo menu dinamico
     */
    menuComponents =
        [
        "menu_sport",
        "menu_eventi",
        "menu_live",
        "menu_concorsi",
        "menu_ippica"
    ],
    
    /**
     * La variabile rappresenta la url della componente per verificare se la sessione è valida
     */
    sessioneAjaxUrl = contesto + "/pubblico/servlet/checksessione",
    
    /**
     * La variabile rappresenta la url della componente per gestire lo stato dei palinsesti
     */
    palinsestoAjaxUrl = contesto + "/pubblico/servlet/palinsesto?",
    
    /**
     * La variabile rappresenta la url della componente per gestire lo stato dei menu
     */
    menuAjaxUrl = contesto + "/pubblico/servlet/menu?",

    /**
     * La variabile rappresenta la url della componente per gestire le scommesse selezionate
     */
    scommessaAjaxUrl = contesto + "/pubblico/servlet/scommessa?",

    /**
     * La variabile rappresenta la url della componente per gestire le scommesse selezionate
     */
    rimuoviScommesseAjaxUrl = contesto + "/pubblico/servlet/rimuoviscommesse?",

    /**
     * La variabile rappresenta la url della componente per gestire la giocata
     */
    giocataAjaxUrl = contesto + "/pubblico/servlet/giocata?",

    /**
     * La variabile rappresenta le componenti aggiornate dal menu sport
     */
    sportComponents =
        [
        {
            url : contesto + "/pubblico/sportSchedina.jsp" + location.search,
            options : {target : "dettaglio_sport_schedina"}
        }
    ],

    /**
     * La variabile rappresenta le componenti aggiornate dal palinsesto sport
     */
    bigliettoSportComponents =
        [
        {
            url : contesto + "/pubblico/bigliettoSport.jsp",
            options : {target : "biglietto_sport"}
        }
    ],

    /**
     * La variabile rappresenta la url della componente incrementale aggiornata dal menu sport.
     */
    sportAjaxUrl = contesto + "/pubblico/sportSchedinaAjax.jsp",
    
    /**
     * La variabile rappresenta le scommesse sportive presenti nel biglietto Sport, ognuna delle quali è composta dai seguenti elementi 
     * scommessaSport[0]  = palinsesto
     * scommessaSport[1]  = avvenimento
     * scommessaSport[2]  = classe esito
     * scommessaSport[3]  = esito
     * scommessaSport[4]  = legame minimo
     * scommessaSport[5]  = legame massimo
     * scommessaSport[6]  = legame multipla
     * scommessaSport[7]  = black list min
     * scommessaSport[8]  = black list max
     * scommessaSport[9]  = descrizione avvenimento
     * scommessaSport[10] = descrizione classe esito
     * scommessaSport[11] = descrizione esito
     */
    listaScommesseSport = [],
    /**
     * La variabile rappresenta le quote delle scommesse sportive presenti nel biglietto sport 
     */
    listaQuoteSport = [],

    /**
     * La variabile rappresenta le componenti aggiornate dal sistema sport
     */
    sistemaSportComponents =
        [
        {
            url : contesto + "/pubblico/sistemaSport.jsp" + location.search,
            options : {target : "dettaglio_sistema_sport"}
        }
    ],

    /**
     * La variabile rappresenta le componenti da disabilitare se sistema sport è attivo
     */
    sistemaSportNoComponents =
        [
        "menu_sport",
        "menu_eventi",
        "menu_live",
        "menu_concorsi"
    ],
    
    /**
     * La variabile rappresenta le componenti aggiornate dal sistema sport
     */
    sistemaSportCalcoloComponents =
        [
        {
            url : contesto + "/pubblico/sistemaSportCalcolo.jsp" + location.search,
            options : {target : "dettaglio_sistema_sport_calcolo"}
        }
    ],

    /**
     * La variabile rappresenta le componenti aggiornate dal menu concorsi - totocalcio
     */
    totocalcioComponents =
        [
        {
            url : contesto + "/pubblico/schedinaTotocalcio.jsp" + location.search,
            options : {target : "dettaglio_concorsi_schedina_totocalcio"}
        },
        {
            url : contesto + "/pubblico/ultimoConcorsoTotocalcio.jsp" + location.search,
            options : {target : "dettaglio_concorsi_ultimo_concorso_totocalcio"}
        },
        {
            url : contesto + "/pubblico/jackpot.jsp",
            options : {target : "dettaglio_concorsi_jackpot"}
        }
    ],

    /**
     * La variabile rappresenta le componenti aggiornate dalla schedina totocalcio
     */
    bigliettoTotocalcioComponents =
        [
        {
            url : contesto + "/pubblico/bigliettoTotocalcio.jsp" + location.search,
            options : {target : "biglietto_totocalcio"}
        }
    ],

    /**
     * La variabile rappresenta la url della componente incrementale aggiornata dal menu totocalcio.
     */
    totocalcioAjaxUrl = contesto + "/pubblico/schedinaTotocalcioAjax.jsp",

    /**
     * La variabile rappresenta le componenti aggiornate dal menu concorsi - totogol
     */
    totogolComponents =
        [
        {
            url : contesto + "/pubblico/schedinaTotogol.jsp" + location.search,
            options : {target : "dettaglio_concorsi_schedina_totogol"}
        },
        {
            url : contesto + "/pubblico/ultimoConcorsoTotogol.jsp" + location.search,
            options : {target : "dettaglio_concorsi_ultimo_concorso_totogol"}
        },
        {
            url : contesto + "/pubblico/jackpot.jsp",
            options : {target : "dettaglio_concorsi_jackpot"}
        }
    ],

    /**
     * La variabile rappresenta le componenti aggiornate dalla schedina totogol
     */
    bigliettoTotogolComponents =
        [
        {
            url : contesto + "/pubblico/bigliettoTotogol.jsp" + location.search,
            options : {target : "biglietto_totogol"}
        }
    ],

    /**
     * La variabile rappresenta la url della componente incrementale aggiornata dal menu totogol.
     */
    totogolAjaxUrl = contesto + "/pubblico/schedinaTotogolAjax.jsp",

    /**
     * La variabile rappresenta le componenti aggiornate dal menu ippica totalizzatore
     */
    ippicaComponents =
        [
        {
            url : contesto + "/pubblico/ippicaSchedina.jsp" + location.search,
            options : {target : "dettaglio_ippica_schedina"}
        }
    ],

    /**
     * La variabile rappresenta le componenti aggiornate dal palinsesto ippica
     */
    bigliettoIppicaComponents =
        [
        {
            url : contesto + "/pubblico/bigliettoIppica.jsp" + location.search,
            options : {target : "biglietto_ippica"}
        }
    ],

    /**
     * La variabile rappresenta la url della componente incrementale aggiornata dal menu ippica.
     */
    ippicaAjaxUrl = contesto + "/pubblico/ippicaSchedinaAjax.jsp",
   
    /**
     * La variabile rappresenta le scommesse ippiche presenti nel biglietto Ippica 
     */
    listaScommessaIppica = [],

    /**
     * La variabile rappresenta le componenti aggiornate dal menu ippica nazionale
     */
    trisComponents =
        [
        {
            url : contesto + "/pubblico/trisSchedina.jsp" + location.search,
            options : {target : "dettaglio_tris_schedina"}
        },
        {
            url : contesto + "/pubblico/quoteTrisSchedina.jsp" + location.search,
            options : {target : "dettaglio_quote_tris_schedina"}
        }
    ],

    /**
     * La variabile rappresenta le componenti aggiornate dal palinsesto tris
     */
    bigliettoTrisComponents =
        [
        {
            url : contesto + "/pubblico/bigliettoTris.jsp" + location.search,
            options : {target : "biglietto_tris"}
        }
    ],

    /**
     * La variabile rappresenta la url della componente incrementale aggiornata dal menu tris.
     */
    trisAjaxUrl = contesto + "/pubblico/trisSchedinaAjax.jsp",
    
    /**
     * La variabile rappresenta le scommesse ippiche presenti nel biglietto Ippica 
     */
    listaScommessaTris = [];
    
    /**
     * La funzione converte da Numero a valuta in Euro
     * @return string
     */
    function numberToValuta(number)
    {
      
        var numberStr = parseFloat(number).toFixed(2).toString(), numFormatDec, numFormat = [];
      
        numFormatDec = numberStr.slice(-2);
        numberStr = numberStr.substring(0, numberStr.length - 3);
        while (numberStr.length > 3) {
            numFormat.unshift(numberStr.slice(-3));
            numberStr = numberStr.substring(0, numberStr.length - 3);
        }
        numFormat.unshift(numberStr);
        return numFormat.join('.') + ',' + numFormatDec; /* format 000.000.000,00 */
    }
    
    //
    // ritorna la posizione di un determinato carattere dato un offset da cui far partire la ricerca
    function searchFromOffset(testo, charRicerca, offsetStart)
    {
        var lastSearch = 0;
        
        // esco dal ciclo solo se ho trovato un carattere successivo all'offset o non esistono più caratteri inerenti alla ricerca
        do
        {
            // certo che nel testo sia contenuto il carattere da ricercare
            lastSearch = testo.search(charRicerca);
            // se non viene trovato nessun carattere, setto la condizione necessaria per uscire dal ciclo
            if (lastSearch === -1) 
            {
                offsetStart = -2; // necessario per uscire dal ciclo
            } else
            {
                // sostituisco al carattere trovato uno spazio in modo che non venga più preso in considerazione
                testo = testo.replace(testo.substring(lastSearch, lastSearch + charRicerca.length), ' ');
            }
        } while ((lastSearch <= offsetStart) && (lastSearch !== -1));
        // ritorno la posizione del primo carattere trovato successivo all'offset richiesto
        return lastSearch;
    }
    
    // passando una stringa vengono sostituiti i tag ( <esempio>) privi di spazio, utilizzando il testo contenuto nell'array passato alla funzione
    function messaggiParse(message, arrayParams)
    {
        var
            paramCounter = 0,
            tagDaSostituire = "",
            firstTag = 0,
            lastTag = 0;
        
        // ciclo se trovo i tag di apertura e chiusura
        while (((searchFromOffset(message, '<', firstTag) !== -1) && (searchFromOffset(message, '>', firstTag) !== -1)) && (paramCounter < arrayParams.length))
        {
            // recupero il primo tag di apertura
            firstTag = searchFromOffset(message, '<', firstTag);
            // recupero il primo tag di chiusura
            lastTag = searchFromOffset(message, '>', firstTag);
            // recupero il contenuto tra i tag (compresi)
            tagDaSostituire = message.substring(firstTag, lastTag + 1);
            // se il contenuto contiene spazi non lo considero..
            if (tagDaSostituire.search(' ') === -1)
            {
                // hideThis: sostuisce con javascript che nasconde il popup e l'overlay selezionato
                if (tagDaSostituire === "<euro>")
                {
                    // in caso il contenuto sia corretto effettuo la replate dei tag di sostituzione con l'array dei parametri passati
                    message = message.replace(tagDaSostituire, numberToValuta(arrayParams[paramCounter] / 100));
                }
                // sostituisce con il testo inserito dallo sviluppatore
                else
                {
                    // in caso il contenuto sia corretto effettuo la replate dei tag di sostituzione con l'array dei parametri passati
                    message = message.replace(tagDaSostituire, arrayParams[paramCounter]);
                }
                
                // incremento il vettore parametri in modo da poter prendere il successivo al prossimo step
                paramCounter += 1;
            }
        }
        // ritorno il messaggio elaborato sostituendo i tag
        return message;
    }
    
    /**
     * La funzione gestisce i messaggi delle api della piattaforma di gioco
     * @return il messaggio finale
     * @type string
     */
    function recuperaMessaggio(esito, options)
    {
        try
        {
            var
                codice = esito[0],
                messaggio = esito[1],
                info = [],
                ii = 0, 
                arrayPos = -1,
                msgOk = ""
                ;
            
            if (SISAL.logger.isDebugEnabled())
            {
                SISAL.logger.debug("recuperaMessaggio - inizio");
                SISAL.logger.debug("recuperaMessaggio - esito:\n" + SISAL.toStringAsLiteral(esito));
                SISAL.logger.debug("recuperaMessaggio - options:\n" + SISAL.toStringAsLiteral(options));
            }

            // gestione parametri
            if (SISAL.isNull(esito))
            {
                throw new Error("Parametro obbligatorio esito nullo.");
            }
            else if (!(esito instanceof Array))
            {
                throw new Error("Tipo parametro obbligatorio esito non corretto: " + typeof esito + ".");
            }   
            // gestione options
            options = SISAL.isNullOrEmpty(options) ? {} : SISAL.copy(options);
            options.func = typeof options.func !== "string" ? null : options.func;

            if (SISAL.logger.isTraceEnabled())
            {
                SISAL.logger.trace("recuperaMessaggio - options:\n" + SISAL.toStringAsLiteral(options));
            }
            
            // ciclo sull'array dei messaggi in ricerca del codice errore..
            do
            {
                // se il parametro è settato lo utilizzo per la ricerca
                if (SISAL.isNull(options.func))
                {
                    if (arrayMessaggi[ii][1] * 1 === codice * 1)
                    {
                        arrayPos = ii;
                    }
                } else
                {
                    if ((arrayMessaggi[ii][1] * 1 === codice * 1) && (arrayMessaggi[ii][0] === options.func))
                    {
                        arrayPos = ii;
                    }
                }
                ii += 1;
            } while (ii < arrayMessaggi.length && arrayPos === -1);
            
            // carimento delle info di ESITO dentro l'array INFO
            for (ii = 0; ii < esito.length - 2; ii += 1)
            {
                info[ii] = esito[ii + 2];
            }
            if (SISAL.logger.isTraceEnabled())
            {
                SISAL.logger.debug("recuperaMessaggio - info:\n" + SISAL.toStringAsLiteral(info));
            }
            
            // controllo se il codice di errore è stato trovato nell'array dei messaggi
            if (arrayPos === -1)
            {
                // ritorno il messagio di default
                msgOk = messaggio;
            } else
            {
                // faccio il parse del messaggio ricavato dall'array sostituendo i tag con i valori ricevuti durante la chiamata alla funzione
                msgOk = messaggiParse(arrayMessaggi[arrayPos][2], info);
            }
            
            if (SISAL.logger.isTraceEnabled())
            {
                SISAL.logger.trace("recuperaMessaggio - messaggio di ritorno:\n" + msgOk);
            }
            if (SISAL.logger.isDebugEnabled())
            {
                SISAL.logger.debug("recuperaMessaggio - fine");
            }
            
            // sostituisco tutti i segni di < (minore) e > (maggiore) con le rispettive entità &#60; (minore) e &#62; (maggiore)
            while (msgOk.search('<') !== -1)
            {
                msgOk = msgOk.replace('<', '&#60;');
            }
            while (msgOk.search('>') !== -1)
            {
                msgOk = msgOk.replace('>', '&#62;');
            }
            
            
            return msgOk;
        }
        catch (e)
        {
            if (SISAL.logger.isErrorEnabled())
            {
                SISAL.logger.error("recuperaMessaggio - ", e);
            }
        }
        return null;
    }
    
    /**
     * La funzione evidenzia le voci attive sul menu dinamico
     * @return null
     */
    function sessioneInattiva()
    {
        if ("https:" === document.location.protocol)
        {
            SISAL.FX.showOnElement_TemplatePopup('body',
                    'mp.alert.buttonok.html', {
                "TextAlign_default": "TextAlign_left",
                "{title}" : "Sessione scaduta",
                "{content}" : recuperaMessaggio([-1, "La sessione di gioco è scaduta. Per continuare a giocare effettua un nuovo login. Inoltre, la durata della sessione sarà di 15 minuti."], {func: "controllaSessione"}),
                "{buttonclick}" : "SISAL.unsetCookie('login');SISAL.MATCHPOINT.controlloSessioneLogin();",
                "{buttontext}" : "OK",
                width : '360px'
            });
        }
        else
        {
            SISAL.FX.showOnElement_TemplatePopup('body',
                    'mp.alert.buttonok.html', {
                "TextAlign_default": "TextAlign_left",
                "{title}" : "Sessione scaduta",
                "{content}" : recuperaMessaggio([-1, "La sessione è scaduta. Per continuare a navigare aggiorna la pagina."], {func: "controllaSessioneHttp"}),
                "{buttonclick}" : "<hideThis>",
                "{buttontext}" : "OK",
                width : '360px'
            });
        }
    }
    
    /**
     * La funzione evidenzia le voci attive sul menu dinamico
     * @return null
     */
    function evidenziaMenuAttivo(idmenu, classe)
    {
        if (SISAL.logger.isInfoEnabled())
        {
            SISAL.logger.info("evidenziaMenuAttivo - inizio");
        }

        var menu = document.getElementById(idmenu);
        
        if (!SISAL.isNull(menu))
        {
            menu.className = classe;
        }

        if (SISAL.logger.isInfoEnabled())
        {
            SISAL.logger.info("evidenziaMenuAttivo - fine");
        }
    }
    
    /**
     * La funzione effettua la pulizia delle classi selezionate
     * @return null
     */
    function togliEvidenzaMenu(sezione, classe)
    {
        if (SISAL.logger.isInfoEnabled())
        {
            SISAL.logger.info("togliEvidenzaMenu - inizio");
        }

        var menu1, i, menu2, k, menu3, j;
        
        for (i in menuComponents)
        {
            if (menuComponents.hasOwnProperty(i))
            {
                menu1 = document.getElementById(menuComponents[i]);
                if (!SISAL.isNull(menu1))
                {
                    if (sezione === "sport" && menuComponents[i] === "menu_sport")
                    {
                        continue;
                    }
                    if (sezione === "eventi" && menuComponents[i] === "menu_eventi")
                    {
                        continue;
                    }
                    if (sezione === "live" && menuComponents[i] === "menu_live")
                    {
                        continue;
                    }
                    if (sezione === "ippica" && menuComponents[i] === "menu_ippica")
                    {
                        continue;
                    }
                    if (SISAL.logger.isInfoEnabled())
                    {
                        SISAL.logger.info("togliEvidenzaMenu - menu: " + menuComponents[i]);
                    }
                    menu2 = menu1.getElementsByTagName("div");
                    if (!SISAL.isNull(menu2))
                    {
                        for (k = 0; k < menu2.length; k = k + 1)
                        {
                            menu3 = menu2[k].getElementsByTagName("div");
                            if (!SISAL.isNull(menu3))
                            {
                                for (j = 0; j < menu3.length; j = j + 1)
                                {
                                    if (menu3[j].className === classe)
                                    {
                                        menu3[j].className = "";
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
        
        if (SISAL.logger.isInfoEnabled())
        {
            SISAL.logger.info("togliEvidenzaMenu - fine");
        }
    }
    
    /**
     * La funzione effettua il caricamento dei componenti definiti per ogni sezione del menu.
     * @return null
     */
    function loadDettagliSezione(sezione, url, menuDiv, parameters)
    {
        var components, semaforo, ajaxUrl, masterDiv, i;
        
        if (SISAL.logger.isInfoEnabled())
        {
            SISAL.logger.info("loadDettagliSezione - inizio");
        }
        
        // determino components da utilizzare
        ajaxUrl = palinsestoAjaxUrl + "concessione=";
        if (sezione === "sport" || sezione === "eventi" || sezione === "live") {
            if (sezione === "sport")
            {
                ajaxUrl = ajaxUrl + "1";
            }
            if (sezione === "eventi") {
                ajaxUrl = ajaxUrl + "6";
            }
            if (sezione === "live") {
                ajaxUrl = ajaxUrl + "103";
            }
            components = SISAL.copy(SISAL.addParameters(sportComponents, parameters));
            // aggiungo prima componente biglietto sport
            components.push(bigliettoSportComponents[0]);
        }
        if (sezione === "totocalcio") {
            ajaxUrl = ajaxUrl + "400";
            components = SISAL.copy(SISAL.addParameters(totocalcioComponents, parameters));
            // aggiungo prima componente biglietto totocalcio
            components.push(bigliettoTotocalcioComponents[0]);
        }
        if (sezione === "totogol") {
            ajaxUrl = ajaxUrl + "500";
            components = SISAL.copy(SISAL.addParameters(totogolComponents, parameters));
            // aggiungo prima componente biglietto totogol
            components.push(bigliettoTotogolComponents[0]);
        }
        if (sezione === "ippica") {
            ajaxUrl = ajaxUrl + "2";
            components = SISAL.copy(SISAL.addParameters(ippicaComponents, parameters));
            // aggiungo prima componente biglietto ippica
            components.push(bigliettoIppicaComponents[0]);
        }
        if (sezione === "tris") {
            ajaxUrl = ajaxUrl + "4";
            components = SISAL.copy(SISAL.addParameters(trisComponents, parameters));
            // aggiungo prima componente biglietto tris
            components.push(bigliettoTrisComponents[0]);
        }
        
        // verifico se esiste semaforo per components[0]
        semaforo = document.getElementById("semaforo_" + components[0].options.target);
        if (!SISAL.isNull(semaforo))
        {
            if (SISAL.logger.isInfoEnabled())
            {
                SISAL.logger.info("loadDettagliSezione - esiste semaforo");
            }
            return;
        }
        
        // pulizia evidenza menu
        togliEvidenzaMenu(sezione, 'color_menudin_voce2_sel');
        
        // pulizia dati in sessione
        SISAL.ajax(palinsestoAjaxUrl + "erase=true&sezione=" + sezione, {softsync: false});
        
        // verifico se devo cambiare pagina
        masterDiv = document.getElementById(components[0].options.target);
        if (SISAL.isNull(masterDiv))
        {            
            if (SISAL.logger.isInfoEnabled())
            {
                SISAL.logger.info("loadDettagliSezione - vado in " + url);
            }
             
            // cambio pagina
            for (i in parameters)
            {
                if (parameters.hasOwnProperty(i)) {
                    ajaxUrl = ajaxUrl + "&" + i + "=" + parameters[i];
                }
            }
            SISAL.ajax(ajaxUrl, {success: function () { 
                                                        location.href = url;
                                                        // aggiorno sessione menu se presente
                                                        if (!SISAL.isNull(menuDiv))
                                                        {
                                                            SISAL.ajax(menuAjaxUrl + "elemento=" + menuDiv + "&selezione=true");
                                                            evidenziaMenuAttivo(menuDiv, 'color_menudin_voce2_sel');
                                                        }
                                                    }});
            return;
        }
        
        // pulizia div html
        if (sezione === "sport" || sezione === "eventi" || sezione === "live") {
            SISAL.unloadComponents(totocalcioComponents);
            SISAL.unloadComponents(bigliettoTotocalcioComponents);
            SISAL.unloadComponents(totogolComponents);
            SISAL.unloadComponents(bigliettoTotogolComponents);
            SISAL.unloadComponents(ippicaComponents);
            SISAL.unloadComponents(bigliettoIppicaComponents);
            SISAL.unloadComponents(trisComponents);
            SISAL.unloadComponents(bigliettoTrisComponents);
        }
        if (sezione === "totocalcio") {
            SISAL.unloadComponents(sportComponents);
            SISAL.unloadComponents(bigliettoSportComponents);
            SISAL.unloadComponents(totogolComponents);
            SISAL.unloadComponents(bigliettoTotogolComponents);
            SISAL.unloadComponents(ippicaComponents);
            SISAL.unloadComponents(bigliettoIppicaComponents);
            SISAL.unloadComponents(trisComponents);
            SISAL.unloadComponents(bigliettoTrisComponents);
        }
        if (sezione === "totogol") {
            SISAL.unloadComponents(sportComponents);
            SISAL.unloadComponents(bigliettoSportComponents);
            SISAL.unloadComponents(totocalcioComponents);
            SISAL.unloadComponents(bigliettoTotocalcioComponents);
            SISAL.unloadComponents(ippicaComponents);
            SISAL.unloadComponents(bigliettoIppicaComponents);
            SISAL.unloadComponents(trisComponents);
            SISAL.unloadComponents(bigliettoTrisComponents);
        }
        if (sezione === "ippica") {
            SISAL.unloadComponents(sportComponents);
            SISAL.unloadComponents(bigliettoSportComponents);
            SISAL.unloadComponents(totocalcioComponents);
            SISAL.unloadComponents(bigliettoTotocalcioComponents);
            SISAL.unloadComponents(totogolComponents);
            SISAL.unloadComponents(bigliettoTotogolComponents);
            SISAL.unloadComponents(trisComponents);
            SISAL.unloadComponents(bigliettoTrisComponents);
        }
        if (sezione === "tris") {
            SISAL.unloadComponents(sportComponents);
            SISAL.unloadComponents(bigliettoSportComponents);
            SISAL.unloadComponents(totocalcioComponents);
            SISAL.unloadComponents(bigliettoTotocalcioComponents);
            SISAL.unloadComponents(totogolComponents);
            SISAL.unloadComponents(bigliettoTotogolComponents);
            SISAL.unloadComponents(ippicaComponents);
            SISAL.unloadComponents(bigliettoIppicaComponents);
        }
        
        // carico applicazioni
        SISAL.loadApplication(components);
        // aggiorno sessione menu se presente
        if (!SISAL.isNull(menuDiv))
        {
            SISAL.ajax(menuAjaxUrl + "elemento=" + menuDiv + "&selezione=true");
            evidenziaMenuAttivo(menuDiv, 'color_menudin_voce2_sel');
        }
       
        if (SISAL.logger.isInfoEnabled())
        {
            SISAL.logger.info("loadDettagliSezione - fine");
        }
    }

    /**
     * La funzione effettua l'aggiornamento dei componenti definiti per ogni sezione del menu.
     * @return null
     */
    function aggiornaDettagliSezione(sezione, parameters)
    {
        if (SISAL.logger.isInfoEnabled())
        {
            SISAL.logger.info("aggiornaDettagliSezione - inizio");
        }

        var components;
        
        if (sezione === "sport" || sezione === "eventi" || sezione === "live") {
            components = SISAL.copy(sportComponents.slice(1));
        }
        if (sezione === "totocalcio") {
            components = SISAL.copy(totocalcioComponents.slice(1));
        }
        if (sezione === "totogol") {
            components = SISAL.copy(totogolComponents.slice(1));
        }
        if (sezione === "ippica") {
            components = SISAL.copy(ippicaComponents.slice(1));
        }
        if (sezione === "tris") {
            components = SISAL.copy(trisComponents.slice(1));
            components.push(bigliettoTrisComponents[0]);
        }
        if (SISAL.logger.isDebugEnabled())
        {
            SISAL.logger.debug("aggiornaDettagliSezione - sezione: " + sezione);
        }
        if (components.length > 0)
        {
            if (SISAL.logger.isDebugEnabled())
            {
                SISAL.logger.debug("aggiornaDettagliSezione - sezione piena: " + sezione);
            }
            SISAL.loadApplication(SISAL.addParameters(components, parameters));
        }
        else
        {
            if (SISAL.logger.isDebugEnabled())
            {
                SISAL.logger.debug("aggiornaDettagliSezione - sezione vuota: " + sezione);
            }
        }
        
        if (SISAL.logger.isInfoEnabled())
        {
            SISAL.logger.info("aggiornaDettagliSezione - fine");
        }
    }

    /**
     * La funzione effettua il caricamento progressivo dei dettagli relativi a sport ed ippica.
     * @return null
     */
    function incrementaDettagliSezione(sezione, url, startDiv, idDiv, menuDiv, parameters)
    {
        if (SISAL.logger.isInfoEnabled())
        {
            SISAL.logger.info("incrementaDettagliSezione - inizio");
        }

        var div, divSon, ajaxUrl, separator, i, sessioneValida, myComponents;
 
        // verifico validità della sessione gioco
        SISAL.ajax(sessioneAjaxUrl, {async: false, response: true, success: function (result) {
            sessioneValida = result;
        }});
        if (SISAL.logger.isDebugEnabled())
        {
            SISAL.logger.debug("incrementaDettagliSezione - sessione <" + sessioneValida + ">");
        }
        
        if (sessioneValida === "OK")
        {
            // verifico validità della sessione login
            if (SISAL.MATCHPOINT.controlloSessioneLogin({html: "La sessione di gioco è scaduta. Per continuare a giocare effettua un nuovo login."}))
            {
                // se non esiste startDiv eseguo loadDettagliSezione
                div = document.getElementById(startDiv);
                if (SISAL.isNull(div))
                {
                    SISAL.logger.info("incrementaDettagliSezione - startDiv null");
                    loadDettagliSezione(sezione, url, menuDiv, parameters);
                }
                else if (div.getElementsByTagName("div").length === 0)
                {
                    SISAL.logger.info("incrementaDettagliSezione - startDiv no child");
                    loadDettagliSezione(sezione, url, menuDiv, parameters);
                }
                else
                {
                    // aggiorno dettaglio
                    SISAL.logger.info("incrementaDettagliSezione - startDiv with child");
                    divSon = document.getElementById(idDiv);
                    if (SISAL.isNull(divSon))
                    {
                        divSon = document.createElement("div");
                        divSon.id = idDiv;
                        div.insertBefore(divSon, div.getElementsByTagName("div")[0]);
                    }
                    if (sezione === "sport" || sezione === "eventi" || sezione === "live") {
                        ajaxUrl = sportAjaxUrl;
                    }
                    if (sezione === "totocalcio") {
                        ajaxUrl = totocalcioAjaxUrl;
                    }
                    if (sezione === "totogol") {
                        ajaxUrl = totogolAjaxUrl;
                    }
                    if (sezione === "ippica") {
                        ajaxUrl = ippicaAjaxUrl;
                    }
                    if (sezione === "tris") {
                        ajaxUrl = trisAjaxUrl;
                    }
                    for (i in parameters)
                    {
                        if (parameters.hasOwnProperty(i)) {
                            separator = ajaxUrl.search("[?]") !== -1 ? "&" : "?";
                            ajaxUrl = ajaxUrl + separator + i + "=" + parameters[i];
                        }
                    }
                    SISAL.ajax(ajaxUrl, {target: idDiv, success: function () {  
                                                                                aggiornaDettagliSezione(sezione, parameters);
                                                                                // aggiorno sessione menu se presente
                                                                                if (!SISAL.isNull(menuDiv))
                                                                                {
                                                                                    SISAL.ajax(menuAjaxUrl + "elemento=" + menuDiv + "&selezione=true");
                                                                                    evidenziaMenuAttivo(menuDiv, 'color_menudin_voce2_sel');
                                                                                }
                                                                            }});
                }
            }
        }
        else
        {
            // messaggio di sessione non attiva
            sessioneInattiva();
        }
        
        if (SISAL.logger.isInfoEnabled())
        {
            SISAL.logger.info("incrementaDettagliSezione - fine");
        }
    }

    /**
     * La funzione effettua la rimozione progressiva dei dettagli relativi a sport ed ippica.
     * @return null
     */
    function decrementaDettagliSezione(sezione, url, startDiv, idDiv, menuDiv, cambiopagina, parameters)
    {
        if (SISAL.logger.isInfoEnabled())
        {
            SISAL.logger.info("decrementaDettagliSezione - inizio");
        }

        var div, ajaxUrl, separator, i, redirect = false;
 
        // se non esiste startDiv non rimuovo nulla
        div = document.getElementById(startDiv);
        if (!SISAL.isNull(div))
        {
            SISAL.logger.info("decrementaDettagliSezione - rimuovo idDiv");
            if (startDiv !== idDiv)
            {
                if (!SISAL.isNull(document.getElementById(idDiv)))
                {
                    div.removeChild(document.getElementById(idDiv));
                }
                // verifico se devo cambiare pagina
                if (div.getElementsByTagName("div").length === 0)
                {
                    redirect = cambiopagina;
                }
            }
            else
            {
                redirect = cambiopagina;
            }
        }
        if (sezione === "sport" || sezione === "eventi" || sezione === "live") {
            ajaxUrl = sportAjaxUrl;
        }
        if (sezione === "ippica") {
            ajaxUrl = ippicaAjaxUrl;
        }
        if (sezione === "tris") {
            ajaxUrl = trisAjaxUrl;
        }
        for (i in parameters)
        {
            if (parameters.hasOwnProperty(i)) {
                separator = ajaxUrl.search("[?]") !== -1 ? "&" : "?";
                ajaxUrl = ajaxUrl + separator + i + "=" + parameters[i];
            }
        }
        if (redirect && SISAL.logger.isInfoEnabled())
        {
            SISAL.logger.info("decrementaDettagliSezione - vado in " + url);
        }
        // pulizia dati sessione e cambio pagina
        SISAL.ajax(ajaxUrl, {target: idDiv, success: function () {
                                                                    if (redirect)
                                                                    {
                                                                        location.href = url;
                                                                    }
                                                                    // aggiorno sessione menu se presente
                                                                    if (!SISAL.isNull(menuDiv))
                                                                    {
                                                                        SISAL.ajax(menuAjaxUrl + "elemento=" + menuDiv + "&selezione=false");
                                                                        evidenziaMenuAttivo(menuDiv, '');
                                                                    }
                                                                }});
        
        if (SISAL.logger.isInfoEnabled())
        {
            SISAL.logger.info("decrementaDettagliSezione - fine");
        }
    }
    
    /**
     * La funzione riduce il dettaglio relativo a sport ed ippica.
     * @return null
     */
    function riduciDettagliSezione(sezione, idDiv, parameters)
    {
        if (SISAL.logger.isInfoEnabled())
        {
            SISAL.logger.info("riduciDettagliSezione - inizio");
        }

        var ajaxUrl, separator, i;
 
        // cambio display
        SISAL.FX.slideToggle(idDiv, {complete: function () {
            var el = document.getElementById("btn_riduci_dati_tb1_1_" + parameters.disciplina + "_" + parameters.manifestazione);          
            if (!SISAL.isNull(el))
            { 
                el.className = (el.className === "btn_riduci") ? "btn_espandi" : "btn_riduci";
            }
        }});
        // memorizzo display attraverso chiamata alla servlet
        if (sezione === "sport") {
            ajaxUrl = palinsestoAjaxUrl + "concessione=1";
        }
        if (sezione === "eventi") {
            ajaxUrl = palinsestoAjaxUrl + "concessione=6";
        }
        if (sezione === "live") {
            ajaxUrl = palinsestoAjaxUrl + "concessione=103";
        }
        if (sezione === "ippica") {
            ajaxUrl = palinsestoAjaxUrl + "concessione=2";
        }
        for (i in parameters)
        {
            if (parameters.hasOwnProperty(i)) {
                separator = ajaxUrl.search("[?]") !== -1 ? "&" : "?";
                ajaxUrl = ajaxUrl + separator + i + "=" + parameters[i];
            }
        }
        SISAL.ajax(ajaxUrl);
        
        if (SISAL.logger.isInfoEnabled())
        {
            SISAL.logger.info("riduciDettagliSezione - fine");
        }
    }

    /**
     * La funzione evidenzia il filtro attivo sul menu dinamico
     * @return null
     */
    function evidenziaFiltroAttivo(filtro, idfiltro, classe)
    {
        if (SISAL.logger.isInfoEnabled())
        {
            SISAL.logger.info("evidenziaFiltroAttivo - inizio");
        }

        var padre, figli, i;
        
        padre = document.getElementById(filtro);
        figli = padre.getElementsByTagName("td");
        for (i = 0; i < figli.length; i = i + 1)
        {
            if (figli[i].id !== idfiltro)
            {
                figli[i].className = "";
            }
            else
            {
                figli[i].className = classe;
            }
        }

        if (SISAL.logger.isInfoEnabled())
        {
            SISAL.logger.info("evidenziaFiltroAttivo - fine");
        }
    }

    //
    // funzioni comuni ai vari palinsesti
    /**
     * La funzione stampa il biglietto di tutte le giocate
     * @return null
     */
    function stampaBiglietto(urlstampa, widthstampa)
    {
        if (SISAL.logger.isInfoEnabled())
        {
            SISAL.logger.info("stampaBiglietto - inizio");
        }

        var sessioneValida;
        
        // verifico validità della sessione
        SISAL.ajax(sessioneAjaxUrl, {async: false, response: true, success: function (result) {
            sessioneValida = result;
        }});
        if (SISAL.logger.isDebugEnabled())
        {
            SISAL.logger.debug("stampaBiglietto - sessione <" + sessioneValida + ">");
        }
        
        if (sessioneValida === "OK")
        {
            // verifico validità della sessione login
            if (SISAL.MATCHPOINT.controlloSessioneLogin({html: "La sessione di gioco è scaduta. Per continuare a giocare effettua un nuovo login."}))
            {
                SISAL.FX.showOnElement_OverlayPopup('body', {
                    url : contesto + urlstampa,
                    width : widthstampa
                });
            }
        }
        else
        {
            // messaggio di sessione non attiva
            sessioneInattiva();
        }

        if (SISAL.logger.isInfoEnabled())
        {
            SISAL.logger.info("stampaBiglietto - fine");
        }
    }
 
    //
    // funzioni tipiche del palinsesto SPORT
    //
    /**
     * La funzione verifica la validita' della scommessa sportiva
     * @return null
     */
    function verificaScommessa(pulsante, sezione, disciplina, manifestazione, classe, filtro, quota, options)
    {
        if (SISAL.logger.isInfoEnabled())
        {
            SISAL.logger.info("verificaScommessa - inizio");
        }

        var scommessa = [], ajaxUrl, esito, i, errore, sessioneValida, myOptions,
            successFunction = function () {
                verificaScommessa(pulsante, sezione, disciplina, manifestazione, classe, filtro, quota, options);
            };
        
        if (SISAL.logger.isDebugEnabled())
        {
            SISAL.logger.debug("options " + SISAL.toStringAsLiteral(options));
        }
        
        // verifico validità della sessione
        SISAL.ajax(sessioneAjaxUrl, {async: false, response: true, success: function (result) {
            sessioneValida = result;
        }});
        if (SISAL.logger.isDebugEnabled())
        {
            SISAL.logger.debug("verificaScommessa - sessione <" + sessioneValida + ">");
        }
        
        if (sessioneValida === "OK")
        {
            // verifico validità della sessione login
            if (SISAL.MATCHPOINT.controlloSessioneLogin({html: "La sessione di gioco è scaduta. Per continuare a giocare effettua un nuovo login."}))
            {
                ajaxUrl = scommessaAjaxUrl + "concessione=1&sezione=" + sezione + "&disciplina=" + disciplina + "&manifestazione=" + manifestazione + "&quota=" + quota;
                for (i in options)
                {
                    if (options.hasOwnProperty(i)) {
                        scommessa.push(options[i]);
                        ajaxUrl = ajaxUrl + "&" + i + "=" + encodeURIComponent(options[i]);
                    }
                }
                
                SISAL.ajax(rimuoviScommesseAjaxUrl + "concessione=1", {target: "verificaScommessa1", success: function () {
                    esito = validaNuovaScommessa(scommessa, listaScommesseSport);
                    if (SISAL.logger.isDebugEnabled())
                    {
                        SISAL.logger.debug("Esito " + esito[0] + " " + esito[1]);
                    }
                    if (esito[0] >= 0)
                    {
                        SISAL.ajax(ajaxUrl, {target: "verificaScommessa2", success: function () {
                            myOptions = SISAL.copy(bigliettoSportComponents[0].options);
                            myOptions.async = false;
                            listaQuoteSport.push(quota);
                            SISAL.ajax(bigliettoSportComponents[0].url, myOptions);
                            $(".quote_sel").removeClass("quote_sel");
                            pulsante.className = pulsante.className + " quote_sel";
                        }});
                    }
                    else
                    {
                        errore = "<p>" + recuperaMessaggio(esito, {func: "validaNuovaScommessa"}) + "</p>";
                        SISAL.FX.showOnElement_TemplatePopup('body',
                                'mp.alert.buttonok.html', {
                            "TextAlign_default": "TextAlign_left",
                            "{title}" : "Biglietto Scommesse",
                            "{content}" : errore,
                            "{buttonclick}" : "<hideThis>",
                            "{buttontext}" : "OK",
                            width : '360px'
                        });
                    }
                }});
            }
        }
        else
        {
            // messaggio di sessione non attiva
            sessioneInattiva();
        }
        
        if (SISAL.logger.isInfoEnabled())
        {
            SISAL.logger.info("verificaScommessa - fine");
        }
    }

    /**
     * La funzione carica dalla sessione le scommesse
     * @return null
     */
    function caricaScommessa(quota, options)
    {
        if (SISAL.logger.isInfoEnabled())
        {
            SISAL.logger.info("caricaScommessa - inizio");
        }

        var scommessa = [], esito, i;
        
        if (SISAL.logger.isDebugEnabled())
        {
            SISAL.logger.debug("options " + SISAL.toStringAsLiteral(options));
        }
        
        for (i in options)
        {
            if (options.hasOwnProperty(i)) {
                scommessa.push(options[i]);
            }
        }
        
        esito = validaNuovaScommessa(scommessa, listaScommesseSport);
        if (esito[0] >= 0)
        {
            listaQuoteSport.push(quota);
        }

        if (SISAL.logger.isInfoEnabled())
        {
            SISAL.logger.info("caricaScommessa - fine");
        }
    }
    
    /**
     * La funzione cancella dalla sessione la scommessa
     * @return null
     */
    function cancellaScommessa(disciplina, manifestazione, palinsesto, avvenimento, classe, esito)
    {
        if (SISAL.logger.isInfoEnabled())
        {
            SISAL.logger.info("cancellaScommessa - inizio");
        }

        var scommessa, ajaxUrl, i, found = -1;
        
        ajaxUrl = scommessaAjaxUrl + "concessione=1&rimuovi=true&disciplina=" + disciplina + "&manifestazione=" + manifestazione;
        
        for (i = 0; i < listaScommesseSport.length; i = i + 1)
        {
            scommessa = listaScommesseSport[i];
            if (scommessa[0] === palinsesto && scommessa[1] === avvenimento && scommessa[2] === classe && scommessa[3] === esito)
            {
                found = i;
                break;
            }
        }
        
        if (found !== -1)
        {
            if (SISAL.logger.isDebugEnabled())
            {
                SISAL.logger.debug("cancellaScommessa - rimuovo disciplina " + disciplina + " manifestazione " + manifestazione + " " + scommessa[0] + " " + scommessa[1] + " " + scommessa[2] + " " + scommessa[3]);
            }
            listaScommesseSport.splice(found, 1);
            listaQuoteSport.splice(found, 1);
            ajaxUrl = ajaxUrl + "&palinsesto=" + scommessa[0];
            ajaxUrl = ajaxUrl + "&avvenimento=" + scommessa[1];
            ajaxUrl = ajaxUrl + "&classe=" + scommessa[2];
            ajaxUrl = ajaxUrl + "&esito=" + scommessa[3];
            SISAL.ajax(ajaxUrl, {success: function () {
                SISAL.ajax(bigliettoSportComponents[0].url, bigliettoSportComponents[0].options);
            }});
        }
        
        if (SISAL.logger.isInfoEnabled())
        {
            SISAL.logger.info("cancellaScommessa - fine");
        }
    }
    
    /**
     * La funzione cancella dalla sessione tutte le scommesse
     * @return null
     */
    function cancellaScommesse()
    {
        if (SISAL.logger.isInfoEnabled())
        {
            SISAL.logger.info("cancellaScommesse - inizio");
        }

        var scommessa, ajaxUrl, i, found = -1;
        
        ajaxUrl = rimuoviScommesseAjaxUrl + "concessione=1&cancella=true";
        SISAL.ajax(ajaxUrl, {success: function () {
            SISAL.ajax(bigliettoSportComponents[0].url, bigliettoSportComponents[0].options);
            while (listaScommesseSport.length > 0)
            {
                listaScommesseSport.pop();
            }
            while (listaQuoteSport.length > 0)
            {
                listaQuoteSport.pop();
            }
        }});
        
        if (SISAL.logger.isInfoEnabled())
        {
            SISAL.logger.info("cancellaScommesse - fine");
        }
    }
    
    /**
     * La funzione imposta il valore della giocata in entrata del biglietto
     * @return null
     */
    function impostaGiocata(giocata, valore)
    {
        if (valore === "0")
        {
            document.getElementById(giocata).value = "";
        }
        else
        {
            document.getElementById(giocata).value = valore;
        }
    }

    /**
     * La funzione calcola la quota da applicare all'importo per ottenere la vincita
     * @return null
     */
    function calcolaQuota(quota)
    {
        if (SISAL.logger.isInfoEnabled())
        {
            SISAL.logger.info("calcolaQuota - inizio");
        }

        var idquota, nAvvenimenti = listaQuoteSport.length, quotaTot = 1, i;
        
        idquota = document.getElementById(quota);
        if (!SISAL.isNull(idquota))
        { 
            quotaTot = moltiplicatoreSport(listaQuoteSport);
            
            if (SISAL.logger.isDebugEnabled())
            {
                SISAL.logger.debug("calcolaQuota - quota " + quotaTot);
            }
            idquota.innerHTML = 'x ' + numberToValuta(quotaTot);
        }
            
        if (SISAL.logger.isInfoEnabled())
        {
            SISAL.logger.info("calcolaQuota - fine");
        }
    }
    
    /**
     * La funzione verifica l'inserimento di soli decimali
     * @return null
     */
    function checkImporto(e)
    {
        /*
        var filtro;
        
        filtro = new RegExp("[^0-9.]");
        document.getElementById(giocata).value = document.getElementById(giocata).value.replace(filtro, "");
        */
        return SISAL.matchRegExp(e, new RegExp("[0-9]"));
    }
    
    /**
     * La funzione verifica l'inserimento di soli decimali
     * @return null
     */
    function checkImportoDecimal(obj, e)
    {
        var
            esito1 = false,
            esito2 = true,
            posVirgola,
            objText = obj.value,
            key = window.event ? e.keyCode : e.which
            ;
            
        esito1 = SISAL.matchRegExp(e, new RegExp("[0-9,]"));

        posVirgola = objText.indexOf(",");
        if (key === 44 && ((objText.length - (objText.replace(/,/gi, '')).length) >= 1 || objText.length === 0))
        {
            esito2 = false;
        }
        if (key >= 48 && key <= 57 && objText.length > 3 && posVirgola >= 0 && posVirgola < 2)
        {
            esito2 = false;
        }
        
        return (esito1 && esito2);
    }
  
    /**
     * La funzione determina la vincita che si otterrebbe scommettendo
     * @return null
     */
    function determinaVincita(giocata, vincita)
    {
        if (SISAL.logger.isInfoEnabled())
        {
            SISAL.logger.info("determinaVincita - inizio");
        }

        var idgiocata, idvincita, bonusVal = 0, vincitaVal = 0, filtro; 
        
        //filtro = new RegExp("[^0-9.]");
        idgiocata = document.getElementById(giocata);
        idvincita = document.getElementById(vincita);
        //idgiocata.value.replace(filtro, "");
        
        if (!SISAL.isNull(idgiocata) && !SISAL.isNull(idvincita))
        {
            if (idgiocata.value !== "" && idgiocata.value !== "0")
            {
                bonusVal = bonus(listaQuoteSport.length);                    
                vincitaVal = importoVincita(listaQuoteSport, idgiocata.value * 100);
                if (SISAL.logger.isDebugEnabled())
                {
                    SISAL.logger.debug("determinaVincita - vincita " + vincitaVal);
                }                
                idvincita.innerHTML = '&euro; ' + numberToValuta(vincitaVal / 100);
            }
            else
            {
                idvincita.innerHTML = '';
            }
        }

        if (SISAL.logger.isInfoEnabled())
        {
            SISAL.logger.info("determinaVincita - fine");
        }
    }
    
    /**
     * La funzione memorizza in sessione importo, bonus, vincita
     * @return null
     */
    function calcolaVincita(giocata, vincita)
    {
        if (SISAL.logger.isInfoEnabled())
        {
            SISAL.logger.info("calcolaVincita - inizio");
        }

        var idgiocata, idvincita, ajaxUrl, bonusVal = 0, vincitaVal = 0;
        
        idgiocata = document.getElementById(giocata);
        idvincita = document.getElementById(vincita);
        
        if (!SISAL.isNull(idgiocata) && !SISAL.isNull(idvincita))
        {
            if (idgiocata.value !== "" && idgiocata.value !== "0")
            {
                bonusVal = bonus(listaQuoteSport.length);                    
                vincitaVal = importoVincita(listaQuoteSport, idgiocata.value * 100);
                if (SISAL.logger.isDebugEnabled())
                {
                    SISAL.logger.debug("calcolaVincita - vincita " + vincitaVal);
                }                
                ajaxUrl = scommessaAjaxUrl + "concessione=1&importo=" + (idgiocata.value * 100) + "&bonus=" + bonusVal + "&vincita=" + vincitaVal;
                SISAL.ajax(ajaxUrl);
            }
            else
            {
                vincitaVal = 0;
            }
            idvincita.innerHTML = '&euro; ' + numberToValuta(vincitaVal / 100);
        }

        if (SISAL.logger.isInfoEnabled())
        {
            SISAL.logger.info("calcolaVincita - fine");
        }
    }
    
    /**
     * La funzione verifica che sia corretta la giocata e quindi gioca
     * @return null
     */
    function giocaScommesse(giocata, vincita, minimoscommessa, moltiplicatore)
    {
        if (SISAL.logger.isInfoEnabled())
        {
            SISAL.logger.info("giocaScommesse - inizio");
        }

        var idgiocata, idvincita, cookie_login, giocataVal, esito, ajaxUrl, errore, sessioneValida, optionsBiglietto;
        
        idgiocata = document.getElementById(giocata);
        idvincita = document.getElementById(vincita);
        
        if (!SISAL.isNull(idgiocata) && !SISAL.isNull(idvincita))
        {
            // verifico validità della sessione
            SISAL.ajax(sessioneAjaxUrl, {async: false, response: true, success: function (result) {
                sessioneValida = result;
            }});
            if (SISAL.logger.isDebugEnabled())
            {
                SISAL.logger.debug("giocaScommesse - sessione <" + sessioneValida + ">");
            }
            
            if (sessioneValida === "OK")
            {
                // verifico validità della sessione login
                if (SISAL.MATCHPOINT.controlloSessioneLogin({html: "La sessione di gioco è scaduta. Per continuare a giocare effettua un nuovo login.", http: true}))
                {
                    // controllo importo da giocare
                    if (idgiocata.value === "" || idgiocata.value === "0")
                    {
                        errore = "<p>" + recuperaMessaggio([-12, "Inserire l'importo da scommettere."], {func: "GIOCATASPORT"}) + "</p>";
                        SISAL.FX.showOnElement_TemplatePopup('body',
                                'mp.alert.buttonok.html', {
                            "TextAlign_default": "TextAlign_left",
                            "{title}" : "Biglietto Scommesse",
                            "{content}" : errore,
                            "{buttonclick}" : "<hideThis>",
                            "{buttontext}" : "OK",
                            width : '360px'
                        });
                        return;
                    }
                    
                    // controllo validitità biglietto
                    giocataVal = idgiocata.value * 100;
                    esito = validaBiglietto(listaScommesseSport, giocataVal, minimoscommessa, moltiplicatore);
                    if (esito[0] === 0)
                    {
                        // popup con clessidra per "giocata in corso...."
                        SISAL.FX.showOnElement_TemplatePopup('body',
                                'mp.loading.html', {
                                "{content}" : "Scommessa in corso...",
                                width : '360px'
                            });
                        
                        // chiamo servizio per effettuare la giocata
                        ajaxUrl = giocataAjaxUrl + "concessione=1";
                        SISAL.ajax(ajaxUrl, {success: function () {
                            optionsBiglietto = SISAL.copy(bigliettoSportComponents[0].options);
                            optionsBiglietto.success = function () {
                                SISAL.ajax('/LoginNuovo/pubblico/servlet/saldo', {success: function () {
                                    var saldo = SISAL.getCookieField("saldo", "saldoDisponibile"),
                                        bonus = SISAL.getCookieField("saldo", "bonus"),
                                        borsino = SISAL.getCookie("borsini");
                                    saldo = isNaN(saldo) ? "" : numberToValuta(saldo / 100);
                                    $('#saldoDisponibile').html("&euro; " + saldo);
                                    $('#logoutSaldo').html(saldo + " &euro;");
                                    bonus = isNaN(bonus) ? "" : numberToValuta(bonus / 100);
                                    if (!SISAL.isNull(borsino))
                                    {
                                        borsino = borsino.match(new RegExp(".*\\D+" + 1 + "\\D*,\\D*(\\d+)\\D+.*"));
                                        borsino = (SISAL.isNull(borsino) ? borsino : borsino[1]);
                                        borsino = isNaN(borsino) ? "" : numberToValuta(borsino / 100);
                                    }
                                    $('#bonusScommesse').html("&euro; " + borsino);
                                    $('#logoutBonus').html(bonus + " &euro;");
                                } });
                            };
                            SISAL.ajax(bigliettoSportComponents[0].url + "?biglietto=ok", optionsBiglietto);
                        }});                    
                    }
                    else
                    {
                        errore = "<p>" + recuperaMessaggio(esito, {func: "validaBiglietto"}) + "</p>";
                        SISAL.FX.showOnElement_TemplatePopup('body',
                                'mp.alert.buttonok.html', {
                            "TextAlign_default": "TextAlign_left",
                            "{title}" : "Biglietto Scommesse",
                            "{content}" : errore,
                            "{buttonclick}" : "<hideThis>",
                            "{buttontext}" : "OK",
                            width : '360px'
                        });
                    }
                }
            }
            else
            {
                // messaggio di sessione non attiva
                sessioneInattiva();
            }
        }

        if (SISAL.logger.isInfoEnabled())
        {
            SISAL.logger.info("giocaScommesse - fine");
        }
    }

    /**
     * La funzione verifica che sia corretta la giocata e quindi gioca
     * @return null
     */
    function mostraStatistiche(palinsesto, avvenimento)
    {
        if (SISAL.logger.isInfoEnabled())
        {
            SISAL.logger.info("giocaScommesse - inizio");
        }
        
        var statUrl = "https://www.stats.betradar.com/statistics/matchpoint/?clientmatchid=" + palinsesto + "-" + avvenimento + "&treemenu=false";

        SISAL.FX.open({
            url : statUrl,
            name : avvenimento + palinsesto,
            height : 640,
            width : 800,
            centered : true
        });

        if (SISAL.logger.isInfoEnabled())
        {
            SISAL.logger.info("giocaScommesse - fine");
        }
    }
    
    //
    // funzioni tipiche del sistema SPORT
    //
    /**
     * La funzione disabilita la giocata a sistema
     * @return null
     */
    function disabilitaSistema()
    {
        var i, ajaxUrl;
        
        if (SISAL.logger.isInfoEnabled())
        {
            SISAL.logger.info("disabilitaSistema - inizio");
        }

        // registro scommessa sport
        ajaxUrl = scommessaAjaxUrl + "concessione=600&erase=true";
        SISAL.ajax(ajaxUrl, {success: function () {
            // pulisco sistema sport
            SISAL.unloadComponents(sistemaSportComponents);
            // pulisco calcolo sistema sport
            SISAL.unloadComponents(sistemaSportCalcoloComponents);
            // tolgo popup
            SISAL.FX.hideOnElement_OverlayPopup(bigliettoSportComponents[0].options.target);
            // tolgo hide
            for (i = 0; i < sistemaSportNoComponents.length; i = i + 1)
            {
                if (!SISAL.isNull(document.getElementById(sistemaSportNoComponents[i])))
                {
                    SISAL.FX.hideOnElement_Overlay(sistemaSportNoComponents[i]);
                }
            }
            // mostro schedina sport
            SISAL.switchDisplay(sportComponents[0].options.target);
        }});
        
        if (SISAL.logger.isInfoEnabled())
        {
            SISAL.logger.info("disabilitaSistema - fine");
        }
    }
    
    /**
     * La funzione riabilita la schedina dopo una giocata sistema ok
     * @return null
     */
    function riabilitaSistema()
    {
        var i, ajaxUrl;
        
        if (SISAL.logger.isInfoEnabled())
        {
            SISAL.logger.info("riabilitaSistema - inizio");
        }

        // tolgo popup
        SISAL.FX.hideOnElement_OverlayPopup(sistemaSportComponents[0].options.target);
        SISAL.FX.hideOnElement_Overlay(sistemaSportCalcoloComponents[0].options.target);
        // pulisco sistema sport
        SISAL.unloadComponents(sistemaSportComponents);
        // pulisco calcolo sistema sport
        SISAL.unloadComponents(sistemaSportCalcoloComponents);
        // tolgo hide
        for (i = 0; i < sistemaSportNoComponents.length; i = i + 1)
        {
            if (!SISAL.isNull(document.getElementById(sistemaSportNoComponents[i])))
            {
                SISAL.FX.hideOnElement_Overlay(sistemaSportNoComponents[i]);
            }
        }
        // mostro schedina sport
        SISAL.switchDisplay(sportComponents[0].options.target);
        
        if (SISAL.logger.isInfoEnabled())
        {
            SISAL.logger.info("riabilitaSistema - fine");
        }
    }
    
    /**
     * La funzione abilita la giocata a sistema
     * @return null
     */
    function abilitaSistema()
    {
        var i, ajaxUrl, sessioneValida;
        
        if (SISAL.logger.isInfoEnabled())
        {
            SISAL.logger.info("abilitaSistema - inizio");
        }

        // verifico validità della sessione
        SISAL.ajax(sessioneAjaxUrl, {async: false, response: true, success: function (result) {
            sessioneValida = result;
        }});
        if (SISAL.logger.isDebugEnabled())
        {
            SISAL.logger.debug("abilitaSistema - sessione <" + sessioneValida + ">");
        }
        
        if (sessioneValida === "OK")
        {
            // verifico validità della sessione login
            if (SISAL.MATCHPOINT.controlloSessioneLogin({html: "La sessione di gioco è scaduta. Per continuare a giocare effettua un nuovo login."}))
            {
                // registro scommessa a sistema
                ajaxUrl = scommessaAjaxUrl + "concessione=600";
                SISAL.ajax(ajaxUrl, {success: function () {
                    // abilito pulsante di ritorno alla schedina
                    SISAL.FX.showOnElement_OverlayPopup(bigliettoSportComponents[0].options.target, {width: 180, html: '<div  class="buttonRitornaScedina" onclick="SISAL.MATCHPOINT.PALINSESTO.disabilitaSistema();"><div style="height:8px"> </div>TORNA ALLA SCHEDINA</div>'});
                    // metto hide
                    for (i = 0; i < sistemaSportNoComponents.length; i = i + 1)
                    {
                        if (!SISAL.isNull(document.getElementById(sistemaSportNoComponents[i])))
                        {
                            SISAL.FX.showOnElement_Overlay(sistemaSportNoComponents[i]);
                        }
                    }
                    // nascondo schedina sport
                    SISAL.switchDisplay(sportComponents[0].options.target);
                    // carico sistema sport
                    SISAL.ajax(sistemaSportComponents[0].url, sistemaSportComponents[0].options);
                }});
            }
        }
        else
        {
            // messaggio di sessione non attiva
            sessioneInattiva();
        }
        
        if (SISAL.logger.isInfoEnabled())
        {
            SISAL.logger.info("abilitaSistema - fine");
        }
    }

    /**
     * La funzione aggiorna il sistema pulendo il div con i calcoli del sistema
     * @return null
     */
    function aggiornaSistema()
    {
        var ajaxUrl, sessioneValida;
        
        if (SISAL.logger.isInfoEnabled())
        {
            SISAL.logger.info("aggiornaSistema - inizio");
        }

        // verifico validità della sessione
        SISAL.ajax(sessioneAjaxUrl, {async: false, response: true, success: function (result) {
            sessioneValida = result;
        }});
        if (SISAL.logger.isDebugEnabled())
        {
            SISAL.logger.debug("aggiornaSistema - sessione <" + sessioneValida + ">");
        }
        
        if (sessioneValida === "OK")
        {
            // verifico validità della sessione login
            if (SISAL.MATCHPOINT.controlloSessioneLogin({html: "La sessione di gioco è scaduta. Per continuare a giocare effettua un nuovo login."}))
            {
                // pulisco la lista delle combinazioni valide
                ajaxUrl = rimuoviScommesseAjaxUrl + "concessione=600";
                SISAL.ajax(ajaxUrl, {success: function () {
                    // pulisco calcolo sistema sport
                    SISAL.unloadComponents(sistemaSportCalcoloComponents);
                    // ricarico sistema sport
                    SISAL.ajax(sistemaSportComponents[0].url, sistemaSportComponents[0].options);
                }});
            }
        }
        else
        {
            // messaggio di sessione non attiva
            sessioneInattiva();
        }
        
        if (SISAL.logger.isInfoEnabled())
        {
            SISAL.logger.info("aggiornaSistema - fine");
        }
    }

    /**
     * La funzione esegue i calcoli per la giocata a sistema
     * @return null
     */
    function calcolaSistema(numScommesse, maxFisse)
    {
        var i, ajaxUrl, sessioneValida, cookie_login, numFisse =  0, fisse = "", errore;
        
        if (SISAL.logger.isInfoEnabled())
        {
            SISAL.logger.info("calcolaSistema - inizio");
        }

        // verifico validità della sessione
        SISAL.ajax(sessioneAjaxUrl, {async: false, response: true, success: function (result) {
            sessioneValida = result;
        }});
        if (SISAL.logger.isDebugEnabled())
        {
            SISAL.logger.debug("calcolaSistema - sessione <" + sessioneValida + ">");
        }
        
        if (sessioneValida === "OK")
        {                    
            // verifico validità della sessione login
            if (SISAL.MATCHPOINT.controlloSessioneLogin({html: "La sessione di gioco è scaduta. Per continuare a giocare effettua un nuovo login.", http: true}))
            {
                // controllo che non siano selezionate tutte le scommesse come fissa
                // e compongo parametro per memorizzarle in sessione
                for (i = 0; i < numScommesse; i = i + 1)
                {
                    if (document.getElementById("fissa_" + i).checked === true)
                    {
                        numFisse = numFisse + 1;
                        fisse = fisse + "&fissa=" + document.getElementById("fissa_" + i).value;
                    }
                }
                if (numFisse <= maxFisse)
                {
                    // popup con clessidra per "giocata in corso...."
                    SISAL.FX.showOnElement_TemplatePopup('body',
                            'mp.loading.html', {
                            "{content}" : "Calcolo sistema in corso...",
                            width : '360px'
                        });
        
                    // eseguo simulazione giocata per ottenere la lista delle combinazioni valide
                    ajaxUrl = giocataAjaxUrl + "concessione=600&simula=true" + fisse;
                    SISAL.ajax(ajaxUrl, {success: function () {
                        // carico calcolo sistema sport
                        SISAL.ajax(sistemaSportCalcoloComponents[0].url + "?biglietto=ok", sistemaSportCalcoloComponents[0].options);
                    }});
                }
                else
                {
                    errore = "<p>" + recuperaMessaggio([-17, "Il numero delle fisse non può essere superiore a " + maxFisse + ".", maxFisse], {func: "CALCOLOSISTEMA"}) + "</p>";
                    SISAL.FX.showOnElement_TemplatePopup('body',
                            'mp.alert.buttonok.html', {
                        "TextAlign_default": "TextAlign_left",
                        "{title}" : "Sistema Scommesse",
                        "{content}" : errore,
                        "{buttonclick}" : "<hideThis>",
                        "{buttontext}" : "OK",
                        width : '360px'
                    });
                }
            }
        }
        else
        {
            // messaggio di sessione non attiva
            sessioneInattiva();
        }
        
        if (SISAL.logger.isInfoEnabled())
        {
            SISAL.logger.info("calcolaSistema - fine");
        }
    }

    //
    // funzioni tipiche del palinsesto TOTOCALCIO
    //
    /**
     * La funzione esegue i calcoli sulla schedina richiamata ad ogni click del mouse su i segni 1X2 e sul IL9 della schedina
     * da questa funzione viene controllato anche l'abilitazione del bottone INSERICI che si attiva solo se si gioca minimo una doppia
     * @return boolean
     */
    function calcolaCombinazioniTcal(numeroAree, numeroPartite, costoComb, costoComb9)
    {
        if (SISAL.logger.isDebugEnabled())
        {
            SISAL.logger.debug("calcolaCombinazioniTcal - inizio");
        }
                  
        var a, p, abilita9, combArea14, combArea9, totPron, totComb14 = 0, totComb9 = 0, costoTotale14 = 0, costoTotale9 = 0, costoTotale, costoArea14, costoArea9, errore;

        for (a = 0; a < numeroAree; a = a + 1) 
        {
            abilita9 = document.getElementById("abilita9_" + a).checked;
            combArea14 = 1;
            combArea9 = 1;  
            for (p = 1; p < numeroPartite; p = p + 1)
            {
                totPron = document.getElementById("pronostici_" + a + "_" + p + "_1").checked ? 1 : 0;
                totPron += document.getElementById("pronostici_" + a + "_" + p + "_X").checked ? 1 : 0;
                totPron += document.getElementById("pronostici_" + a + "_" + p + "_2").checked ? 1 : 0;
                if (totPron === 0)
                {
                    combArea14 = 0;
                    break;
                }
                combArea14 *= totPron;
                if (abilita9 && p <= 9)
                {
                    combArea9 *= totPron;
                }
            }
                   
            document.getElementById("itm_num_combinaz_" + a).innerHTML = combArea14;
            costoArea14 = (combArea14 * costoComb) / 100;         
            document.getElementById("itm_importo_" + a).innerHTML = numberToValuta(costoArea14);

            if (!abilita9 || combArea14 === 0)
            {
                combArea9 = 0;
            }
            document.getElementById("itm_num_combinaz9_" + a).innerHTML = combArea9;
            costoArea9 = (combArea9 * costoComb9) / 100;
            document.getElementById("itm_importo9_" + a).innerHTML = numberToValuta(costoArea9);

            costoTotale14 = costoTotale14 + costoArea14;
            costoTotale9  = costoTotale9 + costoArea9;

            document.getElementById("itm_importo_tot_" + a).innerHTML = numberToValuta((costoArea9 + costoArea14));
           
            totComb14 = totComb14 + combArea14;
            if (abilita9)
            {
                totComb9 = totComb9 + combArea9;
            }
        }
       
        document.getElementById("itm_num_combinaz").innerHTML = totComb14;
        document.getElementById("num_combinaz").value = totComb14;
        document.getElementById("itm_num_combinaz9").innerHTML = totComb9;
        document.getElementById("num_combinaz9").value = totComb9;
        document.getElementById("itm_num_combinaz_tot").innerHTML = totComb14 + totComb9;
        document.getElementById("num_combina_tot").value = totComb14 + totComb9;
           
        costoTotale = costoTotale14 + costoTotale9;                                                      
        document.getElementById("itm_importo").innerHTML = numberToValuta(costoTotale14);
        document.getElementById("importo").value = numberToValuta(costoTotale14);
        document.getElementById("itm_importo9").innerHTML = numberToValuta(costoTotale9);
        document.getElementById("importo9").value = numberToValuta(costoTotale9);
        document.getElementById("itm_importo_tot").innerHTML = numberToValuta(costoTotale);
        document.getElementById("combina_tot").value = numberToValuta(costoTotale);
        
        if (totComb14 <= 8192 && totComb9 <= 8192)
        {
            if (totComb14 < 2)
            {
                document.getElementById("divBtnScommetti").style.visibility = "hidden";
            }
            else
            {
                document.getElementById("divBtnScommetti").style.visibility = "visible";
            }
        }
        else
        {
            document.getElementById("divBtnScommetti").style.visibility = "hidden";
            errore = "<p>" + recuperaMessaggio([-22, "Superato il numero massimo di colonne!"], {func: "GIOCATATOTOCALCIO"}) + "</p>";
            SISAL.FX.showOnElement_TemplatePopup('body',
                    'mp.alert.buttonok.html', {
                "TextAlign_default": "TextAlign_left",
                "{title}" : "Biglietto Totocalcio",
                "{content}" : errore,
                "{buttonclick}" : "<hideThis>",
                "{buttontext}" : "OK",
                width : '360px'
            });
        }
         
        if (SISAL.logger.isDebugEnabled())
        {
            SISAL.logger.debug("calcolaCombinazioniTcal - fine");
        }
    }

    /**
     * La funzione cambia la classe dell'elemento cliccato e richiama la funzione precedente
     * @return null
     */
    function cambioClasseTcal(element_id, numeroAree, numeroPartite, costoComb, costoComb9)
    {
        if (SISAL.logger.isDebugEnabled())
        {
            SISAL.logger.debug("cambioClasseTcal - inizio");
        }

        if (document.getElementById("checkInput_" + element_id).className === "checkFalse")
        {
            document.getElementById("checkInput_" + element_id).className = "checkTrue";
            document.getElementById("pronostici_" + element_id).checked = true;
        }
        else
        {
            document.getElementById("checkInput_" + element_id).className = "checkFalse";
            document.getElementById("pronostici_" + element_id).checked = false;

        }
        calcolaCombinazioniTcal(numeroAree, numeroPartite, costoComb, costoComb9);

        if (SISAL.logger.isDebugEnabled())
        {
            SISAL.logger.debug("cambioClasseTcal - fine");
        }
    }
    
    /**
     * La funzione pulisce l'area del totocalcio passata come parametro
     * @return null
     */
    function pulisciAreaTcal(idArea, numeroAree, numeroPartite, costoComb, costoComb9)
    {
        if (SISAL.logger.isInfoEnabled())
        {
            SISAL.logger.info("pulisciAreaTcal - inizio");
        }
        
        var p, element;
        
        for (p = 1; p < numeroPartite; p = p + 1)
        {
            document.getElementById("pronostici_" + idArea + "_" + p + "_1").checked = false;
            document.getElementById("checkInput_" + idArea + "_" + p + "_1").className = "checkFalse";
            document.getElementById("pronostici_" + idArea + "_" + p + "_X").checked = false;
            document.getElementById("checkInput_" + idArea + "_" + p + "_X").className = "checkFalse";
            document.getElementById("pronostici_" + idArea + "_" + p + "_2").checked = false;
            document.getElementById("checkInput_" + idArea + "_" + p + "_2").className = "checkFalse";                                                                                            
        }
        document.getElementById("abilita9_" + idArea).checked = false;

        calcolaCombinazioniTcal(numeroAree, numeroPartite, costoComb, costoComb9);
        
        if (SISAL.logger.isInfoEnabled())
        {
            SISAL.logger.info("pulisciAreaTcal - fine");
        }
    }

    /**
     * La funzione verifica che le Aree di gioco della schedina siano compilate in modo corretto.
     * @return boolean
     */
    function controllaAreeTcal(numeroAree, numeroPartite)
    {
        if (SISAL.logger.isInfoEnabled())
        {
            SISAL.logger.info("controllaAreeTcal - inizio");
        }
        
        var isAreaVuota  = false, found = false, a, p, totPron, errore;
        
        for (a = 0; a < numeroAree; a = a + 1) 
        {
            found = false;
            for (p = 1; p < numeroPartite; p = p + 1)
            {
                totPron = ((document.getElementById("pronostici_" + a + "_" + p + "_1").checked) ? 1 : 0) +
                          ((document.getElementById("pronostici_" + a + "_" + p + "_X").checked) ? 1 : 0) +
                          ((document.getElementById("pronostici_" + a + "_" + p + "_2").checked) ? 1 : 0);
                          
                if (found) 
                {
                    if (isAreaVuota)
                    {
                        errore = "<p>" + recuperaMessaggio([-13, "L'area " + String.fromCharCode(65 + a - 1) + " non è completa.", String.fromCharCode(65 + a - 1)], {func: "GIOCATATOTOCALCIO"}) + "</p>";
                        SISAL.FX.showOnElement_TemplatePopup('body',
                                'mp.alert.buttonok.html', {
                            "TextAlign_default": "TextAlign_left",
                            "{title}" : "Biglietto Totocalcio",
                            "{content}" : errore,
                            "{buttonclick}" : "<hideThis>",
                            "{buttontext}" : "OK",
                            width : '360px'
                        });
                        return false;
                    }                   
                    isAreaVuota = false;
                    if (totPron === 0) 
                    {
                        errore = "<p>" + recuperaMessaggio([-13, "L'area " + String.fromCharCode(65 + a) + " non è completa.", String.fromCharCode(65 + a)], {func: "GIOCATATOTOCALCIO"}) + "</p>";
                        SISAL.FX.showOnElement_TemplatePopup('body',
                                'mp.alert.buttonok.html', {
                            "TextAlign_default": "TextAlign_left",
                            "{title}" : "Biglietto Totocalcio",
                            "{content}" : errore,
                            "{buttonclick}" : "<hideThis>",
                            "{buttontext}" : "OK",
                            width : '360px'
                        });
                        return false;
                    }
                }
                else
                {
                    if (totPron > 0)
                    {
                        if (p > 1)
                        {
                            errore = "<p>" + recuperaMessaggio([-13, "L'area " + String.fromCharCode(65 + a) + " non è completa.", String.fromCharCode(65 + a)], {func: "GIOCATATOTOCALCIO"}) + "</p>";
                            SISAL.FX.showOnElement_TemplatePopup('body',
                                    'mp.alert.buttonok.html', {
                                "TextAlign_default": "TextAlign_left",
                                "{title}" : "Biglietto Totocalcio",
                                "{content}" : errore,
                                "{buttonclick}" : "<hideThis>",
                                "{buttontext}" : "OK",
                                width : '360px'
                            });
                            return false;
                        }
                        else
                        {
                            found = true;
                        }
                    }
                }
            }
            isAreaVuota  = !found;
        }
        
        if (SISAL.logger.isInfoEnabled())
        {
            SISAL.logger.info("controllaAreeTcal - fine");
        }
        
        return true;
    }
    
    function pronosticoGiocatoTcal(pGiocata, numeroAree, numeroPartite, costoComb, costoComb9, anno, conc)
    {        
        var col_array = pGiocata.split(";"), part_num = 0, verificaArray, test;
        
        verificaArray = col_array.pop();
        test = verificaArray.split("-");
        if ((test[0] === anno + "") && (test[1] === conc + ""))
        { 
            while (part_num < col_array.length)
            {
                if (col_array[part_num] !== "abilita9_0" && col_array[part_num] !== "abilita9_1" && col_array[part_num] !== "abilita9_2" && col_array[part_num] !== "abilita9_3")
                {
                    cambioClasseTcal(col_array[part_num], numeroAree, numeroPartite, costoComb, costoComb9);
                }
                else
                {
                    document.getElementById(col_array[part_num]).checked = true;
                }
                part_num += 1;
            }
        }    
    }
    
    function giocateFatteTcal(numeroAree, numeroPartite, anno, conc)
    {
        var giocate = "", a, p;
        
        for (a = 0; a < numeroAree; a = a + 1) {

            for (p = 1; p < numeroPartite; p = p + 1) {

                if (document.getElementById("pronostici_" + a + "_" + p + "_1").checked === true)
                {
                    giocate = giocate + a + "_" + p + "_1;";
                }
                if (document.getElementById("pronostici_" + a + "_" + p + "_X").checked === true)
                {
                    giocate = giocate + a + "_" + p + "_X;";
                }
                if (document.getElementById("pronostici_" + a + "_" + p + "_2").checked === true)
                {
                    giocate = giocate + a + "_" + p + "_2;";
                }
            }
            if (document.getElementById("abilita9_" + a).checked === true)
            {
                giocate = giocate + "abilita9_" + a + ";";
            }
        }
        giocate = giocate + anno + "-" + conc;
        return giocate;
    }

    /**
     * La funzione, se la schedina è compilata in modo corretto, memorizza la
     * giocata
     * 
     * @return null
     */
    function verificaSchedinaTcal(numeroAree, numeroPartite)
    {
        if (SISAL.logger.isInfoEnabled())
        {
            SISAL.logger.info("verificaSchedinaTcal - inizio");
        }
        
        var xmlComodo = "", i, z, ajaxUrl, pronosticoGiocato;
        
        if (controllaAreeTcal(numeroAree, numeroPartite))
        {
            xmlComodo = "<?xml version=\"1.0\" encoding=\"UTF-8\"?>";
            xmlComodo = xmlComodo + "<palinsesto>";
            xmlComodo = xmlComodo + "<cps tipo=\"1\" conc=\"" + document.getElementById("conc").value + "\">";
            xmlComodo = xmlComodo + "<descrizione>Totocalcio<\/descrizione>";
            xmlComodo = xmlComodo + "<concorso anno=\"" + document.getElementById("anno").value + "\" cod=\"" + document.getElementById("concorso").value + "\"  stato=\"" + document.getElementById("statoconc").value + "\">";
            xmlComodo = xmlComodo + "<pronostico chek=\"true\">";
            for (i = 1; i < numeroPartite; i = i + 1)
            { 
                xmlComodo = xmlComodo + "<partita num=\"" + document.getElementById("numero_" + i).value + "\" stato=\"" + document.getElementById("stato_p").value + "\" segno=\"\" ris=\"\">";
                xmlComodo = xmlComodo + "<descrizione>\"" + document.getElementById("partita_" + i).value + "\"<\/descrizione>";
                xmlComodo = xmlComodo + "<area>";
                for (z = 0; z < numeroAree; z = z + 1)
                {    
                    if (z === 0)
                    {
                        xmlComodo = xmlComodo + "<A segno1=\"" + document.getElementById("pronostici_" + z + "_" + i + "_1").checked + "\" segnoX=\"" + document.getElementById("pronostici_" + z + "_" + i + "_X").checked + "\" segno2=\"" + document.getElementById("pronostici_" + z + "_" + i + "_2").checked + "\"/>";
                    }
                    else if (z === 1)
                    {
                        xmlComodo = xmlComodo + "<B segno1=\"" + document.getElementById("pronostici_" + z + "_" + i + "_1").checked + "\" segnoX=\"" + document.getElementById("pronostici_" + z + "_" + i + "_X").checked + "\" segno2=\"" + document.getElementById("pronostici_" + z + "_" + i + "_2").checked + "\"/>";
                    }
                    else if (z === 2) 
                    {
                        xmlComodo = xmlComodo + "<C segno1=\"" + document.getElementById("pronostici_" + z + "_" + i + "_1").checked + "\" segnoX=\"" + document.getElementById("pronostici_" + z + "_" + i + "_X").checked + "\" segno2=\"" + document.getElementById("pronostici_" + z + "_" + i + "_2").checked + "\"/>";
                    } 
                    else if (z === 3)
                    {
                        xmlComodo = xmlComodo + "<D segno1=\"" + document.getElementById("pronostici_" + z + "_" + i + "_1").checked + "\" segnoX=\"" + document.getElementById("pronostici_" + z + "_" + i + "_X").checked + "\" segno2=\"" + document.getElementById("pronostici_" + z + "_" + i + "_2").checked + "\"/>";
                    }
                }
                xmlComodo = xmlComodo + "<\/area>";
                xmlComodo = xmlComodo + "<\/partita>";
            }
            xmlComodo = xmlComodo + "<flagIL9 areaA=\"" + document.getElementById("abilita9_0").checked + "\" areaB=\"" + document.getElementById("abilita9_1").checked + "\" areaC=\"" + document.getElementById("abilita9_2").checked + "\" areaD=\"" + document.getElementById("abilita9_3").checked + "\"/>";
            xmlComodo = xmlComodo + "<\/pronostico>";
            xmlComodo = xmlComodo + "<totali numeroColonne=\"" + document.getElementById("num_combinaz").value + "\" colonneIL9=\"" + document.getElementById("num_combinaz9").value + "\" colonneTotali=\"" + document.getElementById("num_combina_tot").value + "\" importoTotocalcio=\"" + document.getElementById("importo").value + "\" importoIL9=\"" + document.getElementById("importo9").value + "\" importoTotale=\"" + document.getElementById("combina_tot").value + "\"/>";
            xmlComodo = xmlComodo + "<\/concorso>";
            xmlComodo = xmlComodo + "<\/cps>";
            xmlComodo = xmlComodo + "<\/palinsesto>";  
            
            document.getElementById("txtXml").value = xmlComodo;
            pronosticoGiocato = giocateFatteTcal(numeroAree, numeroPartite, document.getElementById("anno").value, document.getElementById("concorso").value);
            ajaxUrl = scommessaAjaxUrl + "concessione=400";
            SISAL.ajax(ajaxUrl, {method: 'POST', data: 'sendXml=' + xmlComodo + '&giocataFatta=' + pronosticoGiocato, success: function () {
                SISAL.ajax(bigliettoTotocalcioComponents[0].url, bigliettoTotocalcioComponents[0].options);
            }});
        }

        if (SISAL.logger.isInfoEnabled())
        {
            SISAL.logger.info("verificaSchedinaTcal - fine");
        }
    } 
    
    /**
     * La funzione cancella dalla sessione la schedina compilata
     * @return null
     */
    function cancellaSchedinaTcal()
    {
        if (SISAL.logger.isInfoEnabled())
        {
            SISAL.logger.info("cancellaSchedinaTcal - inizio");
        }

        var ajaxUrl;
        
        ajaxUrl = scommessaAjaxUrl + "concessione=400&rimuovi=true";
        SISAL.ajax(ajaxUrl, {success: function () {
            SISAL.ajax(bigliettoTotocalcioComponents[0].url, bigliettoTotocalcioComponents[0].options);
        }});
        
        if (SISAL.logger.isInfoEnabled())
        {
            SISAL.logger.info("cancellaSchedinaTcal - fine");
        }
    }

    /**
     * La funzione gioca la schedina compilata
     * @return null
     */
    function giocaSchedinaTcal()
    {
        if (SISAL.logger.isInfoEnabled())
        {
            SISAL.logger.info("giocaSchedinaTcal - inizio");
        }

        var cookie_login, ajaxUrl, sessioneValida, optionsBiglietto;
        
        // verifico validità della sessione
        SISAL.ajax(sessioneAjaxUrl, {async: false, response: true, success: function (result) {
            sessioneValida = result;
        }});
        if (SISAL.logger.isDebugEnabled())
        {
            SISAL.logger.debug("giocaSchedinaTcal - sessione <" + sessioneValida + ">");
        }
            
        if (sessioneValida === "OK")
        {
            // verifico validità della sessione login
            if (SISAL.MATCHPOINT.controlloSessioneLogin({html: "La sessione di gioco è scaduta. Per continuare a giocare effettua un nuovo login.", http: true}))
            {
                // popup con clessidra per "giocata in corso...."
                SISAL.FX.showOnElement_TemplatePopup('body',
                        'mp.loading.html', {
                        "{content}" : "Giocata in corso...",
                        width : '360px'
                    });
                    
                // chiamo servizio per effettuare la giocata
                ajaxUrl = giocataAjaxUrl + "concessione=400";
                SISAL.ajax(ajaxUrl, {success: function () {
                    // ricarico biglietto totocalcio
                    optionsBiglietto = SISAL.copy(bigliettoTotocalcioComponents[0].options);
                    optionsBiglietto.success = function () {
                        SISAL.ajax('/LoginNuovo/pubblico/servlet/saldo', {success: function () {
                            var saldo = SISAL.getCookieField("saldo", "saldoDisponibile"),
                                bonus = SISAL.getCookieField("saldo", "bonus"),
                                borsino = SISAL.getCookie("borsini");
                            saldo = isNaN(saldo) ? "" : numberToValuta(saldo / 100);
                            $('#saldoDisponibile').html("&euro; " + saldo);
                            $('#logoutSaldo').html(saldo + " &euro;");
                            bonus = isNaN(bonus) ? "" : numberToValuta(bonus / 100);
                            if (!SISAL.isNull(borsino))
                            {
                                borsino = borsino.match(new RegExp(".*\\D+" + 5 + "\\D*,\\D*(\\d+)\\D+.*"));
                                borsino = (SISAL.isNull(borsino) ? borsino : borsino[1]);
                                borsino = isNaN(borsino) ? "" : numberToValuta(borsino / 100);
                            }
                            $('#bonusScommesse').html("&euro; " + borsino);
                            $('#logoutBonus').html(bonus + " &euro;");
                        } });
                    };
                    SISAL.ajax(bigliettoTotocalcioComponents[0].url + "?biglietto=ok", optionsBiglietto);
                }});
            }
        }
        else
        {
            // messaggio di sessione non attiva
            sessioneInattiva();
        }

        if (SISAL.logger.isInfoEnabled())
        {
            SISAL.logger.info("giocaSchedinaTcal - fine");
        }
    }
    
    //
    // funzioni tipiche del palinsesto TOTOCALCIO
    //
    /*
     * [funzione interna]
     * Algoritmo di calcolo delle combinazioni Nuovo Tgol
     */
    function AlgoritmoTgol()
    {
        // MP
        //this.a;
        this.cA = 7;
        this.n  = 0;
        this.A  = new Array(this.cA);
        this.init = function ()
        {
            var i;
            for (i = 0; i < this.cA; i = i + 1)
            {
                this.A[i] = new Array(14);
            }
        };
        this.calcola_colonne = function ()
        {
            var i, j, k, l, m, n1, n2, gA, p, b2, b3, b4, b5, b6, b7, b8, a2;
            if (this.cA === 0)
            {
                this.n = 1;
            }
            else if (this.cA === 1)
            {
                for (i = 0; i < 14; i = i + 1)
                {
                    if (this.A[0][i])
                    {
                        this.n = this.n + 1;
                    }
                }
            }
            else if (this.cA === 2)
            {
                b2 = 0;
                b3 = 0;
                b5 = 0;
                for (i = 0; i < 14; i = i + 1)
                {
                    if (this.A[0][i])
                    {
                        b2 = b2 + 1;
                        if (this.A[1][i])
                        {
                            b3 = b3 + 1;
                            b5 = b5 + 1;
                        }
                    }
                    else if (this.A[1][i]) 
                    {
                        b3 = b3 + 1;
                    }
                }
                this.n = b2 * b3 - b5;
            }
            else if (this.cA === 3)
            {
                b2 = 0;
                b3 = 0;
                b4 = 0;
                b5 = 0;
                b6 = 0;
                b7 = 0;
                b8 = 0;
                for (i = 0; i < 14; i = i + 1)
                {
                    if (this.A[0][i])
                    {
                        b2 = b2 + 1;
                        if (this.A[1][i])
                        {
                            b3 = b3 + 1;
                            b5 = b5 + 1;
                            if (this.A[2][i])
                            {
                                b4 = b4 + 1;
                                b6 = b6 + 1;
                                b7 = b7 + 1;
                                b8 = b8 + 1;
                            }
                        }
                        else if (this.A[2][i])
                        {
                            b4 = b4 + 1;
                            b6 = b6 + 1;
                        }               
                    }
                    else if (this.A[1][i])
                    {
                        b3 = b3 + 1;
                        if (this.A[2][i])
                        {
                            b4 = b4 + 1;
                            b7 = b7 + 1;
                        }
                    }
                    else if (this.A[2][i])
                    {
                        b4 = b4 + 1;
                    }   
                }
                this.n = (b2 * b3 * b4) - (b2 * b7) - (b3 * b6) - (b4 * b5) + (2 * b8);
            }
            else
            {
                n2 = [];//[this.cA+1];
                p = [];

                n2[this.cA] = 1;
                for (i = 0; i < this.cA; i = i + 1)
                {
                    gA = 0;
                    for (j = 0; j < 14; j = j + 1)
                    {
                        if (this.A[this.cA - i - 1][j])
                        {
                            gA = gA + 1;
                        }
                    }
                    n2[this.cA - i - 1] = n2[this.cA - i] * gA;
                }
                this.n = n2[0];
                for (j = 0; j < this.cA - 1; j = j + 1)
                {
                    for (k = j + 1; k < this.cA; k = k + 1)
                    {
                        for (l = 0; l < 14; l = l + 1)
                        {
                            if (this.A[j][l] && this.A[k][l])
                            {
                                a2 = new AlgoritmoTgol();
                                a2.cA = k - 1;
                                a2.init();
                                p = a2.A;
                                for (m = 0; m < 14; m = m + 1)
                                {
                                    for (n1 = 0; n1 < k - 1; n1 = n1 + 1)
                                    {
                                        if (m === l) 
                                        {
                                            p[n1][m] = false;
                                        }
                                        else if (n1 < j)
                                        {
                                            p[n1][m] = this.A[n1][m];
                                        }
                                        else
                                        {
                                            p[n1][m] = this.A[n1 + 1][m];
                                        }
                                    }
                                }
                                a2.calcola_colonne();
                                this.n = this.n - a2.n * n2[k + 1];
                            }
                        }
                    }
                }
            }
        };
    }
    
    /**
     * Funzione che esegue i calcoli sulla schedina richiamata ad ogni click del mouse su i segni corrispondenti al numero delle partite
     * da questa funzione viene controllato anche l'abilitazione del bottone INSERICI che si attiva solo se si gioca minimo una doppia
     */
    function calcolaCombinazioniTgol(numeroAree, numeroPartite, costoComb)
    {
        var a, s, p, totComb = 0, costoTotale = 0, calcola = false, combArea, pronMatrix, found, pronAvv, a1, costoArea, errore;

        for (a = 0; a < numeroAree; a = a + 1)
        {
            combArea   = 0;
            pronMatrix = [];

            for (s = 0; s < 7; s = s + 1)
            {
                found   = false;
                pronAvv = [];
                for (p = 0; p < numeroPartite; p = p + 1)
                {
                    pronAvv[p] = document.getElementById("pronostici_" + a + "_" + (p + 1) + "_" + (s + 1)).checked;
                    if (pronAvv[p])
                    {
                        found = true;
                        // pronAvv deve contenere tutte e 14 le partite
                        // break;
                    }
                }
                if (found)
                {
                    calcola = true;
                    pronMatrix[s] = pronAvv;
                }
                else
                {
                    calcola = false;
                    break;
                }
            }

            if (calcola)
            {
                // ci entro sse ho scelto 7 partite distinte nelle 7 colonne
                a1 = new AlgoritmoTgol();
                a1.cA = pronMatrix.length;
                a1.init();
                a1.A = pronMatrix;
                a1.calcola_colonne();
                combArea = a1.n;
            }

            document.getElementById("itm_num_combinaz_" + a).innerHTML = combArea;
            costoArea = (combArea * costoComb) / 100;
            document.getElementById("itm_importo_" + a).innerHTML = numberToValuta(costoArea.toFixed(2));
         
            costoTotale += costoArea;
            totComb     += combArea;
        }

        document.getElementById("itm_num_combinaz").innerHTML = totComb;
        document.getElementById("num_combinaz").value = totComb;

        document.getElementById("itm_importo").innerHTML = numberToValuta(costoTotale.toFixed(2));
        document.getElementById("importo").value = costoTotale * 100;

        if (totComb <= 16384)
        {
            document.getElementById("divBtnScommetti").style.visibility = (totComb < 2) ? "hidden" : "visible";
        }
        else
        {
            document.getElementById("divBtnScommetti").style.visibility = "hidden";
            errore = "<p>" + recuperaMessaggio([-22, "Superato il numero massimo di colonne!"], {func: "GIOCATATOTOGOL"}) + "</p>";
            SISAL.FX.showOnElement_TemplatePopup('body',
                    'mp.alert.buttonok.html', {
                "TextAlign_default": "TextAlign_left",
                "{title}" : "Biglietto Totogol",
                "{content}" : errore,
                "{buttonclick}" : "<hideThis>",
                "{buttontext}" : "OK",
                width : '360px'
            });
        }
    }
    
    /**
     * La funzione cambia la classe dell'elemento cliccato e richiama la funzione precedente
     * @return null
     */
    function cambioClasseTgol(element_id, numeroAree, numeroPartite, costoComb)
    {           
        if (SISAL.logger.isDebugEnabled())
        {
            SISAL.logger.debug("cambioClasseTgol - inizio");
        }

        if (document.getElementById("checkInput_" + element_id).className === "checkFalse")
        {
            document.getElementById("checkInput_" + element_id).className = "checkTrue";
            document.getElementById("pronostici_" + element_id).checked = true;
        }
        else
        {
            document.getElementById("checkInput_" + element_id).className = "checkFalse";
            document.getElementById("pronostici_" + element_id).checked = false;
        }
        calcolaCombinazioniTgol(numeroAree, numeroPartite, costoComb);

        if (SISAL.logger.isDebugEnabled())
        {
            SISAL.logger.debug("cambioClasseTgol - fine");
        }
    }

    /**
     * La funzione pulisce l'area del totogol passata come parametro
     * @return null
     */
    function pulisciAreaTgol(idArea, numeroAree, numeroPartite, costoComb)
    {
        if (SISAL.logger.isInfoEnabled())
        {
            SISAL.logger.info("pulisciAreaTgol - inizio");
        }
     
        var p, s;
     
        for (p = 0; p < numeroPartite; p = p + 1)
        {
            for (s = 0; s < 7; s = s + 1)
            {
                document.getElementById("pronostici_" + idArea + "_" + (p + 1) + "_" + (s + 1)).checked = false;
                document.getElementById("checkInput_" + idArea + "_" + (p + 1) + "_" + (s + 1)).className = "checkFalse";
            }
        }
        calcolaCombinazioniTgol(numeroAree, numeroPartite, costoComb);
     
        if (SISAL.logger.isInfoEnabled())
        {
            SISAL.logger.info("pulisciAreaTgol - fine");
        }                                                                                
    }

    /**
     * La funzione verifica che le Aree di gioco della schedina siano compilate in modo corretto.
     * @return boolean
     */
    function controllaAreeTgol(numeroAree, numeroPartite)
    {
        if (SISAL.logger.isInfoEnabled())
        {
            SISAL.logger.info("controllaAreeTgol - inizio");
        }
        
        var a, s, p, areaVuota, areaValida, found, combArea, errore;

        for (a = 0; a < numeroAree; a = a + 1)
        {
            areaValida = true;
            areaVuota  = true;
            for (s = 0; s < 7; s = s + 1)
            {
                found = false;
                for (p = 0; p < numeroPartite; p = p + 1)
                {
                    if (document.getElementById("pronostici_" + a + "_" + (p + 1) + "_" + (s + 1)).checked === true)
                    {
                        found = true;
                        break;
                    }
                }
                if (found || (p === numeroPartite && a < numeroAree - 1))
                {
                    areaVuota = false;
                }
                else
                {
                    areaValida = false;
                }

                if (!areaVuota && !areaValida)
                {
                    break;
                }
            }

            if (!areaValida && !areaVuota)
            {
                errore = "<p>" + recuperaMessaggio([-13, "L'area " + String.fromCharCode(65 + a) + " non è completa.", String.fromCharCode(65 + a)], {func: "GIOCATATOTOGOL"}) + "</p>";
                SISAL.FX.showOnElement_TemplatePopup('body',
                        'mp.alert.buttonok.html', {
                    "TextAlign_default": "TextAlign_left",
                    "{title}" : "Biglietto Totogol",
                    "{content}" : errore,
                    "{buttonclick}" : "<hideThis>",
                    "{buttontext}" : "OK",
                    width : '360px'
                });
                return false;
            }
            if (!areaVuota)
            {
                combArea = document.getElementById("itm_num_combinaz_" + a).innerHTML;
                if (combArea === "0")
                {
                    errore = "<p>" + recuperaMessaggio([-13, "L'area " + String.fromCharCode(65 + a) + "  non è compilata correttamente!", String.fromCharCode(65 + a)], {func: "GIOCATATOTOGOL"}) + "</p>";
                    SISAL.FX.showOnElement_TemplatePopup('body',
                            'mp.alert.buttonok.html', {
                        "TextAlign_default": "TextAlign_left",
                        "{title}" : "Biglietto Totogol",
                        "{content}" : errore,
                        "{buttonclick}" : "<hideThis>",
                        "{buttontext}" : "OK",
                        width : '360px'
                    });
                    return false;
                }
            }
        }

        if (SISAL.logger.isInfoEnabled())
        {
            SISAL.logger.info("controllaAreeTgol - fine");
        }
        return true;
    }
    
    function pronosticoGiocatoTgol(pGiocata, numeroAree, numeroPartite, costoComb, anno, conc)
    {
        var col_array = pGiocata.split(";"), part_num = 0, verificaArray, test;
        
        verificaArray = col_array.pop();
        test = verificaArray.split("-");
        
        if ((test[0] === anno + "") && (test[1] === conc + ""))
        { 
            while (part_num < col_array.length)
            {
                cambioClasseTgol(col_array[part_num], numeroAree, numeroPartite, costoComb); 
                part_num = part_num + 1;
            }
        }
    }
    
    function giocateFatteTgol(numeroAree, numeroPartite, anno, conc)
    {        
        var giocate = "", a, s, p;
        
        for (a = 0; a < numeroAree;  a = a + 1)
        {            
            for (s = 0; s < 7; s = s + 1)
            {
                for (p = 0; p < numeroPartite; p = p + 1)
                {
                    if (document.getElementById("pronostici_" + a + "_" +  (p + 1) + "_" + (s + 1)).checked === true)
                    {
                        giocate = giocate + a + "_" + (p + 1) + "_" + (s + 1) + ";";
                    }
                }
            }
        }
        giocate = giocate + anno + "-" + conc;
        return giocate;
    }
    
    /**
     * La funzione, se la schedina è compilata in modo corretto, memorizza la giocata
     * @return null
     */
    function verificaSchedinaTgol(numeroAree, numeroPartite) {
   
        if (SISAL.logger.isInfoEnabled())
        {
            SISAL.logger.info("verificaSchedinaTgol - inizio");
        }
     
        var xmlComodo = "", i, z, s, ajaxUrl, optionsBiglietto, primo, found, pronosticoGiocato;
         
        if (controllaAreeTgol(numeroAree, numeroPartite))
        {
            xmlComodo = "";
            xmlComodo = "<?xml version=\"1.0\" encoding=\"UTF-8\"?>";
            xmlComodo = xmlComodo + "<palinsesto>";
            xmlComodo = xmlComodo + "<cps tipo=\"2\" conc=\"" + document.getElementById("conc").value + "\">";
            xmlComodo = xmlComodo + "<descrizione>Totogol<\/descrizione>";
            xmlComodo = xmlComodo + "<concorso anno=\"" + document.getElementById("anno").value + "\" cod=\"" + document.getElementById("concorso").value + "\"  data=\"" + document.getElementById("dataSchedina").value + "\" stato=\"" + document.getElementById("statoconc").value + "\">";
            xmlComodo = xmlComodo + "<bigliettototogol codiceconcessione=\"" + document.getElementById("conc").value + "\" codicetipogioco=\"11\" tsn=\"\" dataoravendita=\"\" datascadenza=\"\" palinsesto=\"" + document.getElementById("conc").value + "\" importovendita=\"" + document.getElementById("importo").value + "\" importovincita=\"\" anno=\"" + document.getElementById("anno").value + "\" concorso=\"" + document.getElementById("concorso").value + "\" numerocombinazioni=\"" + document.getElementById("num_combinaz").value + "\" vincentevincitaistantanea=\"\" importovincitaistantanea=\"\" tsnvincitaistantanea=\"\">";
            for (z = 0; z < numeroAree; z = z + 1)
            { 
                primo = true;
                found = false;
                for (i = 0; i < numeroPartite; i = i + 1)
                {   
                    if (document.getElementById("pronostici_" + z + "_" + (i + 1) + "_1").checked === true ||
                        document.getElementById("pronostici_" + z + "_" + (i + 1) + "_2").checked === true ||
                        document.getElementById("pronostici_" + z + "_" + (i + 1) + "_3").checked === true ||
                        document.getElementById("pronostici_" + z + "_" + (i + 1) + "_4").checked === true ||
                        document.getElementById("pronostici_" + z + "_" + (i + 1) + "_5").checked === true ||
                        document.getElementById("pronostici_" + z + "_" + (i + 1) + "_6").checked === true ||
                        document.getElementById("pronostici_" + z + "_" + (i + 1) + "_7").checked === true)
                    {
                        if (primo === true)
                        {
                            primo = false;
                            xmlComodo = xmlComodo + "<areatotogol colonna=\"" + String.fromCharCode(65 + z) + "\" vincente=\"\">";
                        }
                        xmlComodo = xmlComodo + "<pronostico numeropartita=\"" + (i + 1) + "\" stato=\"\" pronostico1=\"" + document.getElementById("pronostici_" + z + "_" + (i + 1) + "_1").checked + "\" pronostico2=\"" + document.getElementById("pronostici_" + z + "_" + (i + 1) + "_2").checked + "\" pronostico3=\"" + document.getElementById("pronostici_" + z + "_" + (i + 1) + "_3").checked + "\" pronostico4=\"" + document.getElementById("pronostici_" + z + "_" + (i + 1) + "_4").checked + "\" pronostico5=\"" + document.getElementById("pronostici_" + z + "_" + (i + 1) + "_5").checked + "\" pronostico6=\"" + document.getElementById("pronostici_" + z + "_" + (i + 1) + "_6").checked + "\" pronostico7=\"" + document.getElementById("pronostici_" + z + "_" + (i + 1) + "_7").checked + "\"/>";
                        found = true;
                    }
                }
                if (found)
                {
                    xmlComodo = xmlComodo + "<\/areatotogol>";
                }
            }
            xmlComodo = xmlComodo + "<\/bigliettototogol>";
            xmlComodo = xmlComodo + "<\/concorso>";
            xmlComodo = xmlComodo + "<\/cps>";
            xmlComodo = xmlComodo + "<\/palinsesto>";  
         
            // alert(xmlComodo); 
            document.getElementById("txtXml").value = xmlComodo;
            pronosticoGiocato = giocateFatteTgol(numeroAree, numeroPartite, document.getElementById("anno").value, document.getElementById("concorso").value);
            ajaxUrl = scommessaAjaxUrl + "concessione=500";
            SISAL.ajax(ajaxUrl, {success: function () {
                optionsBiglietto = SISAL.copy(bigliettoTotogolComponents[0].options);
                optionsBiglietto.method = 'POST';
                optionsBiglietto.data = "sendXml=" + xmlComodo + '&giocataFattaTotogol=' + pronosticoGiocato;
                SISAL.ajax(bigliettoTotogolComponents[0].url, optionsBiglietto);
            }});
        }
     
        if (SISAL.logger.isInfoEnabled())
        {
            SISAL.logger.info("verificaSchedinaTgol - fine");
        }
    }
    
    /**
     * La funzione cancella dalla sessione la schedina compilata
     * @return null
     */
    function cancellaSchedinaTgol()
    {
        if (SISAL.logger.isInfoEnabled())
        {
            SISAL.logger.info("cancellaSchedinaTgol - inizio");
        }

        SISAL.ajax(bigliettoTotogolComponents[0].url + "?concessione=500&cancella=true", bigliettoTotogolComponents[0].options);
        
        if (SISAL.logger.isInfoEnabled())
        {
            SISAL.logger.info("cancellaSchedinaTgol - fine");
        }
    }

    /**
     * La funzione gioca la schedina compilata
     * @return null
     */
    function giocaSchedinaTgol()
    {
        if (SISAL.logger.isInfoEnabled())
        {
            SISAL.logger.info("giocaSchedinaTgol - inizio");
        }

        var cookie_login, ajaxUrl, sessioneValida, optionsBiglietto;
        
        // verifico validità della sessione
        SISAL.ajax(sessioneAjaxUrl, {async: false, response: true, success: function (result) {
            sessioneValida = result;
        }});
        if (SISAL.logger.isDebugEnabled())
        {
            SISAL.logger.debug("giocaSchedinaTcal - sessione <" + sessioneValida + ">");
        }
            
        if (sessioneValida === "OK")
        {
            // verifico validità della sessione login
            if (SISAL.MATCHPOINT.controlloSessioneLogin({html: "La sessione di gioco è scaduta. Per continuare a giocare effettua un nuovo login.", http: true}))
            {
                // popup con clessidra per "giocata in corso...."
                SISAL.FX.showOnElement_TemplatePopup('body',
                        'mp.loading.html', {
                        "{content}" : "Giocata in corso...",
                        width : '360px'
                    });
                    
                // chiamo servizio per effettuare la giocata
                ajaxUrl = giocataAjaxUrl + "concessione=500";
                SISAL.ajax(ajaxUrl, {success: function () {
                    // ricarico biglietto totogol
                    optionsBiglietto = SISAL.copy(bigliettoTotogolComponents[0].options);
                    optionsBiglietto.success = function () {
                        SISAL.ajax('/LoginNuovo/pubblico/servlet/saldo', {success: function () {
                            var saldo = SISAL.getCookieField("saldo", "saldoDisponibile"),
                                bonus = SISAL.getCookieField("saldo", "bonus"),
                                borsino = SISAL.getCookie("borsini");
                            saldo = isNaN(saldo) ? "" : numberToValuta(saldo / 100);
                            $('#saldoDisponibile').html("&euro; " + saldo);
                            $('#logoutSaldo').html(saldo + " &euro;");
                            bonus = isNaN(bonus) ? "" : numberToValuta(bonus / 100);
                            if (!SISAL.isNull(borsino))
                            {
                                borsino = borsino.match(new RegExp(".*\\D+" + 5 + "\\D*,\\D*(\\d+)\\D+.*"));
                                borsino = (SISAL.isNull(borsino) ? borsino : borsino[1]);
                                borsino = isNaN(borsino) ? "" : numberToValuta(borsino / 100);
                            }
                            $('#bonusScommesse').html("&euro; " + borsino);
                            $('#logoutBonus').html(bonus + " &euro;");
                        } });
                    };
                    SISAL.ajax(bigliettoTotogolComponents[0].url + "?biglietto=ok", optionsBiglietto);
                }});
            }
        }
        else
        {
            // messaggio di sessione non attiva
            sessioneInattiva();
        }

        if (SISAL.logger.isInfoEnabled())
        {
            SISAL.logger.info("giocaSchedinaTgol - fine");
        }
    }

    //
    // funzioni tipiche del palinsesto IPPICA
    //
    /**
     * La funzione ritorna la lista dei cavalli selezionati nella schedina ippica
     * @return string
     */
    function listaCavalliIppica()
    {
        var cavalli = document.getElementById("nCavalli").innerHTML, colonne = document.getElementById("numeroColonne").value, lCavalli = [], px, x, z, test;
        
        for (x = 0; x < colonne; x = x + 1)
        {
            px = [];
            for (z = 1; z <= cavalli; z = z + 1)
            {
                /*if (document.getElementById("cavallo_" + x + "_" + z + "").checked === true)*/
                if ($("#cavallo_" + x + "_" + z + ":checkbox").attr('checked') === true)
                {
                    test = document.getElementById("cavallo_" + x + "_" + z + "").value;
                    if (test > 0) 
                    {
                        px.push(document.getElementById("cavallo_" + x + "_" + z + "").value);
                    }
                }
            }
            lCavalli.push(px);
        }
        return lCavalli;
    }

    /**
     * La funzione calcola il numero di combinazioni e l'importo della giocata
     * @return string
     */
    function calcoloScomIppica(codScommessa, codSistema, bitAbbinato)
    {
        var appCavalli = listaCavalliIppica(), v, i, listaSelezione = [], combinazioni, moltiplicatore, totale = 0, errore;
        
        v = appCavalli.length;
        for (i = 0; i < v; i = i + 1)
        {
            listaSelezione.push(appCavalli[i]);
        }
        
        moltiplicatore = document.getElementById("moltiplicatore").value * 1;
        if (moltiplicatore <= 0 || moltiplicatore > 10000)
        {
            errore = "<p>" + recuperaMessaggio([-14, "Specificare un valore numerico valido per il numero di volte (numero compreso tra 1 e 10000)."], {func: "GIOCATAIPPICA"}) + "</p>";
            SISAL.FX.showOnElement_TemplatePopup('body',
                    'mp.alert.buttonok.html', {
                "TextAlign_default": "TextAlign_left",
                "{title}" : "Biglietto Ippica",
                "{content}" : errore,
                "{buttonclick}" : "<hideThis>",
                "{buttontext}" : "OK",
                width : '360px'
            });
            return;
        }
        
        combinazioni = combinazioniIppica(codScommessa, codSistema, listaSelezione);
        document.getElementById("nCombinazioni").innerHTML = combinazioni;

        if (combinazioni > 0)
        {
            totale = importoVenditaIppica(codScommessa, bitAbbinato, combinazioni, moltiplicatore) / 100;
        }

        document.getElementById("numImporto").innerHTML = numberToValuta(totale);
        document.getElementById("importoTot").value = totale;
    }
    
    /**
     * La funzione seleziona tutti i partenti di una data colonna e poi chiama calcoloScomIppica per elaborare il numero di combinazioni e importo.
     * TODO bisogna considerare se checkato campo partenti e settare in base ad esso true o false
     * @return null
     */
    function checkedAllIppica(x, codScommessa, codSistema, bitAbbinato)
    {
        var cavalli = document.getElementById("nCavalli").innerHTML, checkall, z;

        checkall = document.getElementById("checkall_" + x).checked; 
        for (z = 1; z <= cavalli; z = z + 1)
        {
            document.getElementById("cavallo_" + x + "_" + z + "").checked = checkall;
        }
        calcoloScomIppica(codScommessa, codSistema, bitAbbinato);
    }

    /**
     * La funzione rimuove una scommessa ippica
     * @return null
     */
    function cancellaScommessaIppica(idScommessa)
    {
        if (SISAL.logger.isInfoEnabled())
        {
            SISAL.logger.info("cancellaScommessaIppica - inizio");
        }
               
        while (listaScommessaIppica.length > 0)
        {
            listaScommessaIppica.pop();
        }
        SISAL.ajax(bigliettoIppicaComponents[0].url + "?concessione=2&cancella=" + idScommessa, bigliettoIppicaComponents[0].options);
        
        if (SISAL.logger.isInfoEnabled())
        {
            SISAL.logger.info("cancellaScommessaIppica - fine");
        }
    }

    /**
     * La funzione esegue i controlli di congruenza a seconda del tipo di giocata scelta
     * TODO implementare i controlli mancanti
     * @return null
     */
    function validaGiocataIppica(codiceScommessa, minimoscommessa)
    {
        if (SISAL.logger.isInfoEnabled())
        {
            SISAL.logger.info("validaGiocataIppica - inizio");
        }
        
        var sessioneValida, cavalli, colonne, errore = false, maxScommesse = 4, checkCavalli = 0, msgErrore = "", lCavalli = [], x, z, px, testComb, moltiplicatore, appCavalli = listaCavalliIppica(), combinazioni = "", scommessaIppica, esito, xmlInput, xmlScommesse = [], xmlSistema = [], xmlDesc = [], xmlImporti = [], xmlCombinazioni = [], xmlCavalli = [], test, ajaxUrl, optionsBiglietto;

        // verifico validità della sessione
        SISAL.ajax(sessioneAjaxUrl, {async: false, response: true, success: function (result) {
            sessioneValida = result;
        }});
        if (SISAL.logger.isDebugEnabled())
        {
            SISAL.logger.debug("validaGiocataIppica - sessione <" + sessioneValida + ">");
        }   
        if (sessioneValida !== "OK")
        {
            // messaggio di sessione non attiva
            sessioneInattiva();
            return;
        }
        
        // verifico validità della sessione login
        if (!SISAL.MATCHPOINT.controlloSessioneLogin({html: "La sessione di gioco è scaduta. Per continuare a giocare effettua un nuovo login."}))
        {
            return;
        }
        
        cavalli = document.getElementById("nCavalli").innerHTML;
        colonne = document.getElementById("numeroColonne").value;
     
        for (x = 0; x < colonne; x = x + 1)
        {
            px = [];
            for (z = 1; z <= cavalli; z = z + 1)
            {
                /*if (document.getElementById("cavallo_" + x + "_" + z + "").checked === true)*/
                if ($("#cavallo_" + x + "_" + z + ":checkbox").attr('checked') === true)
                {
                    px.push(document.getElementById("cavallo_" + x + "_" + z + "").value);
                }
            }
            lCavalli.push(px);
        }

        // prendo combinazioni
        testComb = document.getElementById("nCombinazioni").innerHTML;
        moltiplicatore = document.getElementById("moltiplicatore").value * 1;
        if (testComb > 0 && moltiplicatore > 0)
        {
            switch (codiceScommessa)
            {
            case 1:  // X1-X1 Vincente         
                if (lCavalli[0].length < 1)
                {
                    errore = true;
                    msgErrore = "Devi portare il numero di volte della giocata almeno a 2 oppure aggiungere un'altro cavallo";    
                }
                checkCavalli = 1;
                break;
            case 2:  // X12-X12 Piazzato
                if (lCavalli[0].length < 1)
                {
                    errore = true;
                    msgErrore = "Seleziona uno o più cavalli che potrebbero piazzarsi al termine della corsa (prima, seconda o in terza posizione).";
                }
                checkCavalli = 1;
                break;
            case 3:  // Vincente/Piazzato
                if (lCavalli[0].length < 1)
                {
                    errore = true;
                    msgErrore = "Seleziona uno o più cavalli che potrebbero vincere o piazzarsi al termine della corsa (prima, seconda o in terza posizione).";
                }
                checkCavalli = 2;
                break;
            case 4:  // X13-X13 Piazzato
                if (lCavalli[0].length < 1)
                {
                    errore = true;
                    msgErrore = "Bisogna selezionare due o più cavalli che occuperanno alla fine della corsa le prime due posizioni indipendentemente dall'ordine.";
                }
                checkCavalli = 1;
                break; 
            case 5:  // Vincente/Piazzato
                if (lCavalli[0].length < 1)
                {
                    errore = true;
                    msgErrore = "Nella prima colonna seleziona uno o più cavalli che dovranno piazzarsi al primo o al secondo.";
                }
                checkCavalli = 2;
                break;
            case 6:  // DUE-NX Accoppiata a girare
                if (lCavalli[0].length < 2)
                {
                    errore = true;
                    msgErrore = "Seleziona due o più cavalli che potrebbero giungere al traguardo in accoppiata.";
                } 
                break;
            case 7:  // DUE-P1 Accoppiata base
                if (lCavalli[0].length < 1)
                {
                    errore = true;
                    msgErrore = "Nella prima colonna seleziona uno o più cavalli che dovranno piazzarsi al primo o al secondo posto nella corsa.";
                }
                else if (lCavalli[1].length < 1)
                {
                    errore = true;
                    msgErrore = "Nella seconda colonna seleziona uno o più cavalli che occuperanno l'altra posizione disponibile per completare l'accoppiata.";
                }
                break;
            case 8:  // DUO-NX Accoppiata A/R
                if (lCavalli[0].length < 2)
                {
                    errore = true;
                    msgErrore = "Bisogna selezionare due o più cavalli che occuperanno alla fine della corsa le prime due posizioni indipendentemente dall'ordine.";
                }
                break;
            case 9:  // DUO-T2 Accoppiata in ordine
                if (lCavalli[0].length < 1)
                {
                    errore = true;
                    msgErrore = "Nella prima colonna seleziona uno o più cavalli che dovranno occupare la prima posizione dell'ordine d'arrivo.";
                }
                else if (lCavalli[1].length < 1)
                {
                    errore = true;
                    msgErrore = "Nella seconda colonna è necessario selezionare uno o più cavalli che dovranno occupare la seconda posizione dell'ordine d'arrivo.";
                }
                break;
            case 10: // TRO-NX Trio a girare
                if (lCavalli[0].length < 3)
                {
                    errore = true;
                    msgErrore = "Bisogna selezionare tre o più cavalli che giungeranno al traguardo primo, secondo e terzo indipendentemente dall'ordine.";
                }         
                break;
            case 11: // TRO-P1 Trio con un piazzato
                if (lCavalli[0].length < 1)
                {
                    errore = true;
                    msgErrore = "Nella prima colonna seleziona uno o più cavalli che devono piazzarsi al termine della corsa (primo, secondo o terzo).";
                }
                else if (lCavalli[1].length < 2)
                {
                    errore = true;
                    msgErrore = "Nella seconda colonna bisogna indicare due o più cavalli che dovranno arrivare al primo, secondo o terzo posto al termine della corsa e completare così la terna vincente.";
                }
                break;
            case 12: // TRO-P2 Trio con due piazzati
                if (lCavalli[0].length < 2)
                {
                    errore = true;
                    msgErrore = "Nella prima colonna seleziona due o più cavalli che devono piazzarsi al termine della corsa (primo, secondo o terzo, indipendentemente dal numero di partenti).";
                }
                else if (lCavalli[1].length < 1)
                {
                    errore = true;
                    msgErrore = "Nella seconda colonna seleziona almeno un cavallo che occuperà l'altro piazzamento disponibile.";
                }  
                break;
            case 13: // TRO-G1 Trio con vincente
                if (lCavalli[0].length < 1)
                {
                    errore = true;
                    msgErrore = "Nella prima colonna seleziona uno o più cavalli che potrebbero vincere la corsa.";
                }
                else if (lCavalli[1].length < 2)
                {
                    errore = true;
                    msgErrore = "Nella seconda colonna seleziona almeno due cavalli che giungeranno secondo e terzo.";
                }  
                break;
            case 14: // TRO-G2 Trio in accoppiata
                if (lCavalli[0].length < 2)
                {
                    errore = true;
                    msgErrore = "Nella prima colonna seleziona due o più cavalli che si piazzeranno ai primi due posti dell'ordine d'arrivo.";
                }
                else if (lCavalli[1].length < 1)
                {
                    errore = true;
                    msgErrore = "Nella seconda colonna seleziona uno o più cavalli che si posizioneranno al terzo posto dell'ordine d'arrivo.";
                }  
                break;
            case 15: // TRO-T3 Trio in ordine
                if (lCavalli[0].length < 1)
                {
                    errore = true;
                    msgErrore = "Nella prima colonna seleziona uno o più cavalli che potrebbero vincere la corsa.";
                }
                else if (lCavalli[1].length < 1)
                {
                    errore = true;
                    msgErrore = "Nella seconda colonna seleziona uno o più cavalli che potrebbero giungere al secondo posto.";
                }
                else if (lCavalli[2].length < 1)
                {
                    errore = true;
                    msgErrore = "Nella terza colonna uno o più cavalli che potrebbero piazzarsi al terzo posto.";
                }
                break;
            case 16: // ACP-NX Accoppiata piazzata a girare
                if (lCavalli[0].length < 2)
                {
                    errore = true;
                    msgErrore = "Seleziona due o più cavalli che potrebbero piazzarsi, in qualunque ordine, nei primi tre posti al termine della corsa";
                }
                break;
            case 17: // ACP-P1 Accoppiata piazzata base
                if (lCavalli[0].length < 1)
                {
                    errore = true;
                    msgErrore = "Nella prima colonna seleziona uno o più cavalli che dovranno piazzarsi al primo, al secondo o al terzo posto nella corsa";
                }
                else if (lCavalli[1].length < 1)
                {
                    errore = true;
                    msgErrore = "Nella seconda colonna seleziona uno o più cavalli che occuperanno l'altra posizione disponibile per completare l'accoppiata.";
                }
                break; 
            default:
                msgErrore = "Codice scommessa non previsto.";
                break;
            }
        }
        else
        {
            errore = true;
        }
        // se errore sovrascrivo msgErrore
        if (errore === true)
        {
            msgErrore = recuperaMessaggio([-15, "La scommessa non è stata correttamente impostata. Operare altre selezioni."], {func: "GIOCATAIPPICA"});
        }
        else
        {
            if (listaScommessaIppica.length >= maxScommesse)
            {
                msgErrore = recuperaMessaggio([-23, "Impossibile inserire più di 4 scommesse nello stesso biglietto", 4], {func: "GIOCATAIPPICA"});
            }
            if (checkCavalli > 0)
            {
                x = listaScommessaIppica.length + lCavalli[0].length * checkCavalli;
                if (x > maxScommesse)
                {
                    msgErrore = recuperaMessaggio([-24, "Superato il massimo numero di selezioni possibili (" + maxScommesse + ") per la scomessa corrente", maxScommesse], {func: "GIOCATAIPPICA"});
                }
            }
        }

        if (msgErrore === "")
        {
            scommessaIppica = "2" + "@" + document.getElementById("pal").value + "@" + document.getElementById("ipCod").value + "@" + document.getElementById("corsaCod").value; 
            esito = validaNuovaScommessaIppica(scommessaIppica, listaScommessaIppica);          
            if (esito[0] !== 0)
            {
                msgErrore = recuperaMessaggio(esito, {func: "validaNuovaScommessaIppica"});
            }
            else
            {
                listaScommessaIppica.push(scommessaIppica);
            }
        }
        
        if (msgErrore !== "")
        {
            SISAL.FX.showOnElement_TemplatePopup('body',
                    'mp.alert.buttonok.html', {
                "TextAlign_default": "TextAlign_left",
                "{title}" : "Biglietto Ippica",
                "{content}" : "<p>" + msgErrore + "</p>",
                "{buttonclick}" : "<hideThis>",
                "{buttontext}" : "OK",
                width : '360px'
            });
        }
        else
        {
            z = appCavalli.length;
            if (checkCavalli > 0)
            {
                for (x = 0; x < colonne; x = x + 1)
                {
                    for (z = 1; z <= cavalli; z = z + 1)
                    {
                        /*if (document.getElementById("cavallo_" + x + "_" + z + "").checked === true)*/
                        if ($("#cavallo_" + x + "_" + z + ":checkbox").attr('checked') === true)
                        {
                            test = document.getElementById("cavallo_" + x + "_" + z + "").value;
                            if (test > 0)
                            {
                                xmlCombinazioni.push(test);
                                xmlImporti.push((document.getElementById("importoTot").value * 100) / testComb / checkCavalli);
                            }
                        }
                    }
                }
            }
            else
            {
                for (x = 0; x < z; x = x + 1)
                {
                    if (x > 0)
                    {
                        combinazioni = combinazioni + " / ";
                    }
                    combinazioni = combinazioni + appCavalli[x].join(", ");
                }
                xmlCombinazioni.push(combinazioni);
                xmlImporti.push(document.getElementById("importoTot").value * 100);
            }
            
            xmlInput = "";
            for (x = 0; x < colonne; x = x + 1)
            {
                xmlInput = xmlInput + "<eventi colonna=\"" + (x + 1) + "\">";
                xmlInput = xmlInput + "<listaByte>";
                for (z = 1; z <= cavalli; z = z + 1)
                {
                    /*if (document.getElementById("cavallo_" + x + "_" + z + "").checked === true)*/
                    if ($("#cavallo_" + x + "_" + z + ":checkbox").attr('checked') === true)
                    {
                        test = document.getElementById("cavallo_" + x + "_" + z + "").value;
                        if (test > 0)
                        {
                            xmlInput = xmlInput + "<byte numeroCavallo=\"" + document.getElementById("cavallo_" + x + "_" + z + "").value + "\"><\/byte>";
                        }
                        if (checkCavalli > 0)
                        {
                            xmlInput = xmlInput + "<\/listaByte>";
                            xmlInput = xmlInput + "<\/eventi>";
                            xmlCavalli.push(xmlInput);
                            xmlInput = "";
                            xmlInput = xmlInput + "<eventi colonna=\"" + (x + 1) + "\">";
                            xmlInput = xmlInput + "<listaByte>";
                        }
                    }
                }               
                xmlInput = xmlInput + "<\/listaByte>";
                xmlInput = xmlInput + "<\/eventi>";
            }
            if (checkCavalli === 0)
            {
                xmlCavalli.push(xmlInput);
            }
            if (checkCavalli < 2)
            {
                xmlScommesse.push(document.getElementById("codScommessa").value);
                xmlSistema.push(document.getElementById("codSistema").value);
                xmlDesc.push(document.getElementById("descScommessa").value);
            }
            else
            {
                xmlScommesse.push("1");
                xmlSistema.push("0");
                xmlDesc.push("Vincente");
                if (codiceScommessa === 3)
                {
                    xmlScommesse.push("2");
                    xmlSistema.push("1");
                    xmlDesc.push("Piazzato");
                }
                if (codiceScommessa === 5)
                {
                    xmlScommesse.push("3");
                    xmlSistema.push("2");
                    xmlDesc.push("Piazzato");
                }
            }
            
            xmlInput = "";
            for (x = 0; x < xmlCavalli.length; x = x + 1)
            {
                if (x > 0)
                {
                    xmlInput = xmlInput + "&sendXml=";
                }
                for (z = 0; z < xmlScommesse.length; z = z + 1)
                {
                    if (z > 0)
                    {
                        xmlInput = xmlInput + "&sendXml=";
                    }
                    xmlInput = xmlInput + "<?xml version=\"1.0\" encoding=\"UTF-8\"?>";
                    xmlInput = xmlInput + "<listaScommesse>";
                    xmlInput = xmlInput + "<scommessa grp=\"" + document.getElementById("grp").value + "\" codConcessione=\"" + document.getElementById("conc").value + "\" codTipoGioco=\"\" codPalinsesto=\"" + document.getElementById("pal").value + "\" codAvvenimento=\"" + document.getElementById("codAvv").value + "\" codRiunioneIppodromo=\"" + document.getElementById("ipCod").value + "\" codScommessa=\"" + xmlScommesse[z] + "\" codSistema=\"" + xmlSistema[z] + "\" descScommessa=\"" + xmlDesc[z] + "\" moltiplicatore=\"" + document.getElementById("moltiplicatore").value + "\" importo=\"" + xmlImporti[x] + "\" visualizzazioneColonneCavalli=\"" + xmlCombinazioni[x] + "\">";
                    xmlInput = xmlInput + "<ippodromo cod=\"" + document.getElementById("ipCod").value + "\" descrizione=\"" + document.getElementById("ipDescrizione").value + "\"><\/ippodromo>";
                    xmlInput = xmlInput + "<corsa cod=\"" + document.getElementById("corsaCod").value + "\" numero=\"" + document.getElementById("corsaNumero").value + "\" tipo=\"" + document.getElementById("corsaTipo").value + "\" stato=\"" + document.getElementById("corsaStato").value + "\" distanza=\"" + document.getElementById("corsaDistanza").value + "\" abilitaz=\"" + document.getElementById("corsaAbil").value + "\" orario=\"" + document.getElementById("corsaOrario").value + "\"><\/corsa>";
                    xmlInput = xmlInput + "<infoscommessa codice=\"" + document.getElementById("codScommessa").value + "\" descrizione=\"" + document.getElementById("descScommessa").value + "\" sistema=\"" + document.getElementById("codSistema").value + "\" colonne=\"" + document.getElementById("numeroColonne").value + "\"/>";
                    xmlInput = xmlInput + "<listaElementi>";
                    xmlInput = xmlInput + xmlCavalli[x];
                    xmlInput = xmlInput + "<\/listaElementi>";
                    xmlInput = xmlInput + "<\/scommessa>";
                    xmlInput = xmlInput + "<\/listaScommesse>";
                }
            }
            //alert(xmlInput);
            document.getElementById("txtXml").value = xmlInput;
            ajaxUrl = scommessaAjaxUrl + "concessione=2";
            SISAL.ajax(rimuoviScommesseAjaxUrl + "concessione=2", {success: function () {
                SISAL.ajax(ajaxUrl, {success: function () {
                    optionsBiglietto = SISAL.copy(bigliettoIppicaComponents[0].options);
                    optionsBiglietto.method = 'POST';
                    optionsBiglietto.data = "sendXml=" + xmlInput;
                    SISAL.ajax(bigliettoIppicaComponents[0].url, optionsBiglietto);
                }});
            }});
        }

        if (SISAL.logger.isInfoEnabled())
        {
            SISAL.logger.info("validaGiocataIppica - fine");
        }
    }

    /**
     * La funzione gioca le scommesse ippiche compilate
     * @return null
     */
    function giocaScommesseIppica(ingioco, minimoscommessa)
    {
        if (SISAL.logger.isInfoEnabled())
        {
            SISAL.logger.info("giocaScommesseIppica - inizio");
        }

        var cookie_login, ajaxUrl, sessioneValida, optionsBiglietto, errore;
        
        // verifico validità della sessione
        SISAL.ajax(sessioneAjaxUrl, {async: false, response: true, success: function (result) {
            sessioneValida = result;
        }});
        if (SISAL.logger.isDebugEnabled())
        {
            SISAL.logger.debug("giocaScommesseIppica - sessione <" + sessioneValida + ">");
        }
            
        if (sessioneValida === "OK")
        {
            // verifico validità della sessione login
            if (SISAL.MATCHPOINT.controlloSessioneLogin({html: "La sessione di gioco è scaduta. Per continuare a giocare effettua un nuovo login.", http: true}))
            {
                if (ingioco < minimoscommessa)
                {
                    errore = "<p>" + recuperaMessaggio([-25, "Importo inferiore alla giocata minima di " + numberToValuta(minimoscommessa / 100) + " &euro;.", minimoscommessa], {func: "GIOCATAIPPICA"}) + "</p>";
                    SISAL.FX.showOnElement_TemplatePopup('body',
                            'mp.alert.buttonok.html', {
                        "TextAlign_default": "TextAlign_left",
                        "{title}" : "Biglietto Ippica",
                        "{content}" : errore,
                        "{buttonclick}" : "<hideThis>",
                        "{buttontext}" : "OK",
                        width : '360px'
                    });
                    return;
                }
                
                // popup con clessidra per "giocata in corso...."
                SISAL.FX.showOnElement_TemplatePopup('body',
                        'mp.loading.html', {
                        "{content}" : "Scommessa in corso...",
                        width : '360px'
                    });
                    
                // chiamo servizio per effettuare la giocata
                ajaxUrl = giocataAjaxUrl + "concessione=2";
                SISAL.ajax(ajaxUrl, {success: function () {
                    // ricarico biglietto ippica
                    optionsBiglietto = SISAL.copy(bigliettoIppicaComponents[0].options);
                    optionsBiglietto.success = function () {
                        SISAL.ajax('/LoginNuovo/pubblico/servlet/saldo', {success: function () {
                            var saldo = SISAL.getCookieField("saldo", "saldoDisponibile"),
                                bonus = SISAL.getCookieField("saldo", "bonus"),
                                borsino = SISAL.getCookie("borsini");
                            saldo = isNaN(saldo) ? "" : numberToValuta(saldo / 100);
                            $('#saldoDisponibile').html("&euro; " + saldo);
                            $('#logoutSaldo').html(saldo + " &euro;");
                            bonus = isNaN(bonus) ? "" : numberToValuta(bonus / 100);
                            if (!SISAL.isNull(borsino))
                            {
                                borsino = borsino.match(new RegExp(".*\\D+" + 2 + "\\D*,\\D*(\\d+)\\D+.*"));
                                borsino = (SISAL.isNull(borsino) ? borsino : borsino[1]);
                                borsino = isNaN(borsino) ? "" : numberToValuta(borsino / 100);
                            }
                            $('#bonusScommesse').html("&euro; " + borsino);
                            $('#logoutBonus').html(bonus + " &euro;");
                        } });
                    };
                    SISAL.ajax(bigliettoIppicaComponents[0].url + "?biglietto=ok", optionsBiglietto);
                }});
            }
        }
        else
        {
            // messaggio di sessione non attiva
            sessioneInattiva();
        }

        if (SISAL.logger.isInfoEnabled())
        {
            SISAL.logger.info("giocaScommesseIppica - fine");
        }
    }

    //
    // funzioni tipiche del palinsesto TRIS
    //
    /**
     * La funzione ritorna la lista dei cavalli selezionati nella schedina tris
     * @return string
     */
    function listaCavalliTris()
    {
        var cavalli = document.getElementById("nCavalli").innerHTML, colonne = document.getElementById("numeroColonne").value, lCavalli = [], px, x, z, test;
        
        for (x = 0; x < colonne; x = x + 1)
        {
            px = [];
            for (z = 1; z <= cavalli; z = z + 1)
            {
                /*if (document.getElementById("cavallo_" + x + "_" + z + "").checked === true)*/
                if ($("#cavallo_" + x + "_" + z + ":checkbox").attr('checked') === true)
                {
                    test = document.getElementById("cavallo_" + x + "_" + z + "").value;
                    if (test > 0) 
                    {
                        px.push(document.getElementById("cavallo_" + x + "_" + z + "").value);
                    }
                }
            }
            lCavalli.push(px);
        }
        return lCavalli;
    }

    /**
     * La funzione calcola il numero di combinazioni e l'importo della giocata
     * @return string
     */
    function calcoloScomTris(codScommessa, codSistema, bitAbbinato)
    {
        var appCavalli = listaCavalliTris(), v, i, listaSelezione = [], combinazioni, moltiplicatore, totale = 0, errore;
        
        v = appCavalli.length;
        for (i = 0; i < v; i = i + 1)
        {
            listaSelezione.push(appCavalli[i]);
        }
        
        moltiplicatore = document.getElementById("moltiplicatore").value * 1;
        if (moltiplicatore <= 0 || moltiplicatore > 100)
        {
            errore = "<p>" + recuperaMessaggio([-14, "Specificare un valore numerico valido per il numero di volte (numero compreso tra 1 e 100)."], {func: "GIOCATATRIS"}) + "</p>";
            SISAL.FX.showOnElement_TemplatePopup('body',
                    'mp.alert.buttonok.html', {
                "TextAlign_default": "TextAlign_left",
                "{title}" : "Biglietto Tris",
                "{content}" : errore,
                "{buttonclick}" : "<hideThis>",
                "{buttontext}" : "OK",
                width : '360px'
            });
            return false;
        }
        
        combinazioni = combinazioniSIP(codScommessa, codSistema, listaSelezione);
        if (combinazioni < 0)
        {
            errore = "<p>" + recuperaMessaggio([-16, "Hai superato il numero massimo di 10000 combinazioni giocabili. Riduci le selezioni."], {func: "GIOCATATRIS"}) + "</p>";
            SISAL.FX.showOnElement_TemplatePopup('body',
                    'mp.alert.buttonok.html', {
                "TextAlign_default": "TextAlign_left",
                "{title}" : "Biglietto Tris",
                "{content}" : errore,
                "{buttonclick}" : "<hideThis>",
                "{buttontext}" : "OK",
                width : '360px'
            });
            return false;
        }
        
        document.getElementById("nCombinazioni").innerHTML = combinazioni;

        if (combinazioni > 0)
        {
            totale = importoVenditaSIP(bitAbbinato, codScommessa, combinazioni, moltiplicatore) / 100;
        }

        document.getElementById("numImporto").innerHTML = numberToValuta(totale);
        document.getElementById("importoTot").value = totale;
        return true;
    }
    
    /**
     * La funzione seleziona tutti i partenti di una data colonna e poi chiama calcoloScomTris per elaborare il numero di combinazioni e importo.
     * TODO bisogna considerare se checkato campo partenti e settare in base ad esso true o false
     * @return null
     */
    function checkedAllTris(x, codScommessa, codSistema, bitAbbinato)
    {
        var cavalli = document.getElementById("nCavalli").innerHTML, checkall, z;

        checkall = document.getElementById("checkall_" + x).checked; 
        for (z = 1; z <= cavalli; z = z + 1)
        {
            document.getElementById("cavallo_" + x + "_" + z + "").checked = checkall;
        }
        calcoloScomTris(codScommessa, codSistema, bitAbbinato);
    }

    /**
     * La funzione rimuove una scommessa tris
     * @return null
     */
    function cancellaScommessaTris(idScommessa)
    {
        if (SISAL.logger.isInfoEnabled())
        {
            SISAL.logger.info("cancellaScommessaTris - inizio");
        }
               
        while (listaScommessaTris.length > 0)
        {
            listaScommessaTris.pop();
        }
        SISAL.ajax(bigliettoTrisComponents[0].url + "?concessione=4&cancella=" + idScommessa, bigliettoTrisComponents[0].options);
        
        if (SISAL.logger.isInfoEnabled())
        {
            SISAL.logger.info("cancellaScommessaTris - fine");
        }
    }

    /**
     * La funzione esegue i controlli di congruenza a seconda del tipo di giocata scelta
     * TODO implementare i controlli mancanti
     * @return null
     */
    function validaGiocataTris(codiceScommessa, codScommessa, codSistema, bitAbbinato)
    {
        if (SISAL.logger.isInfoEnabled())
        {
            SISAL.logger.info("validaGiocataTris - inizio");
        }
        
        var sessioneValida, cavalli, colonne, errore = false, msgErrore = "", lCavalli = [], x, z, px, testComb, moltiplicatore, maxScommesse = 4, appCavalli = listaCavalliTris(), combinazioni = "", scommessaTris, esito, xmlInput = "", test, ajaxUrl, optionsBiglietto;

        // verifico validità della sessione
        SISAL.ajax(sessioneAjaxUrl, {async: false, response: true, success: function (result) {
            sessioneValida = result;
        }});
        if (SISAL.logger.isDebugEnabled())
        {
            SISAL.logger.debug("validaGiocataTris - sessione <" + sessioneValida + ">");
        }
            
        if (sessioneValida !== "OK")
        {
            // messaggio di sessione non attiva
            sessioneInattiva();
            return;
        }
        
        // verifico validità della sessione login
        if (!SISAL.MATCHPOINT.controlloSessioneLogin({html: "La sessione di gioco è scaduta. Per continuare a giocare effettua un nuovo login."}))
        {
            return;
        }
        
        // controllo combinazioni
        if (calcoloScomTris(codScommessa, codSistema, bitAbbinato) === false)
        {
            return;
        }
        
        cavalli = document.getElementById("nCavalli").innerHTML;
        colonne = document.getElementById("numeroColonne").value;
     
        for (x = 0; x < colonne; x = x + 1)
        {
            px = [];
            for (z = 1; z <= cavalli; z = z + 1)
            {
                /*if (document.getElementById("cavallo_" + x + "_" + z + "").checked === true)*/
                if ($("#cavallo_" + x + "_" + z + ":checkbox").attr('checked') === true)
                {
                    px.push(document.getElementById("cavallo_" + x + "_" + z + "").value);
                }
            }
            lCavalli.push(px);
        }

        // prendo combinazioni
        testComb = document.getElementById("nCombinazioni").innerHTML;
        moltiplicatore = document.getElementById("moltiplicatore").value * 1;
        if (testComb > 0 && moltiplicatore > 0)
        {
            // controlli in base a codice scommessa
            switch (codiceScommessa)
            {
            case 1:  // X1-NX Vincente
                if (lCavalli[0].length < 1)
                {
                    errore = true;
                    msgErrore = "Devi portare il numero di volte della giocata almeno a 2 oppure aggiungere un'altro cavallo.";    
                }
                break;
            case 2:  // DUO-NX Accoppiata a girare
                if (lCavalli[0].length < 2)
                {
                    errore = true;
                    msgErrore = "Bisogna selezionare due o più cavalli che occuperanno alla fine della corsa le prime due posizioni indipendentemente dall'ordine.";
                }
                break;
            case 3:  // DUO-P1 Accoppiata base
                if (lCavalli[0].length < 1)
                {
                    errore = true;
                    msgErrore = "Nella prima colonna seleziona uno o più cavalli che dovranno piazzarsi al primo o al secondo posto.";
                }
                else if (lCavalli[1].length < 1)
                {
                    errore = true;
                    msgErrore = "Nella seconda colonna seleziona uno o più cavalli che occuperanno l'altra posizione disponibile per completare l'accoppiata.";
                }
                break;
            case 4:  // DUO-T2 Accoppiata in ordine
                if (lCavalli[0].length < 1)
                {
                    errore = true;
                    msgErrore = "Nella prima colonna seleziona uno o più cavalli che dovranno occupare la prima posizione dell'ordine d'arrivo.";
                }
                else if (lCavalli[1].length < 1)
                {
                    errore = true;
                    msgErrore = "Nella seconda colonna è necessario selezionare uno o più cavalli che dovranno occupare la seconda posizione dell'ordine d'arrivo.";
                }
                break;
            case 5:  // TRO-NX Tris a girare
                if (lCavalli[0].length < 3)
                {
                    errore = true;
                    msgErrore = "Bisogna selezionare tre o più cavalli che giungeranno al traguardo primo, secondo e terzo indipendentemente dall'ordine.";
                }
                break;
            case 6:  // TRO-P1 Tris con un piazzato
                if (lCavalli[0].length < 1)
                {
                    errore = true;
                    msgErrore = "Nella prima colonna seleziona uno o più cavalli che devono piazzarsi al termine della corsa (primo, secondo o terzo).";
                }
                else if (lCavalli[1].length < 2)
                {
                    errore = true;
                    msgErrore = "Nella seconda colonna bisogna indicare due o più cavalli.";
                } 
                break;
            case 7:  // TRO-P2 Tris con due piazzati
                if (lCavalli[0].length < 2)
                {
                    errore = true;
                    msgErrore = "Nella prima colonna seleziona due o più cavalli che devono piazzarsi al termine della corsa.";
                }
                else if (lCavalli[1].length < 1)
                {
                    errore = true;
                    msgErrore = "Nella seconda colonna seleziona almeno un cavallo che occuperà l'altro piazzamento disponibile.";
                }
                break;
            case 8:  // TRO-G1 Tris con vincente
                if (lCavalli[0].length < 1)
                {
                    errore = true;
                    msgErrore = "Nella prima colonna seleziona uno o più cavalli che potrebbero vincere la corsa.";
                }
                else if (lCavalli[1].length < 2)
                {
                    errore = true;
                    msgErrore = "Nella seconda colonna seleziona almeno due cavalli che giungeranno secondo e terzo.";
                }
                break;
            case 9:  // TRO-G2 Tris in accoppiata
                if (lCavalli[0].length < 2)
                {
                    errore = true;
                    msgErrore = "Nella prima colonna seleziona due o più cavalli che si piazzeranno ai primi due posti dell'ordine d'arrivo.";
                }
                else if (lCavalli[1].length < 1)
                {
                    errore = true;
                    msgErrore = "Nella seconda colonna seleziona uno o più cavalli che si posizioneranno al terzo posto.";
                }
                break;
            case 10: // TRO-T3 Tris in ordine
                if (lCavalli[0].length < 1)
                {
                    errore = true;
                    msgErrore = "Nella prima colonna seleziona uno o più cavalli che potrebbero vincere la corsa.";
                }
                else if (lCavalli[1].length < 1)
                {
                    errore = true;
                    msgErrore = "Nella seconda colonna seleziona uno o più cavalli che potrebbero giungere al secondo posto.";
                }
                else if (lCavalli[2].length < 1)
                {
                    errore = true;
                    msgErrore = "Nella terza colonna uno o più cavalli che potrebbero piazzarsi al terzo posto.";
                } 
                break;
            case 11: // QUO-NX Quarté a girare
                if (lCavalli[0].length < 4)
                {
                    errore = true;
                    msgErrore = "Bisogna selezionare quattro o più cavalli che giungeranno al traguardo primo, secondo, terzo e quarto indipendentemente dall'ordine.";
                }
                break;
            case 12: // QUO-P1 Quarté con un piazzato
                if (lCavalli[0].length < 1)
                {
                    errore = true;
                    msgErrore = "Nella prima colonna seleziona uno o più cavalli che devono piazzarsi al termine della corsa (primo, secondo, terzo o quarto).";
                }
                else if (lCavalli[1].length < 3)
                {
                    errore = true;
                    msgErrore = "Nella seconda colonna bisogna indicare tre o più cavalli che dovranno arrivare al primo, secondo, terzo o quarto posto al termine della corsa e completare così la quaterna vincente.";
                }            
                break;
            case 13: // QUO-P2 Quarté con due piazzati
                if (lCavalli[0].length < 2)
                {
                    errore = true;
                    msgErrore = "Nella prima colonna seleziona due o più cavalli che devono piazzarsi al termine della corsa (primo, secondo, terzo o quarto, indipendentemente dal numero di partenti).";
                }
                else if (lCavalli[1].length < 2)
                {
                    errore = true;
                    msgErrore = "Nella seconda colonna seleziona almeno due cavalli che occuperano l'altro piazzamento disponibile.";
                }            
                break;
            case 14: // QUO-P3 Quarté con tre piazzati
                if (lCavalli[0].length < 3)
                {
                    errore = true;
                    msgErrore = "Nella prima colonna seleziona tre o più cavalli che devono piazzarsi al termine della corsa (primo, secondo, terzo o quarto, indipendentemente dal numero di partenti).";
                }
                else if (lCavalli[1].length < 1)
                {
                    errore = true;
                    msgErrore = "Nella seconda colonna seleziona almeno un cavallo che occuperà l'altro piazzamento disponibile.";
                }            
                break;
            case 15: // QUO-G1 Quarté con vincente
                if (lCavalli[0].length < 1)
                {
                    errore = true;
                    msgErrore = "Nella prima colonna seleziona uno o più cavalli che potrebbero vincere la corsa.";
                }
                else if (lCavalli[1].length < 3)
                {
                    errore = true;
                    msgErrore = "Nella seconda colonna seleziona almeno tre cavalli che giungeranno secondo, terzo e quarto.";
                }            
                break;
            case 16: // QUO-G2 Quarté con accoppiata
                if (lCavalli[0].length < 2)
                {
                    errore = true;
                    msgErrore = "Nella prima colonna seleziona due o più cavalli che dovranno piazzarsi al primo o al secondo posto nella corsa.";
                }
                else if (lCavalli[1].length < 2)
                {
                    errore = true;
                    msgErrore = "Nella seconda colonna seleziona due o più cavalli che occuperanno le altre posizioni disponibili per completare la quartè.";
                }            
                break;
            case 17: // QUO-G3 Quarté con tris
                if (lCavalli[0].length < 3)
                {
                    errore = true;
                    msgErrore = "Nella prima colonna seleziona tre o più cavalli che dovranno piazzarsi al primo o al secondo o al terzo posto nella corsa.";
                }
                else if (lCavalli[1].length < 1)
                {
                    errore = true;
                    msgErrore = "Nella seconda colonna seleziona uno o più cavalli che occuperanno l'altra posizione disponibile per completare la quartè.";
                }          
                break;
            case 18: // QUO-T4 Quarté in ordine
                if (lCavalli[0].length < 1)
                {
                    errore = true;
                    msgErrore = "Nella prima colonna seleziona uno o più cavalli che potrebbero vincere la corsa.";
                }
                else if (lCavalli[1].length < 1)
                {
                    errore = true;
                    msgErrore = "Nella seconda colonna seleziona uno o più cavalli che potrebbero giungere al secondo posto.";
                }
                else if (lCavalli[2].length < 1)
                {
                    errore = true;
                    msgErrore = "Nella terza colonna seleziona uno o più cavalli che potrebbero piazzarsi al terzo posto.";
                } 
                else if (lCavalli[3].length < 1)
                {
                    errore = true;
                    msgErrore = "Nella quarta colonna seleziona uno o più cavalli che potrebbero piazzarsi al quarto posto.";
                } 
                break;
            case 19: // CIO-NX Quinté a girare
                if (lCavalli[0].length < 5)
                {
                    errore = true;
                    msgErrore = "Bisogna selezionare cinque o più cavalli che giungeranno al traguardo primo, secondo, terzo, quarto e quinto indipendentemente dall'ordine.";
                }
                break;
            case 20: // CIO-P1 Quinté con un piazzato
                if (lCavalli[0].length < 1)
                {
                    errore = true;
                    msgErrore = "Nella prima colonna seleziona uno o più cavalli che devono piazzarsi al termine della corsa (primo, secondo, terzo, quarto o quinto).";
                }
                else if (lCavalli[1].length < 4)
                {
                    errore = true;
                    msgErrore = "Nella seconda colonna bisogna indicare quattro o più cavalli che dovranno arrivare al primo, secondo, terzo, quarto o quinto posto al termine della corsa e completare così la cinquina vincente.";
                }          
                break;
            case 21: // CIO-P2 Quinté con due piazzati
                if (lCavalli[0].length < 2)
                {
                    errore = true;
                    msgErrore = "Nella prima colonna seleziona due o più cavalli che devono piazzarsi al termine della corsa (primo, secondo, terzo, quarto o quinto, indipendentemente dal numero di partenti).";
                }
                else if (lCavalli[1].length < 3)
                {
                    errore = true;
                    msgErrore = "Nella seconda colonna seleziona almeno tre cavalli che occuperano l'altro piazzamento disponibile.";
                }          
                break;
            case 22: // CIO-P2 Quinté con tre piazzati
                if (lCavalli[0].length < 3)
                {
                    errore = true;
                    msgErrore = "Nella prima colonna seleziona tre o più cavalli che devono piazzarsi al termine della corsa (primo, secondo, terzo, quarto o quinto, indipendentemente dal numero di partenti).";
                }
                else if (lCavalli[1].length < 2)
                {
                    errore = true;
                    msgErrore = "Nella seconda colonna seleziona almeno due cavalli che occuperano l'altro piazzamento disponibile.";
                }          
                break;
            case 23: // CIO-P4 Quinté con quattro piazzati
                if (lCavalli[0].length < 4)
                {
                    errore = true;
                    msgErrore = "Nella prima colonna seleziona quattro o più cavalli che devono piazzarsi al termine della corsa (primo, secondo, terzo, quarto o quinto, indipendentemente dal numero di partenti).";
                }
                else if (lCavalli[1].length < 1)
                {
                    errore = true;
                    msgErrore = "Nella seconda colonna seleziona almeno un cavallo che occuperà l'altro piazzamento disponibile.";
                }          
                break;
            case 24: // CIO-G1 Quinté con vincente
                if (lCavalli[0].length < 1)
                {
                    errore = true;
                    msgErrore = "Nella prima colonna seleziona uno o più cavalli che potrebbero vincere la corsa.";
                }
                else if (lCavalli[1].length < 4)
                {
                    errore = true;
                    msgErrore = "Nella seconda colonna seleziona almeno quattro cavalli che giungeranno secondo, terzo, quarto e quinto.";
                }          
                break;
            case 25: // CIO-G2 Quinté con accoppiata
                if (lCavalli[0].length < 2)
                {
                    errore = true;
                    msgErrore = "Nella prima colonna seleziona due o più cavalli che dovranno piazzarsi al primo o al secondo posto nella corsa.";
                }
                else if (lCavalli[1].length < 3)
                {
                    errore = true;
                    msgErrore = "Nella seconda colonna seleziona tre o più cavalli che occuperanno le altre posizioni disponibili per completare la quintè.";
                }          
                break;
            case 26: // CIO-G3 Quinté con tris
                if (lCavalli[0].length < 3)
                {
                    errore = true;
                    msgErrore = "Nella prima colonna seleziona tre o più cavalli che dovranno piazzarsi al primo o al secondo o al terzo posto nella corsa.";
                }
                else if (lCavalli[1].length < 2)
                {
                    errore = true;
                    msgErrore = "Nella seconda colonna seleziona due o più cavalli che occuperanno le altre posizioni disponibili per completare la quintè.";
                }          
                break;
            case 27: // CIO-G4 Quinté con quarté
                if (lCavalli[0].length < 4)
                {
                    errore = true;
                    msgErrore = "Nella prima colonna seleziona quattro o più cavalli che dovranno piazzarsi al primo o al secondo o al terzo o al quarto posto nella corsa.";
                }
                else if (lCavalli[1].length < 1)
                {
                    errore = true;
                    msgErrore = "Nella seconda colonna seleziona uno o più cavalli che occuperanno l'altra posizione disponibile per completare la quintè.";
                }          
                break;
            case 28: // CIO-T5 Quinté in ordine
                if (lCavalli[0].length < 1)
                {
                    errore = true;
                    msgErrore = "Nella prima colonna seleziona uno o più cavalli che potrebbero vincere la corsa.";
                }
                else if (lCavalli[1].length < 1)
                {
                    errore = true;
                    msgErrore = "Nella seconda colonna seleziona uno o più cavalli che potrebbero giungere al secondo posto.";
                }
                else if (lCavalli[2].length < 1)
                {
                    errore = true;
                    msgErrore = "Nella terza colonna seleziona uno o più cavalli che potrebbero piazzarsi al terzo posto.";
                }
                else if (lCavalli[3].length < 1)
                {
                    errore = true;
                    msgErrore = "Nella quarta colonna seleziona uno o più cavalli che potrebbero piazzarsi al quarto posto.";
                }
                else if (lCavalli[4].length < 1)
                {
                    errore = true;
                    msgErrore = "Nella quinta colonna seleziona uno o più cavalli che potrebbero piazzarsi al quinto posto.";
                } 
                break;
            default:
                msgErrore = "Codice scommessa non previsto.";
                break;
            }
        }
        else
        {
            errore = true;
        }
        // se errore sovrascrivo msgErrore
        if (errore === true)
        {
            msgErrore = recuperaMessaggio([-15, "La scommessa non è stata correttamente impostata. Operare altre selezioni."], {func: "GIOCATATRIS"});
        }
        else
        {
            if (listaScommessaTris.length >= maxScommesse)
            {
                msgErrore = recuperaMessaggio([-23, "Impossibile inserire più di 4 scommesse nello stesso biglietto", 4], {func: "GIOCATATRIS"});
            }
        }
       
        if (msgErrore === "")
        {
            scommessaTris = document.getElementById("conc").value + "@" + document.getElementById("pal").value + "@" + document.getElementById("corsaCod").value + "@" + document.getElementById("codTipoGioco").value; 
            esito = validaNuovaScommessaSIP(scommessaTris, listaScommessaTris);
            if (esito[0] !== 0)
            {
                msgErrore = recuperaMessaggio(esito, {func: "validaNuovaScommessaSIP"});
            }
            else
            {
                listaScommessaTris.push(scommessaTris);
            }
        }
        
        if (msgErrore !== "")
        {
            SISAL.FX.showOnElement_TemplatePopup('body',
                    'mp.alert.buttonok.html', {
                "TextAlign_default": "TextAlign_left",
                "{title}" : "Biglietto Tris",
                "{content}" : "<p>" + msgErrore + "</p>",
                "{buttonclick}" : "<hideThis>",
                "{buttontext}" : "OK",
                width : '360px'
            });
        }
        else
        {          
            z = appCavalli.length;
            for (x = 0; x < z; x = x + 1)
            {
                if (x > 0)
                {
                    combinazioni = combinazioni + " / ";
                }
                combinazioni = combinazioni + appCavalli[x].join(", ");
            }
            
            xmlInput = "<?xml version=\"1.0\" encoding=\"UTF-8\"?>";
            xmlInput = xmlInput + "<listaScommesse>";
            xmlInput = xmlInput + "<scommessa grp=\"" + document.getElementById("grp").value + "\" codConcessione=\"" + document.getElementById("conc").value + "\" codTipoGioco=\"" + document.getElementById("codTipoGioco").value + "\" codPalinsesto=\"" + document.getElementById("pal").value + "\" codAvvenimento=\"" + document.getElementById("codicecorsa").value + "\" codRiunioneIppodromo=\"" + document.getElementById("ipCod").value + "\" codScommessa=\"" + document.getElementById("codScomessa").value + "\" codSistema=\"" + document.getElementById("codSistema").value + "\" descScommessa=\"" + document.getElementById("descScommessa").value + "\" moltiplicatore=\"" + document.getElementById("moltiplicatore").value + "\" importo=\"" + (document.getElementById("importoTot").value * 100) + "\" visualizzazioneColonneCavalli=\"" + combinazioni + "\">";
            xmlInput = xmlInput + "<ippodromo cod=\"" + document.getElementById("ipCod").value + "\" descrizione=\"" + document.getElementById("ipDescrizione").value + "\"><\/ippodromo>";
            xmlInput = xmlInput + "<corsa cod=\"" + document.getElementById("corsaCod").value + "\" numero=\"" + document.getElementById("corsaNumero").value + "\" tipo=\"" + document.getElementById("corsaTipo").value + "\" stato=\"" + document.getElementById("corsaStato").value + "\" distanza=\"" + document.getElementById("corsaDistanza").value + "\" abilitaz=\"" + document.getElementById("corsaAbil").value + "\" orario=\"" + document.getElementById("corsaOrario").value + "\"><\/corsa>";
            xmlInput = xmlInput + "<infoscommessa codice=\"" + document.getElementById("codScomessa").value + "\" descrizione=\"" + document.getElementById("descScommessa").value + "\" sistema=\"" + document.getElementById("codSistema").value + "\" colonne=\"" + document.getElementById("numeroColonne").value + "\"/>";
            xmlInput = xmlInput + "<listaElementi>";
            for (x = 0; x < colonne; x = x + 1)
            {
                xmlInput = xmlInput + "<eventi colonna=\"" + (x + 1) + "\">";
                xmlInput = xmlInput + "<listaByte>";
                for (z = 1; z <= cavalli; z = z + 1)
                {
                    /*if (document.getElementById("cavallo_" + x + "_" + z + "").checked === true)*/
                    if ($("#cavallo_" + x + "_" + z + ":checkbox").attr('checked') === true)
                    {
                        test = document.getElementById("cavallo_" + x + "_" + z + "").value;
                        if (test > 0)
                        {
                            xmlInput = xmlInput + "<byte numeroCavallo=\"" + document.getElementById("cavallo_" + x + "_" + z + "").value + "\"><\/byte>";
                        }
                    }
                }
                xmlInput = xmlInput + "<\/listaByte>";
                xmlInput = xmlInput + "<\/eventi>";
            }
            xmlInput = xmlInput + "<\/listaElementi>";
            xmlInput = xmlInput + "<\/scommessa>";
            xmlInput = xmlInput + "<\/listaScommesse>";
            
            // alert(xmlInput);
            document.getElementById("txtXml").value = xmlInput;     
            ajaxUrl = scommessaAjaxUrl + "concessione=4";
            SISAL.ajax(rimuoviScommesseAjaxUrl + "concessione=4", {success: function () {
                SISAL.ajax(ajaxUrl, {success: function () {
                    optionsBiglietto = SISAL.copy(bigliettoTrisComponents[0].options);
                    optionsBiglietto.method = 'POST';
                    optionsBiglietto.data = "sendXml=" + xmlInput;
                    SISAL.ajax(bigliettoTrisComponents[0].url, optionsBiglietto);
                }});
            }}); 
        }

        if (SISAL.logger.isInfoEnabled())
        {
            SISAL.logger.info("validaGiocataTris - fine");
        }
    }

    /**
     * La funzione gioca le scommesse tris compilate
     * @return null
     */
    function giocaScommesseTris(gruppo, codtipo, ingioco)
    {
        if (SISAL.logger.isInfoEnabled())
        {
            SISAL.logger.info("giocaScommesseTris - inizio");
        }

        var cookie_login, ajaxUrl, sessioneValida, optionsBiglietto, importo, errore;
        
        // verifico validità della sessione
        SISAL.ajax(sessioneAjaxUrl, {async: false, response: true, success: function (result) {
            sessioneValida = result;
        }});
        if (SISAL.logger.isDebugEnabled())
        {
            SISAL.logger.debug("giocaScommesseTris - sessione <" + sessioneValida + ">");
        }
            
        if (sessioneValida === "OK")
        {
            // verifico validità della sessione login
            if (SISAL.MATCHPOINT.controlloSessioneLogin({html: "La sessione di gioco è scaduta. Per continuare a giocare effettua un nuovo login.", http: true}))
            {
                // controllo importo giocata minima in base al codice della scommessa (la prima in sessione)
                importo = importoVenditaSIP(gruppo, codtipo, gruppo + 1, 1);
                if (ingioco < importo)
                {
                    errore = "<p>" + recuperaMessaggio([-25, "Importo inferiore alla giocata minima di " + numberToValuta(importo / 100) + " &euro;.", importo], {func: "GIOCATATRIS"}) + "</p>";
                    SISAL.FX.showOnElement_TemplatePopup('body',
                            'mp.alert.buttonok.html', {
                        "TextAlign_default": "TextAlign_left",
                        "{title}" : "Biglietto Tris",
                        "{content}" : errore,
                        "{buttonclick}" : "<hideThis>",
                        "{buttontext}" : "OK",
                        width : '360px'
                    });
                    return;
                }
                
                // popup con clessidra per "giocata in corso...."
                SISAL.FX.showOnElement_TemplatePopup('body',
                        'mp.loading.html', {
                        "{content}" : "Scommessa in corso...",
                        width : '360px'
                    });
                    
                // chiamo servizio per effettuare la giocata
                ajaxUrl = giocataAjaxUrl + "concessione=4";
                SISAL.ajax(ajaxUrl, {success: function () {
                    // ricarico biglietto tris
                    optionsBiglietto = SISAL.copy(bigliettoTrisComponents[0].options);
                    optionsBiglietto.success = function () {
                        SISAL.ajax('/LoginNuovo/pubblico/servlet/saldo', {success: function () {
                            var saldo = SISAL.getCookieField("saldo", "saldoDisponibile"),
                                bonus = SISAL.getCookieField("saldo", "bonus"),
                                borsino = SISAL.getCookie("borsini");
                            saldo = isNaN(saldo) ? "" : numberToValuta(saldo / 100);
                            $('#saldoDisponibile').html("&euro; " + saldo);
                            $('#logoutSaldo').html(saldo + " &euro;");
                            bonus = isNaN(bonus) ? "" : numberToValuta(bonus / 100);
                            if (!SISAL.isNull(borsino))
                            {
                                borsino = borsino.match(new RegExp(".*\\D+" + 4 + "\\D*,\\D*(\\d+)\\D+.*"));
                                borsino = (SISAL.isNull(borsino) ? borsino : borsino[1]);
                                borsino = isNaN(borsino) ? "" : numberToValuta(borsino / 100);
                            }
                            $('#bonusScommesse').html("&euro; " + borsino);
                            $('#logoutBonus').html(bonus + " &euro;");
                        } });
                    };
                    SISAL.ajax(bigliettoTrisComponents[0].url + "?biglietto=ok", optionsBiglietto);
                }});
            }
        }
        else
        {
            // messaggio di sessione non attiva
            sessioneInattiva();
        }

        if (SISAL.logger.isInfoEnabled())
        {
            SISAL.logger.info("giocaScommesseTris - fine");
        }
    }

    return {
        contesto: contesto,
        components: components,
        menuComponents: menuComponents,
        arrayMessaggi: arrayMessaggi,
        sessioneAjaxUrl: sessioneAjaxUrl,
        scommessaAjaxUrl: scommessaAjaxUrl,
        rimuoviScommesseAjaxUrl: rimuoviScommesseAjaxUrl,
        giocataAjaxUrl: giocataAjaxUrl,
        sportComponents: sportComponents,
        bigliettoSportComponents: bigliettoSportComponents,
        listaScommesseSport: listaScommesseSport,
        listaQuoteSport: listaQuoteSport,
        sistemaSportComponents: sistemaSportComponents,
        sistemaSportNoComponents: sistemaSportNoComponents,
        sistemaSportCalcoloComponents: sistemaSportCalcoloComponents,
        totocalcioComponents: totocalcioComponents,
        bigliettoTotocalcioComponents: bigliettoTotocalcioComponents,
        totogolComponents: totogolComponents,
        bigliettoTotogolComponents: bigliettoTotogolComponents,
        ippicaComponents: ippicaComponents,
        bigliettoIppicaComponents: bigliettoIppicaComponents,
        listaScommessaIppica: listaScommessaIppica,
        trisComponents: trisComponents,
        bigliettoTrisComponents: bigliettoTrisComponents,
        listaScommessaTris: listaScommessaTris,
        incrementaDettagliSezione: incrementaDettagliSezione,
        decrementaDettagliSezione: decrementaDettagliSezione,
        riduciDettagliSezione: riduciDettagliSezione,
        evidenziaMenuAttivo: evidenziaMenuAttivo,
        evidenziaFiltroAttivo: evidenziaFiltroAttivo,
        numberToValuta: numberToValuta,
        sessioneInattiva: sessioneInattiva,
        stampaBiglietto: stampaBiglietto,
        verificaScommessa: verificaScommessa,
        caricaScommessa: caricaScommessa,
        cancellaScommessa: cancellaScommessa,
        cancellaScommesse: cancellaScommesse,
        checkImporto: checkImporto,
        checkImportoDecimal: checkImportoDecimal,
        impostaGiocata: impostaGiocata,
        calcolaQuota: calcolaQuota,
        determinaVincita: determinaVincita,
        calcolaVincita: calcolaVincita,
        giocaScommesse: giocaScommesse,
        mostraStatistiche: mostraStatistiche,
        disabilitaSistema: disabilitaSistema,
        riabilitaSistema: riabilitaSistema,
        abilitaSistema: abilitaSistema,
        aggiornaSistema: aggiornaSistema,
        calcolaSistema: calcolaSistema,
        calcolaCombinazioniTcal: calcolaCombinazioniTcal,
        cambioClasseTcal: cambioClasseTcal,
        pulisciAreaTcal: pulisciAreaTcal,
        pronosticoGiocatoTcal: pronosticoGiocatoTcal,
        verificaSchedinaTcal: verificaSchedinaTcal,
        cancellaSchedinaTcal: cancellaSchedinaTcal,
        giocaSchedinaTcal: giocaSchedinaTcal,
        calcolaCombinazioniTgol: calcolaCombinazioniTgol,
        cambioClasseTgol: cambioClasseTgol,
        pulisciAreaTgol: pulisciAreaTgol,
        pronosticoGiocatoTgol: pronosticoGiocatoTgol,
        verificaSchedinaTgol: verificaSchedinaTgol,
        cancellaSchedinaTgol: cancellaSchedinaTgol,
        giocaSchedinaTgol: giocaSchedinaTgol,
        calcoloScomIppica: calcoloScomIppica,
        checkedAllIppica: checkedAllIppica,
        cancellaScommessaIppica: cancellaScommessaIppica,
        validaGiocataIppica: validaGiocataIppica,
        giocaScommesseIppica: giocaScommesseIppica,
        calcoloScomTris: calcoloScomTris,
        checkedAllTris: checkedAllTris,
        cancellaScommessaTris: cancellaScommessaTris,
        validaGiocataTris: validaGiocataTris,
        giocaScommesseTris: giocaScommesseTris,
        recuperaMessaggio: recuperaMessaggio
    };
}());

/**
 * La variabile rappresenta una scorciatoia al namespace utilizzato per tutto il codice javascript di matchpoint - palinsesto.
 */
var PAL = SISAL.MATCHPOINT.PALINSESTO;

if (SISAL.logger.isInfoEnabled())
{
    SISAL.logger.info("SISAL.MATCHPOINT.PALINSESTO - namespace creato (scorciatoria: PAL)");
}