//Ethan Alexander Shulman 2016
//Procedural text generation from source text using something like a Markov Chain


var optionsOpen = false, outEle, optEle,
    generating = false,
    
    ge = function(s) {return document.getElementById(s);};

//initialize on load
window.onload = function() {
  outEle = ge("out");
  optEle = ge("opt");
  
  //initial generation
  setTimeout(gen);
};


//toggle options menu
function toggleOptions() {
  var outD = "none",
       optD = "none";
  if (optionsOpen) outD = "block";
  else optD = "block";
  
  outEle.style.display = outD;
  optEle.style.display = optD;
  
  optionsOpen = !optionsOpen;
}


//generate text
function gen() {
  if (generating) return;//only allow 1 generation at a time
  generating = true;
  
  var src = ge("source").value,
      wordSpace = ge("wordspace").checked,
      drunkenness = parseInt(ge("drunk").value)/100.0,
      seqDepth = parseInt(ge("depth").value),
      vocab = [], sa = new Sequence(seqDepth), ss;
  
  //build vocabulary
  if (wordSpace) {
    //word vocab
    ss = src.replace("\n","").split(" ");
    var i = ss.length;
    while (i--) {
      var ind = vocab.indexOf(ss[i]);
      if (ind === -1) {
        var ind = vocab.length;
        vocab.push(ss[i]);
        ss[i] = ind;
      } else {
        ss[i] = ind;
      }
    }
  } else {
    //letter vocab
    ss = new Uint32Array(src.length);
    var i = src.length;
    while (i--) {
      var ind = vocab.indexOf(src[i]);
      if (ind === -1) {
        ss[i] = vocab.length;
        vocab.push(src[i]);
      } else {
        ss[i] = ind;
      }
    }
  }
 
  //train/learn probabilities from source text
  var i = -1,
      l = ss.length;
  while (++i < l) {
      sa.In(String.fromCharCode(ss[i]));
  }

  
  //generate new text
  sa.Reset();
  var i = parseInt(ge("len").value),
      g = new Uint32Array(i),
      c = -1;
  while (++c < i) {
    var k = -1,
        r = sa.Next(drunkenness);
    
    if (r === -1) {
      r = ~~(Math.random()*vocab.length);//no next guess because there is no current memory state, seed with random vocab character
    }
      
    g[c] = r;
    sa.In(String.fromCharCode(r),true);
  }
  
  //convert generated new text from vocab to words/letters
  var out = "";
  var i = -1,
      l = g.length;
  while (++i < l) {
    out += vocab[g[i]];
    if (wordSpace) out += " ";
  }
  
  ge("out").innerHTML = out;
  generating = false;
}


function Sequence(memorySize) {
  this.memorySize = memorySize;
  this.memory = "";
  this.singleMemory = "";
  this.currentMemoryId = -1;
  this.singleMemoryId = -1;
  this.memories = [];
  this.probabilities = [];
  this.sums = [];
  this.nonWeightedSums = [];
}
//reset and clear memory
Sequence.prototype.Reset = function() {
  this.memory = "";
  this.currentMemoryId = -1;
}
//process input i
Sequence.prototype.In = function(i,dontLearn) {
  if (this.memory.length === this.memorySize) this.memory = this.memory.slice(1)+i;
  else this.memory += i;
  this.singleMemory = i;
  
  if (!dontLearn) {
    if (this.currentMemoryId !== -1 && this.singleMemoryId !== this.currentMemoryId) {
      var p = this.probabilities[this.currentMemoryId][i.charCodeAt(0)]++;
      if (p === 0) this.nonWeightedSums[this.currentMemoryId]++;
      this.sums[this.currentMemoryId]++;
    }
    if (this.singleMemoryId !== -1) {
      var p = this.probabilities[this.singleMemoryId][i.charCodeAt(0)]++;
      if (p === 0) this.nonWeightedSums[this.singleMemoryId]++;
      this.sums[this.singleMemoryId]++;
    }
  }
  
  this.currentMemoryId = this.memories.indexOf(this.memory);
  this.singleMemoryId = this.memories.indexOf(this.singleMemory);
  
  if (!dontLearn) {
    if (this.currentMemoryId === -1 && this.currentMemoryId !== this.singleMemoryId) {
      this.currentMemoryId = this.memories.length;
      this.probabilities.push(new Uint32Array(65565));
      this.sums.push(0);
      this.nonWeightedSums.push(0);
      this.memories.push(this.memory);
    }
    if (this.singleMemoryId === -1) {
      this.singleMemoryId = this.memories.length;
      this.probabilities.push(new Uint32Array(65565));
      this.sums.push(0);
      this.nonWeightedSums.push(0);
      this.memories.push(this.singleMemory);
    }
  }
}
//guess next character in sequence based on probabilities with a certain randomness(0-1)
Sequence.prototype.Next = function(randomness) { 
  //no current memory to guess next from
  var mId = this.currentMemoryId === -1 ? this.singleMemoryId : this.currentMemoryId;
  if (mId === -1) return -1;
  
  var rand = Math.random(),
      min = 0.0,
      i = -1,
      pa = this.probabilities[mId],
      ps = this.sums[mId],
      ds = randomness/this.nonWeightedSums[mId];
  if (ps === 0) return -1;//no probabilities to guess next from
  
  while (++i < 65565) {
    var len = (pa[i]/ps)*(1-randomness)+ds*(pa[i]>0?1:0),
        max = min+len;

    if (rand >= min && rand < max+1e-6) return i;
    min = max;
  }
  return 65564;
}