/*
 * proof.js
 * Laengenpruefung
 *
 * $Id: proof.js 8235 2010-07-05 16:02:20Z rs $
 */


// Leere Objekte vorbereiten, die über nachgeladene
// Javascripts gefüllt werden.


var typeWidth = new Array();        // Schriftdefinition: Die Breite jedes einzelnen Buchstaben,
                                    // oder 0, wenn der Buchstabe hier nicht möglich ist.
var typeWidthL = new Array();       // Für jede Zeile eine Referenz auf eine Schriftdefinition
var maxWidthL = new Array();        // Die mögliche Breite jeder einzelnen Zeile
var charSpaceL = new Array();       // Durchschuss zwischen den Buchstaben

Proof = {


    motiveBaseUrl: "/lib/motive/",    // Aus diesem Directory werden die Motiv-Daten geladen.
    loadStatus: new Array(),          // für jeden Index mit motiveId entweder
                                      // "undefined", "loading" oder "ready"

    // Script mit Definitionen für das Motiv nachladen

    load: function(motiveId) {
        Proof.loadStatus[motiveId]="loading";
            $.getScript(Proof.motiveBaseUrl + "m_" + motiveId + ".js", function(){

            // Safari braucht noch ein wenig Zeit
            setTimeout(function(){Proof.loadStatus[motiveId] = "ready";}, 100);
        });
    },

    run: function(obj) {

        // Sind die Daten für das Motiv schon geladen?
        // Wenn nicht, laden.
        if(typeof(Proof.loadStatus[obj.motiveId])=="undefined") {
            obj.setStatus("loading");
            Proof.load(obj.motiveId);
            return;

        // wenn gerade geladen wird, nichts unternehmen
        } else if (Proof.loadStatus[obj.motiveId] == "loading") {
            obj.setStatus("loading");
            return;

        // ansonsten ist's wohl schon soweit und der Proof kann
        // durchgeführt werden
        } else if (Proof.loadStatus[obj.motiveId] == "ready") {
            obj.proof();
        }
   },

   // Nicht erlaubte Buchstaben in einer Zeile ersetzen
   replace: function(text, obj) {
        for(var i=0; i<text.length; i++) {  // alle Buchstaben durchgehen

            var char = text.charCodeAt(i);

            for(var i=0; i<text.length; i++) {                // alle Buchstaben durchgehen
                var char = text.charCodeAt(i);
                if(typeWidthL[obj.motiveId][obj.line][char]==0) {    // Dieser Buchstabe ist im aktuellen
                                                                    // Motiv nicht erlaubt
                    // Text an dieser Stelle zerschneiden
                    var before = text.substr(0,(i));
                    var after = text.substr(i+1);

                    // zwischenstück zusammenbauen
                    var replace = Proof.tryReplace(char, typeWidthL[obj.motiveId][obj.line], false);
                    text = before + replace + after;
                }
            }
            return text;
        }
   },

   /**
    * Liefert für den übergebenen Buchstabencode "char" einen Ersatzstring
    * zurück.
    * Parameter:
    *   char:      Code des Buchstabens
    *   charTable: Breitentabelle, aus der herausgesucht wird, ob der Bustabe
    *              hier erlaubt ist. 0 bedeutet, dass ersetzt werden muss
    *   seen:      Array mit bereits gesehenen, nicht gültigen Buchstaben
    */

    tryReplace: function(char, charTable, seen) {

        //var char   = char.charCodeAt(0);   // Nummer des Buchstaben
        var opts = repltable[char];    // Optionale Ersatzbuchstaben

        if (!opts) {         // gibt es dafür keine Ersartbuchstaben
            return null;     // wird's durch nichts ersetzt
        }

        if (!seen) {         // das kam schonmal
            seen = new Array();
        }

        for (var i = 0; i < opts.length; i++) { // Optionen durchgehen
            var valid = true;

            var opt = opts[i];          // Ein Buchstabe kann theoretisch auch durch
                                        // mehrere ersetzt werden, z.B. Ä => AE
            var replaceStr = '';        // Noch ist der Ersatz-String leer

            for (var letter = 0; letter < opt.length; letter++) {       // Alle Buchstaben in den möglichen
                                                                        // Ersatzbuchstaben durchgehen
                if (charTable[opt[letter]] == 0) {                      // Wenn der Buchstabe nicht erlaubt ist:
                    if (!seen[char]) {                                  // Wurde noch nicht gesehen?
                        seen[char] = true;                              // Auf gesehen setzen.
                                                                        // Ersetzen versuchen:
                        var repl = Proof.tryReplace(String.fromCharCode(opt[letter]), charTable, seen);

                        if (repl == null) {                             // wenn das nicht klappt
                            valid = false;                              // Flag setzen
                            break;
                        } else {                                        // Wenn es klappt
                            replaceStr = repl;                          // ist das der Ersatz für den Buchstaben
                        }
                    } else {                                            // Wurde schon gesehen und kann nicht ersetzt
                        valid = false;                                  // werden
                        break;
                    }
               } else {                                                    // Gefundenen Ersatz-Buchstaben anhängen
                  replaceStr += String.fromCharCode(opt[letter]);
               }
            }

         if(valid) {
               return replaceStr;
         }
      }
      return null;                        // Wenn nichts klappt, muss wohl der Buchstabe gelöscht werden
   },

   // Länge Prüfen
   checkLength: function(text, obj) {
    var length = 0;
    // Alle Buchstaben durchgehen
    for(var i=0; i<text.length; i++) {
     length += typeWidthL[obj.motiveId][obj.line][text.charCodeAt(i)];
    }
    var kerning = charSpaceL[obj.motiveId][obj.line] * (text.length-1);

       var length = 0;

       // Alle Buchstaben durchgehen
       for(var i=0; i<text.length; i++) {
           length += typeWidthL[obj.motiveId][obj.line][text.charCodeAt(i)];
       }
       var kerning = charSpaceL[obj.motiveId][obj.line] * (text.length-1);

       // console.log(text, length);

       return length + kerning;
   }
}