// Elenco degli errori
var Errori = new Array();
Errori['NulDov'] = "- Non è dovuta alcuna somma per questo immobile\n(è comunque necessario utilizzare 'Totalizza')";
Errori['SelImm'] = "- Devi selezionare un immobile su cui calcolare l'ICI";
Errori['ProNum'] = "- Il numero di poprietari residenti deve essere numerico";
Errori['ImmNum'] = "- Il valore dell'immobile deve essere numerico";
Errori['RenZer'] = "- Importo della rendita catastale uguale a 0!";
Errori['PerNum'] = "- La percentuale di possesso dell'immobile deve essere un valore numerico";
Errori['MesAnt'] = "- Il mese di inizio possesso è antecedente al mese di fine possesso";
Errori['PerPosInc'] = "- La percentuale di possesso è incongruente";
Errori['PerPosIncPro'] = "- La percentuale di possesso è incongruente con il numero di proprietari residenti";
Errori['DetConImm'] = "- Tipo di detrazione non consentito per questo immobile";
Errori['RidConImm'] = "- Tipo di riduzione non consentito per questo immobile";
Errori['CoeDetRid'] = "- Non è consentita la coesistenza di detrazione e riduzione";
Errori['NesImm'] = "- Nessun nuovo immobile calcolato";
Errori['PerPosPriCas'] = "- Il numero di mesi di possesso di una prima casa è superiore a 12!";
Errori['DetrPert'] = "Nota Bene:\n- La parte di detrazione riportata sulla pertinenza della prima casa è già di carattere personale, non verrà ulteriormente suddivisa fra i vari proprietari";
Errori['MaxNumPerAppNonLimitato'] = "- Numero massimo di detrazioni applicate a questa Abitazione Principale (altre pertinenze relative a questa Abitazione Principale sono da considerarsi \"Altri Immobili\")";
Errori['MaxNumPerAppLimitato'] = "- Se hai altre unità immobiliari non avevi diritto alla detrazione selezionata";
Errori['PriNonCorrispondente'] = "- Prima di calcolare una pertinenza deve essere calcolata la corrispondente abitazione";

// Elenco dei messaggi
var Messaggi = new Array();
Messaggi['DetrPert'] = "DETRAZIONE CONSENTITA PER LA PERTINENZA DELL'ABITAZIONE PRINCIPALE";

// Variabili globali
var jsDEBUG = 0;
var jsCALCOLATO = 0;
var jsTOTALEEDIFICI = 0;
var jsPOSSESSO1 = 0;
var jsPOSSESSO2 = 0;
var jsPOSSESSOTOT = 0;
var jsIMPORTO1 = 0.0;
var jsIMPORTO2 = 0.0;
var jsDETRA1 = 0.0;
var jsDETRA2 = 0.0;
var jsPOSSIBILESBILANCIO = false;

// Usate, da rivedere se si possono levare da una 'situazione' globale
var jsRestoDetraz = 0.0;
var jsRestoDetraz1 = 0.0;
var jsRestoDetraz2 = 0.0;

// Varibili globali per gestire gli immobili
var jsForm;
var jsMemoriaImm;
var jsTipoPertinenzaCalcolabile;

// Variable puntatore verso la finestra con i totali
var jsFinestraTotali = null;

/////////////////////////////////////////////////////////////////////////////
// Funzioni per la gestione/inizializzazione del form
/////////////////////////////////////////////////////////////////////////////

/////////////////////////////////////////////////////////////////////////////
// Funzione che: resetta il form, inizializza le variabili e legge i dati dal 
// file di testo
function jsAvvio()
{
   jsForm = window.document.forms[jsNomeForm]; // Riferimento al form

   // resetto il form
   jsResetta();

   jsForm.totedifici.value = 0.0;
   jsForm.agri1.value = 0.0;
   jsForm.agri2.value = 0.0;
   jsForm.fabb1.value = 0.0;
   jsForm.fabb2.value = 0.0;
   jsForm.prin1.value = 0.0;
   jsForm.prin2.value = 0.0;
   jsForm.altr1.value = 0.0;
   jsForm.altr2.value = 0.0;
   jsForm.detr1.value = 0.0;
   jsForm.detr2.value = 0.0;
   jsForm.detr11.value = 0.0;
   jsForm.detr12.value = 0.0;
   jsForm.possibilesbilancio.value = 0;
   
   // Annullo le variabili globali a livello "applicazione"
   jsTOTALEEDIFICI = 0.0;
   jsDetraz = 0.0;
   jsDetraz1 = 0.0;
   jsDetraz2 = 0.0;
   jsRestoDetraz = 0.0;
   jsRestoDetraz1 = 0.0;
   jsRestoDetraz2 = 0.0;

   // Array usato per tenere memoria degli immobili su cui e' stato fatto il calcolo
   jsMemoriaImm = new Array();

    //////////////////////////////////////////////////////////////////////////////
    // Creo un Array che mi tornerà particolarmente utile per gestire
    // le detrazioni collegate alle abitazioni principali (con tutti
    // i casi particolari che esse presentano)
    Detrazione = new Array();
    for (var i in aliquote)
    {
        if (aliquote[i].tipo == '3' ) 
        {
            var jsAppl = (aliquote[i].num_applicabilita_detr!=0
                ?aliquote[i].num_applicabilita_detr:Infinity);
            var jsMesi = (aliquote[i].num_applicabilita_detr!=0
                ?12:Infinity);
            var jsIdDet = aliquote[i].id_detrazione;
            var jsIdPer = aliquote[i].riferimento;

            Detrazione[i] = new Array();
            Detrazione[i]['mesi_possesso'] = jsMesi;
            Detrazione[i]['num_applicabilita'] = jsAppl;
            Detrazione[i]['id_pertinenza'] = jsIdPer;
            Detrazione[i]['pertinenze_applicate'] = 0;
            Detrazione[i][jsAnnoCorrente] = ( (det_valori[jsAnnoCorrente][jsIdDet] != null)?
                det_valori[jsAnnoCorrente][jsIdDet].valore : 0);
            Detrazione[i][jsAnnoVenturo] = 
                det_valori[jsAnnoVenturo][jsIdDet].valore;
            Detrazione[i]['max_num_immobili'] = (detrazioni[jsIdDet] != null ? detrazioni[jsIdDet].max_num_immobili : 0);
        }
    }
    if ( jsDEBUG > 4 )
    {
        for (var i in Detrazione)
        {
            alert(
                'I\t' + i + '\n'
                + 'Mesi possesso\t' + Detrazione[i]['mesi_possesso'] + '\n'
                + 'Num Applic\t' + Detrazione[i]['num_applicabilita'] + '\n'
                + 'Id Pertinenza\t' + Detrazione[i]['id_pertinenza'] + '\n'
                + 'Pertin App\t' + Detrazione[i]['pertinenze_applicate'] + '\n'
                + '\t' + jsAnnoCorrente + '\n'
                + 'Valore\t' + Detrazione[i][jsAnnoCorrente] + '\n'
                + '\t' + jsAnnoVenturo + '\n'
                + 'Valore\t' + Detrazione[i][jsAnnoVenturo] + '\n'
                + '\tMassimo numero di immobili applicabili\n'
                + 'Valore\t' + Detrazione[i]['max_num_immobili'] + '\n'
                );
        }
    }
}

/////////////////////////////////////////////////////////////////////////////
// Funzione che resetta il form
function jsResetta()
{
   // Annullo tutti i campi presenti nella form
   jsForm.selimmobile.selectedIndex = 0;
   jsForm.seldetrazione.selectedIndex = 0;
   jsForm.selriduzione.selectedIndex = 0;
   jsForm.dalmese.selectedIndex = 0;
   jsForm.almese.selectedIndex = 11;
   //jsForm.ali_corrente.value = 0;
   jsForm.ali_venturo.value = 0;
   //jsForm.det_corrente.value = 0;
   jsForm.det_venturo.value = 0;
   //jsForm.rid_corrente.value = 0;
   jsForm.rid_venturo.value = 0;
   jsForm.helpaliquota.value = "";
   jsForm.helpdetrazione.value = "";
   jsForm.helpriduzione.value = "";
   jsForm.valore.value = "";
   jsForm.percpossesso.value = 100;
   jsForm.npossessori.value = 1;
   jsForm.rata.value = 0.0;

   // Annullo le variabili globali utili ad ogni calcolo
   jsCALCOLATO = 0;
   jsPOSSESSO1 = 0;
   jsPOSSESSO2 = 0;
   jsPOSSESSOTOT = 0;
   jsIMPORTO1 = 0.0;
   jsIMPORTO2 = 0.0;
   jsDETRA1 = 0.0;
   jsDETRA2 = 0.0;
    jsPOSSIBILESBILANCIO = false;
}

/////////////////////////////////////////////////////////////////////////////
// Funzione per impostare in automatico le giuste detrazioni e riduzioni
/////////////////////////////////////////////////////////////////////////////

// Funzione che in automatico imposta il giusto commento e le giuste aliquote
// e nel caso l'utente stia calcolando l'ICI per una tipologia di 
// immobili prestabiliti imposta la giusta detrazione/riduzione 
function jsSettaImmobile()
{
    jsImmobileSel = jsRecuperaIdAliquota();

   //jsForm.ali_corrente.value = ali_percentuali[jsAnnoCorrente][jsImmobileSel].percentuale;
   jsForm.ali_venturo.value = ali_percentuali[jsAnnoVenturo][jsImmobileSel].percentuale;
   jsForm.helpaliquota.value = aliquote[jsImmobileSel].help;

   // Imposto eventuali detrazioni per l'immobile selezionato
   jsForm.seldetrazione.selectedIndex = aliquote[jsImmobileSel].id_detrazione;
   jsSettaDetrazione(aliquote[jsImmobileSel].id_detrazione);

   // Nel caso sia rimasta parte della detrazione per la pertinenza
   if (aliquote[jsImmobileSel].tipo == 5 && jsRestoDetraz > 0)
   {
      jsForm.seldetrazione.selectedIndex = 1; 
      //jsForm.det_corrente.value = jsArrotonda(jsRestoDetraz);
      jsForm.det_venturo.value = jsArrotonda(jsRestoDetraz);
      jsForm.helpdetrazione.value = Messaggi['DetrPert'];
   }

   // Imposto eventuali riduzioni per l'immobile selezionato
   jsForm.selriduzione.selectedIndex = aliquote[jsImmobileSel].id_riduzione;
   jsSettaRiduzione(aliquote[jsImmobileSel].id_riduzione);
}

// Funzione che in automatico imposta il giusto commento e le giuste aliquote
function jsSettaDetrazione()
{
    jsDetrazioneSel = jsRecuperaIdDetrazione();

   //jsForm.det_corrente.value = det_valori[jsAnnoCorrente][jsDetrazioneSel].valore;
   jsForm.det_venturo.value = det_valori[jsAnnoVenturo][jsDetrazioneSel].valore;
   jsForm.helpdetrazione.value = detrazioni[jsDetrazioneSel].help;
}

// Funzione che in automatico imposta il giusto commento e le giuste aliquote
function jsSettaRiduzione()
{
    jsRiduzioneSel = jsRecuperaIdRiduzione();

   //jsForm.rid_corrente.value = rid_frazioni[jsAnnoCorrente][jsRiduzioneSel].frazione;
   jsForm.rid_venturo.value = rid_frazioni[jsAnnoVenturo][jsRiduzioneSel].frazione;
   jsForm.helpriduzione.value = riduzioni[jsRiduzioneSel].help;
}

/////////////////////////////////////////////////////////////////////////////
// Funzioni per il calcolo dell'ICI
/////////////////////////////////////////////////////////////////////////////

// Funzione per fare il calcolo dell'ICI in base alle scelte dell'utente
function jsCalcolaIci()
{

   if (!jsCheckForm()) 
      return;

   // Recupero i mesi di possesso
   var jsDalMese = jsForm.dalmese.options.selectedIndex;
   var jsAlMese = jsForm.almese.options.selectedIndex;
   
   if ((jsDalMese < 6) && (jsAlMese < 6))
   {
      jsPOSSESSO1 = jsAlMese - jsDalMese + 1;
      jsPOSSESSO2 = 0;
   }
   if ((jsDalMese < 6) && (jsAlMese >= 6))
   {
      jsPOSSESSO1 = 6 - jsDalMese;
      jsPOSSESSO2 = parseInt(jsAlMese - 5);
   }
   if ((jsDalMese >= 6) && (jsAlMese >= 6))
   {
      jsPOSSESSO1 = 0;
      jsPOSSESSO2 = jsAlMese - jsDalMese + 1;
   }
   jsPOSSESSOTOT = (jsPOSSESSO1 + jsPOSSESSO2);

   if (!jsCheckDetrazioniRiduzioni()) 
      return;

   // Recupero gli indici delle select selezionati
   var jsImmobileSel = jsRecuperaIdAliquota();
   var jsDetrazioneSel = jsRecuperaIdDetrazione();
   var jsRiduzioneSel = jsRecuperaIdRiduzione();
   var jsImporto = 0;
   var jsImporto1 = 0;
   var jsImporto2 = 0;
   
   // Calcolo l'importo (partendo dalla rendita catastale) 
   // su cui calcolare l'ICI
   jsImporto = jsCalcolaImporto(jsForm.valore.value, 
        aliquote[jsImmobileSel].tipo,
        aliquote[jsImmobileSel].rivalutazione);

   jsImporto1 = jsImporto2 = jsImporto;

   // Calcolo l'importo della prima rata con l'aliquota corrente
   var jsImp1 = 0;
   if (ali_percentuali[jsAnnoCorrente][jsImmobileSel] != null) {

       ///////////////
       // RIDUZIONI //
       ///////////////
       // Calcolo l'importo ridotto in base alla funzione di riduzione propria
       // della riduzione selezionata
       if (rid_frazioni[jsAnnoCorrente][jsRiduzioneSel] != null && jsRiduzioneSel != 0) {
          jsImporto1 = eval(rid_frazioni[jsAnnoCorrente][jsRiduzioneSel].funzione 
             + '(jsImporto);');
       }

       jsImp1 = jsImporto1 / 1000.0;
       jsImp1 *= ali_percentuali[jsAnnoCorrente][jsImmobileSel].percentuale;
       jsImp1 = ((jsImp1 / 12.0) * jsPOSSESSO1);
       jsImp1 = ((jsImp1 / 100.0) * jsForm.percpossesso.value);
   }

   // Calcolo l'importo della prima rata
   jsIMPORTO1 = jsArrotonda(jsImp1);

   // Calcolo l'importo della seconda rata con l'aliquota corrente
   var jsImp2 = 0;

   ///////////////
   // RIDUZIONI //
   ///////////////
   // Calcolo l'importo ridotto in base alla funzione di riduzione propria
   // della riduzione selezionata
   if (rid_frazioni[jsAnnoVenturo][jsRiduzioneSel]) {
       jsImporto2 = eval(rid_frazioni[jsAnnoVenturo][jsRiduzioneSel].funzione 
          + '(jsImporto);');
   }

   jsImp2 = jsImporto2 / 1000.0;
   jsImp2 *= ali_percentuali[jsAnnoVenturo][jsImmobileSel].percentuale;
   jsImp2 = ((jsImp2 / 12.0) * jsPOSSESSOTOT);
   jsImp2 = ((jsImp2 / 100.0) * jsForm.percpossesso.value);

   jsIMPORTO2 = jsArrotonda(jsImp2 - jsIMPORTO1);

   // Rimetto insieme prima e seconda rata
   var jsDovuto = jsIMPORTO1 + jsIMPORTO2;

   if (jsDEBUG > 4) {
       alert('Importo uno: ' + jsIMPORTO1 + "\n"
            + 'Importo due: ' + jsIMPORTO2 + "\n");
   }

   // Controllo che non risultino diverse le due rate
   // per problemi di arrotondamento 
   if ( ( jsPOSSESSO1 == jsPOSSESSO2 ) 
      && ( ali_percentuali[jsAnnoCorrente][jsImmobileSel].percentuale == 
         ali_percentuali[jsAnnoVenturo][jsImmobileSel].percentuale ) 
      && ( jsIMPORTO1 != jsIMPORTO2 ) )
   {
        jsPOSSIBILESBILANCIO = true;
   }

   ////////////////
   // DETRAZIONE //
   ////////////////
   // Imposto il valore base della detrazione per l'abitazione principale
   if (aliquote[jsImmobileSel].tipo == 3 )
   {
      jsValoreDetrazione1 = Detrazione[jsImmobileSel][jsAnnoCorrente];
      jsValoreDetrazione2 = Detrazione[jsImmobileSel][jsAnnoVenturo];
   }
   // Imposto il valore base della detrazione per eventuali pertinenze
   if (aliquote[jsImmobileSel].tipo == 5)
   {
      jsValoreDetrazione1 = jsRestoDetraz;
      jsValoreDetrazione2 = jsRestoDetraz;
   }

   // Calcolo l'eventuale detrazione
   if ( aliquote[jsImmobileSel].tipo == 3 
      || aliquote[jsImmobileSel].tipo == 5 )
   {
      // Totale detrazione applicabile
      jsDetraz = ((jsValoreDetrazione2 / 12) * jsPOSSESSOTOT);
      if ( aliquote[jsImmobileSel].tipo == 3 )
        jsDetraz /= jsForm.npossessori.value;
      // Prima parte della detrazione
      jsDetraz1 = ((jsValoreDetrazione1 / 12) * jsPOSSESSO1);
      if ( aliquote[jsImmobileSel].tipo == 3 )
        jsDetraz1 /= jsForm.npossessori.value;
      jsDetraz1 = jsArrotonda(jsDetraz1);
      // Seconda parte della detrazione calcolata come differenza
      jsDetraz2 = jsArrotonda(jsDetraz - jsDetraz1);
        // Se non è dovuto nulla mostro il messaggio
        if ( jsArrotonda(jsDovuto - jsDetraz) <= 0)
        {
            window.alert(Errori['NulDov']);
            jsForm.rata.value = 0;
        }
        else
        {
            jsForm.rata.value = jsArrotonda(jsDovuto - jsDetraz);
        }
    }
    else
    {
        jsForm.rata.value = jsArrotonda(jsDovuto);
    }

   // Calcolo i resti di detrazione da riportare su eventuali pertinenze
   if ( (aliquote[jsImmobileSel].tipo == 3) 
      || (aliquote[jsImmobileSel].tipo == 5) )
   {
      jsRestoDetraz1 = jsDetraz1 - jsIMPORTO1;
      jsDetraz1 -= jsRestoDetraz1;
      jsRestoDetraz2 = jsDetraz2 - jsIMPORTO2;
      jsDetraz2 -= jsRestoDetraz2;
      jsDetraz -= (jsDetraz1 + jsDetraz2)
      if (jsDetraz <= 0)
      {
            jsDetraz1 += jsRestoDetraz1;
            jsDetraz2 += jsRestoDetraz2;
        }
    }
   
   jsDETRA1 = jsArrotonda(jsDetraz1);
   jsDETRA2 = jsArrotonda(jsDetraz2);

   jsCALCOLATO = true;

    if ( jsDEBUG > 2)
    {
        alert('Detrazioni'
            + '\njsDetraz\t' + jsDetraz 
            + '\njsDetraz1\t' + jsDetraz1 
            + '\njsDetraz2\t' + jsDetraz2
            + '\njsDETRA1\t' + jsDETRA1 
            + '\njsDETRA2\t' + jsDETRA2
            + '\njsRestoDetraz\t' + jsRestoDetraz 
            + '\njsRestoDetraz1\t' + jsRestoDetraz1 
            + '\njsRestoDetraz2\t' + jsRestoDetraz2 
            );
    }
}

// Funzione per controllare i dati inseriti nella Form
function jsCheckForm()
{
   var jsErrori = "Errori:"
   var jsErr = false;

   var jsImmobileSel = jsRecuperaIdAliquota();
   var jsDetrazioneSel = jsRecuperaIdDetrazione();
   
   // Controllo che il valore dell'immobile sia numerico
   if (jsImmobileSel  == 0) 
   {
      jsErrori += "\n" + Errori['SelImm'];
      jsSeleziona(jsForm.selimmobile);
      jsErr = true;
   }

   // Controllo che il numero di possidenti sia numerico
   if (isNaN(jsForm.npossessori.value)) 
   {
      jsErrori += "\n" + Errori['ProNum'];
      if (!jsErr) jsSeleziona(jsForm.npossessori);
      jsErr = true;
   }
   
   // Controllo che il valore dell'immobile sia numerico
   if (isNaN(jsForm.valore.value)) 
   {
      jsErrori += "\n" + Errori['ImmNum'];
      if (!jsErr) jsSeleziona(jsForm.valore);
      jsErr = true;
   }

   // Se il valore dell'immobile è zero lo segnalo!
   if (jsForm.valore.value == 0)
   {
      jsErrori += "\n" + Errori['RenZer'];
      if (!jsErr) jsSeleziona(jsForm.valore);
      jsErr = true;
   }

   // Controllo che la percentuale di possesso dell'immobile sia numerica
   if (isNaN(jsForm.percpossesso.value)) 
   {
      jsErrori += "\n" + Errori['PerNum'];
      if (!jsErr) jsSeleziona(jsForm.percpossesso);
      jsErr = true;
   }
   
   // Controllo che i mesi di possesso dell'immobile siano coerenti
   if (jsForm.dalmese.selectedIndex > jsForm.almese.selectedIndex) 
   {
      jsErrori += "\n" + Errori['MesAnt'];
      if (!jsErr) jsSeleziona(jsForm.dalmese);
      jsErr = true;
   }

   if (jsForm.percpossesso.value > 100)
   {
      jsErrori += "\n" + Errori['PerPosInc'];
      if (!jsErr) jsSeleziona(jsForm.percpossesso);
      jsErr = true;
   }

   if ((jsForm.percpossesso.value == 100) && (jsForm.npossessori.value > 1))
   {
      jsErrori += "\n" + Errori['PerPosIncPro'];
      if (!jsErr) jsSeleziona(jsForm.npossessori);
      jsErr = true;
   }

    if (aliquote[jsImmobileSel].tipo == 3)
    {
        if ( Detrazione[jsImmobileSel] != null && (Detrazione[jsImmobileSel]['mesi_possesso'] 
            - (jsForm.almese.selectedIndex-jsForm.dalmese.selectedIndex)) <= 0 )
        {
            jsErrori += "\n" + Errori['PerPosPriCas'];
            if (!jsErr) jsSeleziona(jsForm.selimmobile);
            jsErr = true;
        }
    }
    
    if ( aliquote[jsImmobileSel].tipo == 5 )
    {
        if ( jsTipoPertinenzaCalcolabile != jsImmobileSel )
        {
            jsErrori += "\n" + Errori['PriNonCorrispondente'];
            if (!jsErr) jsSeleziona(jsForm.selimmobile);
            jsErr = true;
        }
        if ( (Detrazione[aliquote[jsImmobileSel].riferimento]['pertinenze_applicate']
            >= jsNumPertinenzeConDetrazione))
        {
            if ( jsTOTALEEDIFICI 
                >= Detrazione[aliquote[jsImmobileSel].riferimento]['max_num_immobili'])
            {
                jsErrori += "\n" + Errori['MaxNumPerAppLimitato'];
            }
            else
            {
                jsErrori += "\n" + Errori['MaxNumPerAppNonLimitato'];
            }
            if (!jsErr) jsSeleziona(jsForm.selimmobile);
            jsErr = true;
        }
    }


   // In caso di errori
   if (jsErr) 
   {
      window.alert(jsErrori);
      return(false);
   }
   // Se va tutto bene
   return(true);
}

// Controllo la validità delle detrazioni e delle riduzioni selezionate
function jsCheckDetrazioniRiduzioni()
{
   var jsErrori = "Errori:"
   var jsErr = false;

   var jsImmobileSel = jsRecuperaIdAliquota();
   if (!jsImmobileSel) return(false);
   
   var jsDetrazioneSel = jsRecuperaIdDetrazione();
   var jsRiduzioneSel = jsRecuperaIdRiduzione();

    // L'utente può selezionare una detrazione per l'immobile sse:
    //      tipo = 5 <==> pertinenza
    //      detrazione.tipo = aliquota.tipo <==> abitazione principale
   if ((jsDetrazioneSel != 0) 
    && (aliquote[jsImmobileSel].tipo != 5) 
    && (detrazioni[jsDetrazioneSel].tipo != aliquote[jsImmobileSel].tipo) )
   {
      jsErrori += "\n" + Errori['DetConImm'];
      jsSeleziona(jsForm.seldetrazione);
      jsErr = true;
   }

    // L'utente può selezionare una riduzione per l'immobile sss:
    //      Terreni agr. a cond. diretta <==> Terreni agr. a cond. diretta
    //      Altri immobili <==> Immobile inagibile
    //      Altri fabbricati, terreni, aree fabbricabili (montemurlo) <==> Immobile inagibile
    if (jsRiduzioneSel==2) {
       if (jsImmobileSel!=6) {
            jsErrori += "\n" + Errori['RidConImm'];
            jsSeleziona(jsForm.selriduzione);
            jsErr = true;
       }
    } else if (jsRiduzioneSel==1) {
        if (!(jsImmobileSel==3 || jsImmobileSel==17 || jsImmobileSel==9 || jsImmobileSel==10 || jsImmobileSel==19)) {
            jsErrori += "\n" + Errori['RidConImm'];
            jsSeleziona(jsForm.selriduzione);
            jsErr = true;
        }
    }

    // Non è consentita la convivenza di Riduzione e Detrazione sullo
    // stesso immobile
   if ((jsDetrazioneSel != 0) && (jsRiduzioneSel != 0))
   {
      jsErrori += "\n" + Errori['CoeDetRid'];
      jsSeleziona(jsForm.selriduzione);
      jsErr = true;
   }

   // In caso di errori
   if (jsErr) 
   {
      window.alert(jsErrori);
      return(false);
   }
   // Se va tutto bene
   return(true);
}

// Funzione richiamata per totalizzare l'importo ICI appena calcolato
function jsCalcolaTot()
{
   if (!jsCheckCalcolaTot()) 
      return;

   // Recupero gli indici delle select selezionati
   var jsImmobileSel = jsRecuperaIdAliquota();
   var jsDetrazioneSel = jsRecuperaIdDetrazione();
   var jsRiduzioneSel = jsRecuperaIdRiduzione();

    // Segnalo un possibile caso di sbilancio nelle due rate
   //jsForm.possibilesbilancio.value = jsPOSSIBILESBILANCIO;
   jsForm.possibilesbilancio.value = false;

   if (aliquote[jsImmobileSel].totalizza_in == 'terreni')
   {
      jsForm.agri1.value = parseFloat(jsForm.agri1.value) + jsIMPORTO1;
      jsForm.agri2.value = parseFloat(jsForm.agri2.value) + jsIMPORTO2;
   }
   if (aliquote[jsImmobileSel].totalizza_in == 'aree')
   {
      jsForm.fabb1.value = parseFloat(jsForm.fabb1.value) + jsIMPORTO1;
      jsForm.fabb2.value = parseFloat(jsForm.fabb2.value) + jsIMPORTO2;
   }
   if (aliquote[jsImmobileSel].totalizza_in == 'principale')
   {
        if (aliquote[jsImmobileSel].tipo == 3)
        {
            jsForm.prin1.value = parseFloat(jsForm.prin1.value) + jsIMPORTO1;
            jsForm.prin2.value = parseFloat(jsForm.prin2.value) + jsIMPORTO2;
            jsForm.detr1.value = parseFloat(jsForm.detr1.value) + jsDETRA1;
            jsForm.detr2.value = parseFloat(jsForm.detr2.value) + jsDETRA2;
        }
        if (aliquote[jsImmobileSel].tipo == 5)
        {
            jsForm.altr1.value = parseFloat(jsForm.altr1.value) + jsIMPORTO1;
            jsForm.altr2.value = parseFloat(jsForm.altr2.value) + jsIMPORTO2;
            jsForm.detr11.value = parseFloat(jsForm.detr11.value) + jsDETRA1;
            jsForm.detr12.value = parseFloat(jsForm.detr12.value) + jsDETRA2;
        }
   }
   if (aliquote[jsImmobileSel].totalizza_in == 'altri')
   {
        if (aliquote[jsImmobileSel].tipo == 3 || aliquote[jsImmobileSel].tipo == 5)
        {
            jsIMPORTO1 -= jsDETRA1;
            jsIMPORTO2 -= jsDETRA2;
        }
      jsForm.altr1.value = parseFloat(jsForm.altr1.value) + jsIMPORTO1;
      jsForm.altr2.value = parseFloat(jsForm.altr2.value) + jsIMPORTO2;
   }

   jsForm.totedifici.value = ++jsTOTALEEDIFICI;

   // Aggiungo un nuovo immobile all'elenco di quelli calcolati
   jsMemoriaImm[jsTOTALEEDIFICI] = new Memoria(
      jsImmobileSel
      , jsForm.valore.value
      , jsForm.almese.options[jsForm.dalmese.options.selectedIndex].value 
      , jsForm.almese.options[jsForm.almese.options.selectedIndex].value
      , jsDetrazioneSel 
      , jsForm.npossessori.value
      , jsRiduzioneSel
      , jsForm.percpossesso.value
        );

    // Se l'immobile calcolato è una 'prima casa' con la possibilità 
    // di averne infinite riazzero il numero di pertinenze applicate
   if ( aliquote[jsImmobileSel].tipo == 3 )
    {
        jsTipoPertinenzaCalcolabile = Detrazione[jsImmobileSel]['id_pertinenza'];
        if (Detrazione[jsImmobileSel]['num_applicabilita'] == Infinity) 
        {
            Detrazione[jsImmobileSel]['pertinenze_applicate'] = 0;
        }
    }

   // Decremento il numero di pertinenze a cui è possibile
   // estendere la detrazione per la prima casa
   if ( aliquote[jsImmobileSel].tipo == 5 ) 
   {
        ++Detrazione[aliquote[jsImmobileSel].riferimento]['pertinenze_applicate'];
        if ( (Detrazione[aliquote[jsImmobileSel].riferimento]['pertinenze_applicate'] 
                >= jsNumPertinenzeConDetrazione)
            )
      {
         // Annullo il resto, puo' essere utilizzato per una sola pertinenza
         jsRestoDetraz = 0;
         jsRestoDetraz1 = 0;
         jsRestoDetraz2 = 0;
      }
   }

   // Parte restante della detrazione
   jsRestoDetraz = jsRestoDetraz1 + jsRestoDetraz2;
   if ( jsRestoDetraz < 0 ) jsRestoDetraz = 0; 

   if ( jsDEBUG > 2)
   {
        alert('Hidden'
            + '\nprin1 ' + jsForm.prin1.value 
            + '\nprin2 ' + jsForm.prin2.value 
            + '\ndetr1 ' + jsForm.detr1.value 
            + '\ndetr2 ' + jsForm.detr2.value 
            + '\ndetr11 ' + jsForm.detr11.value 
            + '\ndetr12 ' + jsForm.detr12.value
            + '\njsRestoDetraz ' + jsRestoDetraz
            );
   }

   // Reinizzializzo il form
   jsCALCOLATO = 0;
   jsResetta();
}

// Controllo che sia giusto calcolare il totale per i nuovi immobili 
function jsCheckCalcolaTot()
{
   var jsErrori = "Errori:"
   var jsErr = false;

   // Se non è stato calcolato nessun nuovo immobile
   if (!jsCALCOLATO)
   {
      jsErrori += "\n" + Errori['NesImm'];
      jsErr = true;
   }

   // Recupero gli indici delle select selezionati
   var jsImmobileSel = jsRecuperaIdAliquota();

   if (aliquote[jsImmobileSel].tipo == 3) 
   {
      if ( (Detrazione[jsImmobileSel]['mesi_possesso'] - jsPOSSESSOTOT) < 0 )
      {
         jsErrori += "\n" + Errori['PerPosPriCas'];
         jsErr = true;
      }
      else Detrazione[jsImmobileSel]['mesi_possesso'] -= jsPOSSESSOTOT;
    }
    
   // In caso di errori
   if (jsErr)
   {
      window.alert(jsErrori);
      return(false);
   }
   // Se va tutto bene
   return(true);
}

// Funzione che apre una nuova finestra in pop-up con i totali
// centra la finestra e gli dà il focus
function jsTotali($jsComune)
{
    var $jsWidth = parseInt(window.screen.availWidth);
    var $jsHeight = parseInt(window.screen.availHeight);
    var $jsUrl = "?com=" + $jsComune;
    
    // Se la rata da versa è inferiore ai 4.14 euro è possibile
    // versare solo in unica rata!
    // Recupero le variabili 'hidden' della pagina aprente
    var jsAgri1 = (!isNaN(jsForm.agri1.value)
        ? jsArrotonda(parseFloat(jsForm.agri1.value)) : 0);
    var jsAgri2 = (!isNaN(jsForm.agri2.value)
        ? jsArrotonda(parseFloat(jsForm.agri2.value)) : 0);
    
    var jsFabb1 = (!isNaN(jsForm.fabb1.value)
        ? jsArrotonda(parseFloat(jsForm.fabb1.value)) : 0);
    var jsFabb2 = (!isNaN(jsForm.fabb2.value)
        ? jsArrotonda(parseFloat(jsForm.fabb2.value)) : 0);
    
    var jsPrin1 = (!isNaN(jsForm.prin1.value)
        ? jsArrotonda(parseFloat(jsForm.prin1.value)) : 0);
    var jsPrin2 = (!isNaN(jsForm.prin2.value)
        ? jsArrotonda(parseFloat(jsForm.prin2.value)) : 0);
    
    var jsAltr1 = (!isNaN(jsForm.altr1.value)
        ? jsArrotonda(parseFloat(jsForm.altr1.value)) : 0);
    var jsAltr2 = (!isNaN(jsForm.altr2.value)
        ? jsArrotonda(parseFloat(jsForm.altr2.value)) : 0);
    
    var jsDetr11= (!isNaN(jsForm.detr11.value)
        ? jsArrotonda(parseFloat(jsForm.detr11.value)) : 0);
    var jsDetr12= (!isNaN(jsForm.detr12.value)
        ? jsArrotonda(parseFloat(jsForm.detr12.value)) : 0);
    
    var jsDetr1 = (!isNaN(jsForm.detr1.value)
        ? jsArrotonda(parseFloat(jsForm.detr1.value)) : 0) + jsDetr11;
    var jsDetr2 = (!isNaN(jsForm.detr2.value)
        ? jsArrotonda(parseFloat(jsForm.detr2.value)) : 0) + jsDetr12;

    var jsResto = (parseFloat(jsForm.resto.value) ? 1 : 0);

    // Se l'importo da pagare per l'abitazione principale
    // è inferiore alla detrazione
    if (jsPrin1 <= jsDetr1)
    {
        jsPrin2 -= (jsDetr1 - jsPrin1);
        jsPrin1 = 0;
    }
    else jsPrin1 = jsArrotonda(jsPrin1 - jsDetr1);

    if (jsPrin2 <= jsDetr2) jsPrin2 = 0;
    else jsPrin2 = jsArrotonda(jsPrin2 - jsDetr2);

    if (jsAltr1 <= jsDetr11) jsAltr1 = 0;
    else jsAltr1 = jsArrotonda(jsAltr1 - jsDetr11);

    if (jsAltr2 <= jsDetr12) jsAltr2 = 0;
    else jsAltr2 = jsArrotonda(jsAltr2 - jsDetr12);

    jsTot1 = jsAgri1 + jsFabb1 + jsPrin1 + jsAltr1;
    jsTot2 = jsAgri2 + jsFabb2 + jsPrin2 + jsAltr2;

    if ( (jsTot1 + jsTot2) <= 4.14) 
        $jsUrl += "&unica=si";

    jsFinestraTotali = window.open(jsNomePaginaTotali + $jsUrl,
        'Totali', 'location,menubar,status,toolbar,scrollbars,resizable');
    jsFinestraTotali.resizeTo($jsWidth,$jsHeight);
    jsFinestraTotali.moveTo(0,0);
    jsFinestraTotali.focus();
}

/////////////////////////////////////////////////////////////////////////////
// Altre funzioni di supporto
/////////////////////////////////////////////////////////////////////////////

// Funzione che rende intero il valore passatogli come parametro
function jsRendiIntero(jsVal)
{
   if (isNaN(jsVal)) return '1';
   return Math.floor(Math.abs(jsVal));
}

// Funzione che sostituisce le occorrenze delle virgole con punti
function jsSostituisciVirgole(jsRif)
{
   return jsRif.replace(/,/gi,".");
}

// Funzione che seleziona il contenuto di un campo di una form
function jsSeleziona(jsRif)
{
   if (jsRif.select) jsRif.select();
   if (jsRif.focus) jsRif.focus();
}

function jsCalcolaImporto(jsVal, jsTipo, jsRivalutazione)
{
  // Rivalutazione della rendita catastale tipica dell'immobile
  var jsTmp = (jsVal * jsRivalutazione);
  // Rivalutazione del 5% della rendita catastale per tutti gli immobili
  // ma non per i terreni
  if (jsTipo != 1 && jsTipo != 2) 
     jsTmp *= 1.05;
  // Per i terreni
  if (jsTipo == 1) 
     jsTmp *= 1.25;
  // Ritorno il valore calcolato
  return(jsTmp); 
}

// Funzione che avverte con un messaggio di errore e reimposta il valore
// dei proprietari residenti a 1 nel caso sia avanzata un po' di detrazione
// da riportare sulla pertinenza della prima casa
function jsValidaProprietari(jsRif)
{
   if ( jsRif.value > 1 
      && aliquote[jsRecuperaIdAliquota()].tipo == 5 )
   {
      window.alert(Errori['DetrPert']);
   }
}

// Funzione che si occupa di ritornare l'id dell'aliquota che è stata selezionata
function jsRecuperaIdAliquota()
{

    return jsForm.selimmobile.options[jsForm.selimmobile.options.selectedIndex].value;
}
// Funzione che si occupa di ritornare l'id dell'aliquota che è stata selezionata
function jsRecuperaIdDetrazione()
{
    return jsForm.seldetrazione.options[jsForm.seldetrazione.options.selectedIndex].value;
}
// Funzione che si occupa di ritornare l'id dell'aliquota che è stata selezionata
function jsRecuperaIdRiduzione()
{
    return jsForm.selriduzione.options[jsForm.selriduzione.options.selectedIndex].value;
}