// contient le nombre de criteres et le nombre de choix pour chaque critere
var criteria;

// contient l'ensemble des combinaisons possibles
var combinations;

// contient le code du modele derive
var model;

// contient le code des silhouettes
var images;

// contient les valeurs numeriques des prix
var priceValues;

// contient les libelles des prix
var priceLabels;

// contient l'indice de la version la moins chere
var less;

// contient l'indice de la version la moins chere
var most;

// contient le nombre de versions
var count;

// contient l'ensemble des choix en cours
var choices;

// contient l'indice du critere puis l'indice de la valeur forcee
var overchoice = [-1, -1];

// contient l'etat des differents choix presentes a l'utilisateur
var states;

// contient l'etat des case "non selectionne"
var unselStates;
    
// contient les indices des combinaisons valides avec les choix en cours
var subset;

// parties du texte de la barre de navigation
var navTitleSingle;
var navTitlePlur;
//var navTitlePlurPart1;
//var navTitlePlurPart2;
//var taxSuffix;

// nom des parametres
var specParamName;
var energyParamName;
var engineParamName;

// page cible
var nextPage;

// chemin pour les images
var imagePath;

// path complet de l'ilage par defaut
var defaultImage;

// pour taggage Weboscope
var weboSpecNames;
var weboEnabled;

var lessValue = 999999999;
var mostValue = 0;

// met a jour subset a partir des choix en cours
function selectCombinations() {
    // pas de choix : tout est compatible
    if (noChoice()) {
        subset.length = combinations.length;
        for (var i = 0; i < subset.length; i++) {
            subset[i] = i;
        }
    }
    // force un choix incompatible 
    else if (overchoice[0] != -1) {
        subset.length = 0;
        // d'abord selection des combinaisons compatibles
        var current = 0;
        for (var i = 0; i < combinations.length; i++) {
            if (combinations[i][overchoice[0]] == overchoice[1]) {
                subset[current++] = i;
            }
        }
        // puis on essaie de remettre les choix en cours
        for (var i = 0; i < choices.length; i++) {
            // si le choix concerne le même critere, ce dernier prend la nouvelle valeur
            if (i == overchoice[0]) {
                choices[i] = overchoice[1];
                continue;
            }
            else if (choices[i] == -1) {
                continue;
            }
            else {
                // verifie si le choix est toujours possible
                var newSubset = new Array();
                var n = 0;
                for (var j = 0; j < subset.length; j++) {
                    if (combinations[subset[j]][i] == choices[i]) {
                        newSubset[n++] = subset[j];
                    }
                }
                // si le choix est toujours compatibles on reduit subset avec
                if (newSubset.length > 0) {
                    subset = newSubset;
                }
                // sinon on le retire
                else {
                    choices[i] = -1;
                }
            }
        }
        // enfin on reinitialise overchoice        
        overchoice[0] = -1;
    }
    // selection des combinaisons compatibles
    else {
        subset.length = 0;
        var current = 0;
        for (var i = 0; i < combinations.length; i++) {
            var isCompatible = true;
            for (var j = 0; j < choices.length; j++) {
                if ((choices[j] != -1) && (choices[j] != combinations[i][j])) {
                    isCompatible = false;
                    break;
                }
            }
            if (isCompatible) {
                subset[current++] = i;
            }
        }
    }
    
    // met a jour les indices des prix min et max
	count = subset.length;
	lessValue = 999999999;
	mostValue = 0;
	
    for (var i = 0; i < subset.length; i++) 
	{
        if (parseInt(priceValues[subset[i]]) < lessValue) 
		{
			lessValue = priceValues[subset[i]];
			less = subset[i];
        }
        if (parseInt(priceValues[subset[i]]) > mostValue) 
		{
			mostValue = priceValues[subset[i]];
			most = subset[i];
        }
    }
}

function getPriceLess()
{
	return lessValue;
}

function getPriceMost()
{
	return mostValue;
}

// mets a jour l'etat des choix 
function updateStates() {
    // d'abord mets a jour l'etat des choix suivant les combinaisons valides de subset
    for (var i = 0; i < criteria.length; i++) {
        for (var j = 0; j < criteria[i]; j++) {
            // initialise a tout grise / non coche
            states[i][j] = 0;
            // parcours de subset pour recuperer les etats
            for (var k = 0; k < subset.length; k++) {
                if (combinations[subset[k]][i] == j) {
                    if (choices[i] == j) {
                        // compatible et selectionne : non grise / coche
                        states[i][j] = 3;
                    }
                    else {
                        // compatible et non selectionne : non grise / non coche
                        states[i][j] = 2;
                    }
                    break;
                }
            }
        }
    }
    // puis fait une deuxieme passe pour griser s'il ne reste qu'une solution et mettre a jour le choix "non selectionne"
    for (var i = 0; i < criteria.length; i++) {
        var n = 0;
        var last = 0;
        for (var j = 0; j < criteria[i]; j++) {
            // >1 = non grise
            if (states[i][j] > 1) {
                n++;
                last = j;
            }
        }
        // Une seule solution -> grise / coche sauf si selection courante (sinon tout risque d'être grise)
        if (n == 1) {
            if (choices[i] == -1) {
                states[i][last] = 1;
                // et on ne peut pas la deselectionner
                unselStates[i] = 0;
            }
            else {
                // pour ne pas que tout soit grise
                unselStates[i] = 2;
            }
        }
        else {
            if (choices[i] == -1) {
                // pas de choix fait mais plusieurs possibles : non grise / coche
                unselStates[i] = 3;
            }
            else {
                // choix fait parmi plusieurs possibles : non grise / non coche
                unselStates[i] = 2;
            }
        }
    }
}

// retourne true si aucun choix n'est encore fait, false sinon
function noChoice() {
    for (var i = 0; i < choices.length; i++) {
        if (choices[i] != -1) {
            return false;
        }
    }
    return true;
}

// change un choix suivant l'etat du choix
function changeChoice(i, j) {
	switch (states[i][j]) {
		// selection d'un choix incompatible
		case 0 :
			overchoice[0] = i;
			overchoice[1] = j;
			break;
		// selection d'un choix deja force : rien a faire
		case 1 :
			return false;
		// selection d'un choix compatible
		case 2 :
			choices[i] = j;
			break;
		// deselection d'un choix
		case 3 :
			choices[i] = -1;
			break;
	}
	selectCombinations();
	updateStates();
	return true;
}

// enleve un choix
function resetChoice(i) {
	// rien a faire si pas de choix
	if (choices[i] != -1) {
		choices[i] = -1;
		selectCombinations();
		updateStates();
		return true;
	}
	else {
		return false;
	}
}

// construit le nom du fichier image a partir de la silhouette (et evt du customer type)
function imageName(imgInfos) {
	var ext = ".gif";
	if (imgInfos.charAt(0) == 'j') {
		ext = ".jpg";
	}
	// avec finition et customer type
	if (imgInfos.length == 6) {
		return imagePath + model + "/" + imgInfos.substr(1, 2) + "/" + imgInfos.substr(3, 1) + "/" 
		+ imgInfos.substr(4, 2) + "/generic/vg_vu" + model + imgInfos.substr(1, 2) + imgInfos.substr(3, 1) + 
		imgInfos.substr(4, 2) + ext;
	}
	// avec finition
	else if (imgInfos.length == 4) {
		return imagePath + model + "/" + imgInfos.substr(1, 2) + "/" + imgInfos.substr(3, 1) + "/generic/vg_vu" + 
		model + imgInfos.substr(1, 2) + imgInfos.substr(3, 1) + ext;
	}
	// seulement body
	else if (imgInfos.length == 3) {
		return imagePath + model + "/" + imgInfos.substr(1, 2) + "/generic/vg_vu" + model + imgInfos.substr(1, 2) + ext;
	}
	// image par defaut
	else {
		return defaultImage;
	}
}

// creer les tableaux de taille variable
function initialize() {
	states = new Array(criteria.length);
	unselStates = new Array(criteria.length);
	subset = new Array();
	less = -1;
	most = -1;
	count = 0;	
    for (var i = 0; i < criteria.length; i++) {
        // creer les tableaux d'etat
        states[i] = new Array(criteria[i]);
    }
    var image = document.getElementById("ucPreviewCar_imgVehicle");
	selectCombinations();
	updateStates();
	updateDisplay();
}