window.onload = function() {
    generateQuestions();
}

function generateQuestions() {
  var section = document.querySelector("section.genpriklady");
  var header =  section.appendChild(document.createElement("h2"));
  
  header.innerHTML = "Příklady k procvičení"
  
    
  for (var i = 0; i < examples.length; i++) {
      var ex = section.appendChild(document.createElement("div"))
      ex.className = "question";
      ex.setAttribute("data-index", i);
      ex.innerHTML = generovatNahled(i); //examples[i].task
    
  }
  
}

var otazky = [];
var spravne = [];


function Otazka() {
  this.parametry = new Array()
  this.vystupy = new Array()
  this.zadani = ""
   
  
  this.setParametry = function(retez) {
  var pole = retez.split("\n");
  
  for (var i= 0; i< pole.length; i++) {
  
    this.parametry = this.parametry.concat(pole[i].split("$"))

    }
}
  this.setVystupy = function(retez) {
  var pole = retez.split("\n");
   this.vystupy = new Array()
    for (var i= 0; i< pole.length; i++) {
  
    this.vystupy = this.vystupy.concat(pole[i].split("$"))
    
    }
}
  
  
  
}

var actQuestion = null;
var actSet = null;

function generatePreviews() {
  var section = document.querySelector(".foundlist");
    section.innerHTML = "";
    
  var header =  section.appendChild(document.createElement("h2"));
  
  header.innerHTML = actSet.title //"Příklady k procvičení"
  
    
  for (var i = 0; i < actSet.examples.length; i++) {
      var ex = section.appendChild(document.createElement("div"))
      ex.className = "question";
      ex.setAttribute("data-index", i);
      ex.innerHTML = generovatNahled(i); //examples[i].task
    
  }
  
}


 function log(arg) {  return Math.log(arg)/Math.LN10 } 
 function ln(arg) { return Math.log(arg) }
 function sin(arg) { return Math.sin(arg) }
 function cos(arg) { return Math.cos(arg) }
 function tg(arg) { return Math.tan(arg) }
 function exp(arg) { return Math.exp(arg) }
 function sqrt(arg) { return Math.sqrt(arg) }
 function pow(arg1, arg2) { return Math.pow(arg1, arg2) }

  function des_carka(cislo) {
  
    var vystup = "" + cislo;
    vystup = vystup.replace(/\./g,",");
  
    if (vystup.charAt(0) ==",") vystup = "0" + vystup;
    return vystup
  }


function nahodne(spodni, horni,step) {
    
    if (typeof spodni == "object") { //zadano pole
        var index = Math.floor(spodni.length*Math.random());
        return spodni[index];
    }
    
    if (typeof spodni == "number" && typeof horni == "number") {
        return spodni + Math.random()*(horni-spodni)
    }
   return null;
   }
   
function zaokrouhlit(cislo, mista) {
   var cislo2 = Number(cislo)
   var pocet = Number(mista);
   return Math.round(cislo2 * Math.pow(10, pocet))/ Math.pow(10, pocet); 
   }

function roundToMF(cislo, mfs) {
    var nonzero = false;
    
   return cislo;
   var cislo2 = Number(cislo)
   var pocet = Number(mista);
    var power = Math.pow(10, pocet)
   return Math.round(cislo2 * power)/ power; 
   }
   
function interpol(poleX, poleY, x0) {
    var imin =0;
    var imax=0;
        
    for (var i = 1; i< poleX.length; i++) {
      if (poleX[i-1] < x0 && poleX[i] > x0) {
        imin = i-1;
        imax = i;
        break;
        
      }
    }
    
    return poleY[imin] + (poleY[imax]-poleY[imin])/(poleX[imax]-poleX[imin])*(x0 - poleX[imin])  
      
   }


function regenerate(node) {
    var question = node.parentNode.parentNode
    var index = parseInt(question.getAttribute("data-index"));
    
    question.innerHTML = generovatNahled(index);

}

function formatovatCislo(cislo) {
   cislo = Number(cislo);
  
    return cislo; 
   }


function generovatNahled(index) {
  
	
    var vystup ="";
    var otazka = examples[index];
    
	if (window.reactions) {
		otazka.reactions = otazka.reactions || getReactionLists(otazka);
	}
    
    
    
    var task = otazka.task //priklady[index*3 + 2]
    
    actQuestion = otazka;
    otazka.params = {};
    
    otazka.used = [];
    
    var solution = otazka.solution.join("");
    
    for (var i= 0; i< otazka.param_in.length; i++) {

        var vals = otazka.param_in[i].split(";");
        var newParam = { name: vals[0], value: "XXX", type: vals[1], round: 0, sf: 0, dp: 0 };
        /*
        type: nm - rucne zaokrouhleny, nr - zaokrouleny po vypoctu, t - textovy parametr, b - logicky parametr - t/f
        sf - pocet platnych cislic (significant figures)
        dp - pocet desetinnych mist (decimal places)
        */
        if (vals.length > 3) {
            newParam.round = vals[3];
        }
       report("-- " + newParam.name);
        report(vals[2]);
        
        nahrada = new RegExp("{" + newParam.name + "}","g");
                
        var result = evalExpr(otazka.used, vals[2], newParam.type)
        
        newParam.value = result[1];
        newParam.raw = result[1];
        
        var newValue = newParam.value;
        
        if (newParam.type === "nm") {
            var round = parseInt(vals[3]);
            newParam.value = zaokrouhlit(newParam.raw, vals[3]);
            var fixed = newParam.raw.toFixed(vals[3]);
            if (vals[3] == 0) fixed += ".";
            newParam.sf = getSigFigs(fixed);
            newParam.dp = round;
            
            report("NM: " + newParam.raw + ", rounded: " + newParam.value.toFixed(vals[3]) + ", sf: " + newParam.sf + ", dp:" + newParam.dp)
            
            newValue = newParam.raw.toFixed(vals[3]);
        }
       
        otazka.params[newParam.name] = newParam;
        
       otazka.used.push(newParam);
       task = task.replace(nahrada, (""+newValue).replace(".", ",")) 
       solution = solution.replace(nahrada, (""+newParam.value).replace(".", ",")) 
       
    }
    
    for (var i= 0; i< otazka.param_sol.length; i++) {
   
        var vals = otazka.param_sol[i].split(";");
        var newParam = { name: vals[0], value: 0};
                    
        for (var j = 0; j < otazka.used.length; j++) {
            var par = otazka.used[j]; 
            vals[1] = vals[1].replace(new RegExp(par.name, "g"), par.value )
        }
        
        nahrada = new RegExp("{" + newParam.name + "}","g");
        newParam.value = eval(vals[1]);
                
        if (vals[2].indexOf("nz") < 0) {
            newParam.value = zaokrouhlit(newParam.value, vals[2]);
            getCipherCount(newParam);
        }
       
       otazka.used.push(newParam);
        var val2 = ("" + newParam.value).replace(".", ",")
       solution = solution.replace(nahrada, val2) 
       
    }
    
    report("--- param out ----")
    //vstupni policka 
    
    spravne[index] = new Array();
      
      for (i= 0; i<  otazka.param_out.length; i++) { 
          
          var vals = otazka.param_out[i].split(";");
         
          var newParamOut = { name: vals[0], value: "XXX", type: vals[1], round: 0, sf: 0, dp: 0, tol: 0 }
         report("-- " + newParamOut.name);
          var result = evalExpr(otazka.used, vals[2], newParam.type)           
          newParamOut.value = result[1];
          
          var rounded = result[0].afterDot; //parseInt(vals[3]);
       
          var newValue = newParamOut.value;
          
        var nazev = ":n" + (i+1);
        if (newParamOut.type === "nm") {
            newParamOut.value = zaokrouhlit( newParamOut.value, rounded );
            newParamOut.dp = rounded;
        }
          
        if (newParamOut.type === "nr") {
            newValue = newParamOut.value.toFixed(rounded);
            newParamOut.dp = result[0].afterDot;
            newParamOut.sf = result[0].sigFigs;
        }
        
        var tolerance = vals[4].trim();
          if (tolerance.indexOf("%") > -1) {
              tolerance = tolerance.substring(0, tolerance.length-1);
              tolerance = parseFloat(tolerance)/100*newParamOut.value;
              
          }
          tolerance = zaokrouhlit(tolerance, newParamOut.dp);
        newParamOut.tol = tolerance;
        
        var nahrada = new RegExp("{" + newParamOut.name + "}","g");
          var nahrada_prec = "";
          if (task.indexOf(newParamOut.name + "-dp") > -1) {
             nahrada_prec = new RegExp("{" + newParamOut.name + "-dp}","g"); 
          }
     
      var prec = "(zaokrouhlete na ";
          if (newParamOut.dp == 0) {
              prec += "celé číslo)"
          }
          if (newParamOut.dp == 1) {
              prec += "1 des. místo)"
          }
          if (newParamOut.dp > 1 && newParamOut.dp < 5) {
              prec += newParamOut.dp + " des. místa)"
          }
          if (newParamOut.dp > 5) {
              prec += newParamOut.dp + " des. míst)"
          }
        
          var tolerance = "";
          if (newParamOut.type == "nm" || newParamOut.type == "nr") {
              tolerance = " ± " + newParamOut.tol;
          }
          
          if (newParamOut.type == "t") {
              prec = "";
              newParamOut.tol = ""
          }
          
          if (tolerance == " ± 0" || tolerance == " ± NaN" ) {
              tolerance = "";
          }
          
          var qid = "ot" + i + "_" + newParamOut.type + "_" + newParamOut.name;
          
          
          var fieldSize = "";
          var valLength = ("" + newValue + tolerance).length
          
          fieldSize = " style=' max-width: " + (valLength*0.8) + "em'"
          
          
          if (nahrada_prec == "") {
              task = task.replace(nahrada," <input type=\"text\" " + fieldSize + " name=\"ot" + qid  + "\" value='' /> " + prec);
          }
          else {
              task = task.replace(nahrada," <input type=\"text\" name=\"ot" + qid  + "\" value='' /> ");
              task = task.replace(nahrada_prec, prec);
              
          }
      
      solution = solution.replace(nahrada, ("" + newValue + tolerance).replace(".", ",") );
    
      spravne[index].push(newParamOut);
          
      otazka.params[newParamOut.name] = newParamOut;
        otazka.used.push(newParamOut);
      }
    task = "<div class='task'>" + task + "</div>"
     task += "<div class=\"feedback\">&nbsp;</div>"
     task += "<div class=\"zkontrolovat\"><input type=\"button\" value=\"Zkontrolovat\" onclick=\"checkAnswers(" + index + ")\" /> <input type=\"button\" value=\"Změnit zadání\" onclick=\"regenerate(this)\" /> <input type=\"button\" value=\"Zobrazit řešení\" onclick=\"toggleSolution(this)\" /></div>"
     
     task += "<div class='solution'>";
    task += solution;
    task += "</div>";
    
	if (task.indexOf("{schema}") > -1) {
		console.log("Schema")
		task = task.replace(/\{schema\}/g, generateSchema(actQuestion.reaction));
	}
	
	if (task.indexOf("{equation}") > -1) {
		task = task.replace(/\{equation\}/g, generateReaction(actQuestion.reaction));
	}
	
	
     //task += "<div class=\"dalsi\"></div>";
    
    //task += "<div class=\"toolbar\"><input type=\"button\" onclick=\"editQuestion(this)\" value=\"Upravit otázku\" /></div></div>";
    
    
  return vystup + task;
      
   }
 

function generateSchema(reaction) {
	var out = ["<span class='equation'>"];
	for (var i = 0; i < reaction.reagents.length; i++) {
		var item = reaction.reagents[i]
		if (i > 0) {
			out.push("<span class='divider2'>+</span>")
		}
		out.push(getHTMLFormula(item)); 
	}
	
	out.push("<span class='divider2'>→</span>")
	
	for (var i = 0; i < reaction.products.length; i++) {
		var item = reaction.products[i]
		if (i > 0) {
			out.push("<span class='divider2'>+</span>")
		}
		out.push(getHTMLFormula(item)); 
	}
	out.push("</span>")
	return out.join(" ");
}

function generateReaction(reaction) {
	var out = ["<span class='equation'>"];
	for (var i = 0; i < reaction.reagents.length; i++) {
		var item = reaction.reagents[i]
		var index = item.koef;
		if (index == 1) index = "";
		
		if (i > 0) {
			out.push("<span class='divider2'>+</span>")
		}
		out.push(index + " " +  getHTMLFormula(item)); 
	}
	
	out.push("<span class='divider2'>→</span>")
	
	for (var i = 0; i < reaction.products.length; i++) {
		var item = reaction.products[i]
		
		var index = item.koef;
		if (index == 1) index = "";
		
		if (i > 0) {
			out.push("<span class='divider2'>+</span>")
		}
		out.push(index + " " +getHTMLFormula(item)); 
	}
	out.push("</span>")
	return out.join(" ");
}


function getHTMLFormula(item) {
    var text = item.formula;
    
    var charge = ""
    if (text.indexOf("$")> 0) {
        var parts = text.split("$")
        text = parts[0]
        charge= "<sup>" + parts[1] + "</sup>";
    }
    
    text = text.replace(/(\d+)/g, "<sub>$1</sub>") + charge;    
    text = text.replace(/<\/sub><sup>/g, "</sub><sup class='nad1'>").replace(/-/g, "−").replace(/#/g, "≡");
    return "<span class='formula'>" + text + "</span>";
}

function getReactionLists(example) {
		
	var list =  [[],[],[],[]];	
	
	if (!example.prereq ) {
		for (var i = 0; i < reactions.length; i++) {
			for (var j = 0; j < reactions[i].length; j++) {
				list[i].push(j);
			}
		}	
		return list;
	}   
	/*
    if (!example.prereq || example.prereq.length == 0) {
        return reactions;        
    }
	*/
    var isSr = example.prereq.indexOf("solution-reagent") > -1; 
    var isGr = example.prereq.indexOf("gas-reagent") > -1; 
    var isSp = example.prereq.indexOf("solution-product") > -1; 
    var isGp = example.prereq.indexOf("gas-product") > -1; 

    
    if (isSr && isSp) return index_srsp;
    if (isSr && isGp) return index_srgp;
    if (isSp && isGr) return index_grsp;
    if (isSr) return index_sr;
    if (isSp) return index_sp;
    if (isGr) return index_gr;
    if (isGp) return index_gp;
    
    return list;
}

function toggleSolution(input) {
    var sol = input.parentNode.parentNode.querySelector(".solution");
    if (sol.style.display && sol.style.display == "block") {
        sol.style.display = "none";
        input.value = "Zobrazit řešení"
    }
    else {
        sol.style.display = "block";
        input.value = "Skrýt řešení"
    }
    
}

function getCipherCount(param) {
    var val = "" + param.value;
    param.afterDot = 0;
    param.sigFigs = 0;
    
    if (val.indexOf(".") > -1) {
        param.afterDot = val.length - 1 - val.indexOf(".");
        val = val.replace(".", "");
        var nonzero = false;
        for (var i = 0; i < val.length; i++) {
            if (!nonzero && val[i] == "0") {
                continue;
            }
            if (!nonzero) {
                param.sigFigs++;
                nonzero = true;
                continue;
            }
            if (nonzero) {
                param.sigFigs++;
            }
        }
    }
    else {
        var nonzero = false;
        for (var i = val.length-1; i >-1; i--) {
            if (!nonzero && val[i] == "0") {
                continue;
            }
            if (!nonzero) {
                param.sigFigs++;
                nonzero = true;
                continue;
            }
            if (nonzero) {
                param.sigFigs++;
            }
        }
    }
    console.log( "Param: " + param.name + ", " + param.value + ", desetiny: " + param.afterDot + ", pc: " + param.sigFigs)
}

function getSigFigs(nb) {
    var val = "" + nb;
    val = val.replace("-", "")
    var mf = 0;
    
    if (val.indexOf(".") > -1) {
        val = val.replace(".", "");
        var nonzero = false;
        for (var i = 0; i < val.length; i++) {
            if (!nonzero && val[i] == "0") {
                continue;
            }
            if (!nonzero) {
                mf++;
                nonzero = true;
                continue;
            }
            if (nonzero) {
                mf++;
            }
        }
    }
    else {
        var nonzero = false;
        for (var i = val.length-1; i >-1; i--) {
            if (!nonzero && val[i] == "0") {
                continue;
            }
            if (!nonzero) {
                mf++;
                nonzero = true;
                continue;
            }
            if (nonzero) {
                mf++;
            }
        }
    }
   return mf;
}

function evalExpr(params, expr, type) {
    //var expr = vals[1];
    var node = jsep(expr);
    return [node, evalExprNode (node)]
    
}

function evalExprNode( node, type) {
    //report(node.type)
    if (node.type == "Literal") {
        
        getCipherCount(node);
        node.sigFigs = 100;
        node.afterDot = 100;
        
        report("literal: " + node.value + ", sf: " + node.sigFigs + ", ad: " + node.afterDot);
        return node.value;
    }
    
    if (node.type == "Identifier") {
        var prom = actQuestion.params[node.name];
        
        
        node.value = prom.value;
        node.sigFigs = prom.sf;
        node.afterDot = prom.dp;
        
        report("Param: " + prom.name +  ", val:" + node.value +  ", sf: " + node.sigFigs + ", ad: " + node.afterDot)
        return prom.value;
    } 
    
    if (node.type == "UnaryExpression") { 
       report("UE: " + node.operator);
        if (node.operator == "-") {
            node.value = -evalExprNode(node.argument,type);
            node.sigFigs = node.argument.sigFigs;
            node.afterDot = node.argument.afterDot;
            return node.value;
        }
    }
    
   if (node.type == "BinaryExpression") {
      // report("BE: " + node.operator)
       var left = evalExprNode(node.left,type);
       var right = evalExprNode(node.right,type)
       var minAfter = Math.min(node.left.afterDot,node.right.afterDot);
       
        if (node.operator == "+") {
            node.afterDot = Math.min(node.left.afterDot,node.right.afterDot);
            node.afterDot = Math.max(node.afterDot,0);
            node.value = left + right; //zaokrouhlit(left + right, node.afterDot);
            node.sigFigs = getSigFigs(zaokrouhlit(node.value, node.afterDot));
            /*
            report("BE+l sf: " + node.left.sigFigs + ", ad: " + node.left.afterDot)
            report("BE+r sf: " + node.right.sigFigs + ", ad: " + node.right.afterDot)
            report("BE+ val:" + node.value +  ", sf: " + node.sigFigs + ", ad: " + node.afterDot)
            */
            return node.value;
        }
        if (node.operator == "-") {
            
            node.afterDot = Math.min(node.left.afterDot,node.right.afterDot);
            node.afterDot = Math.max(node.afterDot,0);
            node.value = left - right;
            node.sigFigs = getSigFigs(zaokrouhlit(node.value, node.afterDot));
            
            report("BE-l val:" + node.left.value +  ", sf: " + node.left.sigFigs + ", ad: " + node.left.afterDot)
            report("BE-r val:" + node.right.value +  ", sf: " + node.right.sigFigs + ", ad: " + node.right.afterDot)
            report("BE- val:" + node.value +  ", sf: " + node.sigFigs + ", ad: " + node.afterDot)
            
            return node.value;
        }
        
        if (node.operator == "*") {
            node.sigFigs = Math.min(node.left.sigFigs,node.right.sigFigs);
            node.value = left * right;
            node.afterDot = 0;
            
            var sigs = node.value.toPrecision(limitSigFigs(node.sigFigs));
            var dot = sigs.indexOf(".");
            if (dot > -1) {
                node.afterDot = sigs.length - dot - 1;
            }
            report("BE*l val: " +  node.left.value + ", sf: " + node.left.sigFigs + ", ad: " + node.left.afterDot)
            report("BE*r val: " +  node.right.value + ",sf: " + node.right.sigFigs + ", ad: " + node.right.afterDot)
            
            report("BE* val:" + node.value +  ", sf:" + node.sigFigs)
            //console.log("* " + node.sigFigs);
            
           return node.value;
        }
        if (node.operator == "/") {
            node.sigFigs = Math.min(node.left.sigFigs,node.right.sigFigs);
            
            node.value = left / right;   
            node.afterDot = 0;
            
            var sigs = node.value.toPrecision(limitSigFigs(node.sigFigs));
            var dot = sigs.indexOf(".");
            if (dot > -1) {
                node.afterDot = sigs.length - dot - 1;
            }
            report("BE/l val: " +  node.left.value + ", sf: " + node.left.sigFigs + ", ad: " + node.left.afterDot)
            report("BE/r val: " +  node.right.value + ", sf: " + node.right.sigFigs + ", ad: " + node.right.afterDot)
            
            report("BE/ val:" + node.value +  ", sf:" + node.sigFigs +  ", ad:" + node.afterDot)
            return node.value;
        }
        
    }
    
    if (node.type == "CallExpression") {
        
        console.log("CallExpression: " + node.callee.name);
        
        if (node.callee.object) {
            var name2 = node.callee.object.name, prop = node.callee.property.name; 
            report("-- fc:" + name2 + "." + prop);
            
            
        
            if (node.arguments.length == 2) {
                report("-- fc2 arg:" + node.arguments[0].type);
                
                return window[name2][prop](evalExprNode(node.arguments[0],type), evalExprNode(node.arguments[1],type))
            }
            
            if (node.arguments.length == 1) {
                
                var arg = evalExprNode(node.arguments[0],type);
                node.value = window[name2][prop](arg)
                if (prop == "floor") {
                    node.afterDot = 0;
                    node.sigFigs = 100;//getSigFigs(val.toFixed(0));
                }
                report("-- fc1 val: " + node.value + ", sf: " + node.sigFigs + ", ad: " + node.afterDot);
               
                return node.value;
            }
            if (node.arguments.length == 0) {
                node.sigFigs = 100;
                node.afterDot = 100;
                node.value = window[name2][prop]();
                report("-- fc0 val:" + node.value + ", sf: " + node.sigFigs + ", ad: " + node.afterDot);
                
               
                return node.value;
            }
            
        }
        if (node.callee.name == "getRandomElement") {
            actQuestion.element = getRandomElement();
            return actQuestion.element;
        }
        if (node.callee.name == "getRandomIon") {
            actQuestion.element = getRandomIon();
            return actQuestion.element;
        }
        
        if (node.callee.name == "getRandomReaction") {
            actQuestion.reaction = getRandomReaction();
            return actQuestion.reaction;
        }
        
        if (node.callee.name == "getReagent") {
            console.log("getReagent: " + node.arguments[0].toString());
            return getReagent(node.arguments[0].value);
        }
        
        if (node.callee.name == "nahodne") {
            if (node.arguments.length == 2) {
               
                return nahodne(node.arguments[0].value, node.arguments[1].value)
            }
            if (node.arguments.length == 1) {
                report("arg: " + node.arguments[0])
                return nahodne(evalExprNode(node.arguments[0],type))
            }
        }
        if (node.callee.name == "log") {
            var argObj = node.arguments[0];
            var arg = evalExprNode( argObj, type);
            node.value = log(arg);
           
            
            node.afterDot = argObj.sigFigs;
            node.sigFigs = getSigFigs(zaokrouhlit(node.value, node.afterDot));
             report("----log: val: " + node.value + ", sf:" + node.sigFigs + ", ad:" + node.afterDot);
            return node.value;
        }
        
        if (node.callee.name == "pow") {
            var argObj = node.arguments[0];
            var argObj2 = node.arguments[1];
            var arg1 = evalExprNode( argObj, type);
            var arg2 = evalExprNode( argObj2, type);
            node.value = pow(arg1, arg2);
            report("----pow: val: " + node.value + ", sf:" + argObj2.sigFigs + ", ad:" + argObj2.afterDot);
            
            node.sigFigs = argObj2.afterDot;
            var prec = node.value.toPrecision(limitSigFigs(node.sigFigs));
            node.afterDot = Math.max(0, prec.length - prec.indexOf(".") -1);
            
            return node.value;
        }
        
        if (node.arguments.length == 0) {
            return window[node.callee.name]()
        }
        if (node.arguments.length == 1) {
           return window[node.callee.name](evalExprNode(node.arguments[0],type))
        }
    
        
        
    }
    
    if (node.type == "MemberExpression") {
        var name = node.object.name || node.object.object.name , prop = node.property.name;
        
        report("Obj: " + name + "." + prop);
        console.log("Obj: " + name + "." + prop);
       
        if ( name == "data" )  {
            
            return window[node.object.name][node.property.name];
        }
        
        
        if (node.object.object) {
             report("Obj.obj.val: " + window[node.object.object.name][node.object.property.name][actQuestion.params[node.property.name].value]);
                return window[node.object.object.name][node.object.property.name][actQuestion.params[node.property.name].value];
            }
        
        if (name != "data" && name != "Math") {
            if (name.indexOf("data_") == 0) {
                var index = actQuestion.params[prop].value
                node.value = window[name][index];
                
                report("Array: " + name + "." + prop + " val: " + node.value);
                
                return node.value;
            }
            
            return actQuestion.params[name].value[prop]; //
        }
        
    }
    
}

function getFirstNonZero(number) {
    
    return 2;
    
}

function checkAnswers(index) {
   var ok = true;
   var vystup ="";
   var question =  document.querySelectorAll(".question")[index]
   
   var fb = question.querySelector(".feedback")
   
   var inputs = question.querySelectorAll("input[type=text]");
   
   for (var i =0; i< inputs.length; i++) {
         
       var parts = inputs[i].name.split("_");
       
       var pType = parts[1];
       var pname = parts[2];
     
       
       
    var hodnota = inputs[i].value;
    hodnota = hodnota.trim();
    hodnota = hodnota.replace(/,/g, ".");
       if (pType.indexOf("n") > -1) {
           
           hodnota = Number(hodnota);
           if (isNaN(hodnota)) {
      fb.innerHTML = "Špatně. Zadejte číslo!";
      return;
       }
       }
    /*
       
    }
  */
    var spr = getCorrect(index, pname); 
    console.log("Spravne: " + spr.value)
    var tolerance  = spr.tol;
       /*if (tolerance.indexOf("%") > -1) {
           tolerance = parseInt(tolerance.substring(0, tolerance.length-1), 10);
           tolerance = spr.value * tolerance/100;
       }*/
    var spravna = spr.value;
       console.log("T: " + spravna + " " + hodnota)
        if (pType == "t" && hodnota != spravna) {
            
            ok = false;
        }
       
       if (pType.indexOf("n") > -1) {
          if (hodnota > spravna + tolerance || hodnota < spravna - tolerance) ok = false; 
       }
    
   }
  if (ok) vystup = "<span class=\"spravne\">Správně.</span>"
  else vystup = "<span class=\"spatne\">Špatně.</span>";
  
  
  fb.innerHTML = vystup;
  }


  function getCorrect(index, name) {
 
  for(var i = 0; i < spravne[index].length; i++) {
    if (spravne[index][i].name == name) return spravne[index][i];
  }
  return null;
  }

function limitSigFigs(sfCount) {
    var out = Math.max(sfCount,1);
    out = Math.min(sfCount,21);
   return out; 
}


//parsovani vzorce - zjisteni poctu atomu, molarni hmotnosti
var actMol = null;

function Group() {
    this.atoms = [];
    this.multiply = 1;
    this.sub = []
    this.parent = null;
}

function getMolarWeight(reagent) {
    actMol = new Group();
    parseGroup(reagent.formula, actMol);
    decimalPlaces = 10;
    
    var out = getGroupMr(actMol);
    
    return out //.toFixed(decimalPlaces);
}


function parseGroup(text, group) {
    var pos = 0;
    var start = text.charAt(0);
    //console.log(text + ", " + group);
    if (start == "(") {
        var end = text.indexOf(")");
        var subtext = text.substring(pos + 1, end);
        
        end++
        var number = ""
        while ("1234567890".indexOf(text.charAt(end)) > -1 && end < text.length) {
            number += text.charAt(end);
            end++;
        }
        if (number == "") {number = 1;}
        else {number = parseInt(number, 10)}
        
        var subgroup = new Group();
        subgroup.multiply = number;
        parseGroup(subtext, subgroup);
        group.sub.push(subgroup);
        //console.log("Skupina - " + number)
        
        if (end < text.length) {
            parseGroup(text.substring(end), group)
        }
        return;
    }
    if (start == "[") {
        var end = text.indexOf("]");
        var subtext = text.substring(pos + 1, end);
        
        end++
        var number = ""
        while ("1234567890".indexOf(text.charAt(end)) > -1 && end < text.length) {
            number += text.charAt(end);
            end++;
        }
        if (number == "") {number = 1;}
        else {number = parseInt(number, 10)}
        
        var subgroup = new Group();
        subgroup.multiply = number;
        parseGroup(subtext, subgroup);
        group.sub.push(subgroup);
        //console.log("Skupina - " + number)
        
        if (end < text.length) {
            parseGroup(text.substring(end), group)
        }
        return;
    }
    
    var elemName = ""
    if (isUppercase(start)) {
        elemName = start;
        pos++;
                
        var next = text.charAt(pos);
        if(isLowercase(next) ) {
            elemName += next;            
            pos++;
            }
        var atom = [-1, 1];
        atom[0]  = getAtomIndex(elemName);
        
        var number = ""
        while ("1234567890".indexOf(text.charAt(pos)) > -1 && pos < text.length) {
            number += text.charAt(pos);
            pos++;
        }
        if (number == "") {number = 1;}
        else {number = parseInt(number, 10)}
        atom[1] = number;
        
        group.atoms.push(atom);
        
        //console.log(znacky[atom[0]] + "  - " +atom[1] )
        if (pos < text.length) {
            parseGroup(text.substring(pos), group)
        }
    }
  
}

function isUppercase(char) {
    var code = char.charCodeAt(0);
    return (code > 64 && code < 91);
}

function isLowercase(char) {
    var code = char.charCodeAt(0);
    return (code > 96 && code < 123);
}

function getAtomIndex(atom) {
    //console.log ("Hledam atom: " + atom)
    var index = znacky.indexOf(atom);
    return index;
}

var decimalPlaces = 10;



function getGroupMr(group) {
    var mr = 0;
    for (var i = 0; i < group.atoms.length; i++) {
        var atom = group.atoms[i]
        var Ar0 = Ar_hodnoty[atom[0]]
        decimalPlaces = Math.min(decimalPlaces, getDecimalPlaces(Ar0));
        
        mr += group.multiply*Ar0*atom[1];
    }
    
    for (var i = 0; i < group.sub.length; i++) {
        mr += getGroupMr(group.sub[i]);
    }
    return mr;
}

function getGroupElems(group) {
    var elems = [];
    
    for (atom of group.atoms) {
        elems.push(atom[0]);
    }
    
        
    for (var i = 0; i < group.sub.length; i++) {
        elems = elems.concat(getGroupElems(group.sub[i]));
    }
    
    return elems;
}

function getDecimalPlaces(number) {
    var nString = "" + number;
    var places = nString.substring(nString.indexOf(".")+1).length
    console.log("" + number + ": " + places);
    return places;
}


//pomocne funkce
   
   
  function getValue(nodeId) {
      return document.getElementById(nodeId).value;
    } 
    
    function setValue(nodeId, code) {
      document.getElementById(nodeId).value = code;
    }
    
    function setHTML(nodeId,code) {
      document.getElementById(nodeId).innerHTML = code;
    }
    function getHTML(nodeId) {
      return document.getElementById(nodeId).innerHTML;
    }
    
    function show(nodeId) {
      document.getElementById(nodeId).style.visibility = "visible";
    }
    
    
    function hide(nodeId) {
      document.getElementById(nodeId).style.visibility = "hidden";
    }
    
    function showBlock(nodeId) {
      document.getElementById(nodeId).style.display = "block";
    }
    function hideBlock(nodeId) {
      document.getElementById(nodeId).style.display = "none";
    }
  function disable (nodeId) {
    document.getElementById(nodeId).disabled = true;
  }
  function enable (nodeId) {
    document.getElementById(nodeId).disabled = false;
  }

 function Expr() {
   this.val = 0;
   this.roundCount = 0;
   this.sigFig = 0;
   this.tree = null;
   this.type = "simple";
   this.children = [];
   
   this.getRoundCount = function () {
      if (this.type == simple) return this.roundCount;
      if (this.type == "addition" || this.type == "subtraction") {
         return Math.min(this.children[0], this.children[1]);
      }
      if (this.type == "multiplication" || this.type == "division") {
         return Math.min(this.children[0], this.children[1]);
      }
   }
 }

function report(text) {
    document.getElementById("report").innerHTML += "<p>" + text + "<p>"
}

//window.addEventListener("load", initBase);