!7

sbool autoClose = true; // close JavaScript window on server lost
sbool autoTurnOn = true; // turn on recognition on program start
static int initialDelay = 0, autoCloseDelay = 5000;
static double firstWindowDelay = 0;
sbool infoBox, doLog = true;
sbool blipOnLanguageSwitch = true; // instead of "switching to..."
sbool blipOnActivation;
sbool hideChromeWindow;
sbool usePassiveLog; // use "passive" log (listening in background)

static int port;
static O onUtterance; // voidfunc(S)
sO onFirstWebSocket; // voidfunc()
static L<WebSocket> webSockets = synchroList();
sbool startRecognition;
static java.util.Timer stopper;
sS language = "en-US";
sS myURL;
static JButton btn;
sbool hadAnyWebSockets; // Does Chrome work at all?
sbool bigOn = true, justOnce = false;
static long speechRecognizerOpened;
static volatile S lastGlobalID;

p {
  load('language);
  if (isMainProgram()) {
    if (isMain()) substance();
    infoBox = true;
  }
  print("Logging speech to: " + speechRecognitionLog());

  NanoHTTPD.SOCKET_READ_TIMEOUT = 24*3600*1000; // not long enough - TODO: Fix in NanoHTTPD
  
  adjustMicrophoneLevel();
  
  port = serveHttpWithWebSockets(findFreePortAbove(9999), func(NanoHTTPD.IHTTPSession handshake) {
    print("New WebSocket.");
    WebSocket ws = new WebSocket(handshake) {
      protected void onPong(WebSocketFrame pongFrame) { print("pong"); }
      protected void onMessage(WebSocketFrame messageFrame) ctex {
        fS s = messageFrame.getTextPayload();
        //print("WebSocket message: " + s);
        cancelTimeout();
        infoBoxOrPrint(/*"User said: " +*/ s, infoBox); 
          //send("stop");
        //print("Sending start."); send("start");
        new Matches m;
        if (swic_trim(s, "Heard ", m))
          handleUtterance(decensor($1), false);
        else if (eqic(s, "big on")) bigOn = true;
        else if (eqic(s, "big off")) bigOn = false;
      }
      protected void onClose(WebSocketFrame.CloseCode code, String reason, boolean initiatedByRemote) {
        print("WebSocket closed.");
        webSockets.remove(this);
      }
      protected void onException(IOException e) { printStackTrace(e); }
    };
    if (startRecognition) {
      startRecognition = false;
      pcall { ws.send(justOnce ? "just once" : "big on"); }
      justOnce = false;
    }
    
    // close any other recognizers
    for (WebSocket ws2 : cloneList(webSockets)) {
      print("Closing websocket.");
      pcall { ws2.close(WebSocketFrame.CloseCode.NormalClosure, ""); }
      webSockets.remove(ws2);
    }
    
    if (!hadAnyWebSockets) {
      hadAnyWebSockets = true;
      pcallF(onFirstWebSocket);
    }
    
    ret addAndReturn(webSockets, ws);
  });
  myURL = print("http://localhost:" + port + "/popup");
  makeBot("Chrome Speech.");
  
  thread { sleepSeconds(firstWindowDelay); openSpeechRecognizer(); }
  
  if (isMain())
    showControls(jcenteredline(btn = jbutton("Open Speech Recognizer", f openSpeechRecognizer)));
  awtEvery(btn, 500, r { setEnabled(btn, empty(webSockets)) });
  
  /*thread "Chrome Re-Starter" {
    sleepSeconds(20);
    repeat with sleep 5 {
      if (hadAnyWebSockets && empty(webSockets)) {
        openSpeechRecognizer();
        sleepSeconds(15);
      }
    }
  });*/
  
  //if (autoTurnOn) startRecognition();
}

html {
  if (eqic(uri, "/favicon.ico"))
    ret serveFile(loadLibrary(#1013028), "image/x-icon");
    
  if (neq(uri, "/popup"))
    ret hbody("Opening popup..." + hjavascript([[
      window.open('/popup', 'speech_recognizer', 'width=300,height=300,location=no');
      setTimeout(function() { window.close(); }, 10000);
    ]]));

  // Serve Popup
  
  ret hhtml(hhead(htitle("Continuous Speech Recognizer")) + hbody(div(
    h3("Continuous Speech Recognizer")
    + [[<link id="favicon" rel="shortcut icon" type="image/png" href="/favicon.png" />]]
    + loadJQuery()
    + hdiv("Language: " + language, id := 'lang, style := "font-size: 10px")
    + hdiv("Results come here", id := 'results, style := "margin: 10px")
  + hjavascript([[
    var websocket;
    var bigOn = #BIGON#, pause = false, listening = false, language = "#LANGUAGE#", justOnce = #JUSTONCE#;
    //var stopUntil = 0;
    
    window.onfocus = function(event) {
      //if (event.explicitOriginalTarget === window)
        $("#btn").focus();
    };

    function update() {
      if (bigOn) {
        $("#btn").html("Turn off");
        document.title = (pause ? "Paused" : language.substring(3) /*"On"*/) + " - Speech Recognizer";
      } else {
        $("#btn").html("Turn on");
        document.title = "[OFF] Speech Recognizer";
      }

      var should = bigOn && !pause;
      if (should && !listening) startRecognition();
      else if (!should && listening) stopRecognition();
    }
    
    function stopRecognition() {
      listening = false;
      recognition.stop();
      update();
    }
    
    function startRecognition() {
      listening = true;
      //if (Date.now() < stopUntil) return;
      recognition.start();
      update();
    }
    
    function openWebSocket() {
      websocket = new WebSocket("ws://localhost:#PORT#/");
      websocket.onopen = function(event) {
        $("#btn").prop('disabled', false);
        $("#btn").focus();
        $("#results").html(bigOn ? "Listening." : "Click to turn me on.");
        if (bigOn)
          startRecognition();
      };
    
      websocket.onmessage = function(event) {
        if (event.data == 'just once') { justOnce = bigOn = true; update(); }
        if (event.data == 'big on') { bigOn = true; justOnce = false; update(); }
        if (event.data == 'big off') { bigOn = false; update(); }
        if (event.data == 'pause') { pause = true; update(); }
        if (event.data == 'unpause') { pause = false; update(); }
        if (event.data.substring(0, 9) == 'language ') {
          var l = event.data.substring(9);
          recognition.lang = language = l;
          $("#lang").html("Language: " + l);
        }
      };
    
      websocket.onclose = function(event) {
        $("#results").html("WebSocket closed");
        if (#AUTOCLOSE#) setTimeout(function() { window.close(); }, autoCloseDelay);
      };
    }
    
    setTimeout(openWebSocket, #INITIALDELAY#);
      
    var recognition = new webkitSpeechRecognition();
    recognition.lang = "#LANGUAGE#";
    
    recognition.onerror = function(event) { 
      var s = "&nbsp;";
      if (event.error != "no-speech") s = "Error: " + event.error;
      $("#results").html(s);
      //stopRecognition(); // do we get onEnd later?
      //setTimeout(startRecognition, 1000); // safety delay
    }
    
    recognition.onresult = function(event) { 
      var result = event.results[0];
      var transcript = result[0].transcript;
      var s = "Transcript: " + transcript;
      if (event.results.length > 1) s += " ." + event.results.length;
      if (result.length > 1) s += " #" + result.length;
      $("#results").html(s);
      websocket.send("Heard " + transcript);
      //stopUntil = Date.now()+200;
      //stopRecognition(); setTimeout(startRecognition, 100);
    }
    
    recognition.onnomatch = function(event) {
      $("#results").html("-");
      //stopRecognition(); setTimeout(startRecognition, 100);
    }
    
    recognition.onend = function(event) { 
      //$("#results").html("-end-");
      //stopRecognition();
      if (justOnce) justOnce = bigOn = false;
      listening = false; setTimeout(update, 100);
    }
    
    function startOrStop() {
      bigOn = !bigOn;
      websocket.send(bigOn ? "big on" : "big off");
      update();
    }
    
    window.resizeTo(300, 300);
  ]]) // end of JavaScript, variables follow
    .replace("#BIGON#", str(autoTurnOn))
    .replace("#JUSTONCE#", str(justOnce))
    .replace("#PORT#", str(port))
    .replace("#AUTOCLOSE#", autoClose ? "true" : "false")
    .replace("#INITIALDELAY#", str(initialDelay))
    .replace("#LANGUAGE#", language)
    .replace("autoCloseDelay", str(autoCloseDelay))
    + tag('button, "...", onclick := "startOrStop()", type := 'button, id := 'btn, disabled := 'disabled)
    + hdiv("", id := 'msgs, style := "margin: 10px; font-size: 10px")
    //+ p(ahref("#", "Popup", onClick := "window.open('/', 'speech_recognizer', 'width=300,height=300,location=no'); return false;"));
  , style := "text-align: center"));
}

svoid justOnce() { startRecognition(true); }
svoid startRecognition() { startRecognition(false); }

svoid startRecognition(bool justOnce) {
  main.justOnce = justOnce;
  bigOn = true;
  L<WebSocket> l = cloneList(webSockets);
  if (empty(l)) startRecognition = true;
  else {
    //print("Starting recognition." + (l(l) > 1 ? "Weird: Have " + l(l) + " websockets" : ""));
    pcall {
      first(l).send(justOnce ? "just once" : "big on");
    }
    justOnce = false;
  }
}

svoid stopRecognition() {
  bigOn = false;
  if (startRecognition) startRecognition = false;
  if (nempty(webSockets)) pcall {
    first(webSockets).send("big off");
  }
}

sS hotCommands(S s) {
  if (ai_isStopListeningCommand(s)) { stopRecognition(); playBlip(); ret "OK"; }
  S language = ai_extractChangeLanguageCommand(s);
  if (eq(language, 'english)) ret answer("language " + quote("en-US"));
  if (eq(language, 'german)) ret switchToGerman();
  null;
}

answer {
  try answer hotCommands(s);
  if "start recognition timeout *" {
    final int seconds = parseInt($1);
    startRecognition();
    stopper = timerOnce(toMS(seconds), f stopRecognition);
    ret "OK";
  }
  if "is on" ret yesno(bigOn);
  if "has recognizer" ret yesno(nempty(webSockets));

  if "just once" {
    if (nempty(webSockets)) justOnce();
    else {
      justOnce = true;
      openSpeechRecognizerIfNone();
    }
    ret "OK";
  }
  
  if "start recognition" {
    openSpeechRecognizerIfNone();
    if (nempty(webSockets)) {
      bool on = bigOn;
      startRecognition();
      if (!on && blipOnActivation) blip();
    }
    ret "OK";
  }
  
  if "language *" {
    if (eq(language, $1)) ret "OK";
    setAndSave('language, $1);
    if (blipOnLanguageSwitch) blip(); else
      if (eq(language, "de-DE")) william("Switching to German");
        else william("Switching to English");
    pcall { if (nempty(webSockets)) first(webSockets).send("language " + $1); }
    stopRecognition();
    sleep(500);
    startRecognition();
    ret "OK";
  }
  
  if "user typed *" ret "OK" with handleUtterance($1, true);
  
  if "stop recognition" { stopRecognition(); ret "OK"; }
  
  if "use passive log" { usePassiveLog = true; ret "OK"; }
  if "use active log" { usePassiveLog = false; ret "OK"; }
  
  if "log on" { doLog = true; ret "OK"; }
  if "log off" { doLog = false; ret "OK"; }
}

svoid cancelTimeout {
  if (stopper != null) { stopper.cancel(); stopper = null; }
}

sS switchToGerman {
  ret answer("language " + quote("de-DE"));
}

svoid handleUtterance(fS s, final bool typed) {
  if (isStefanReichsPC()) {
    mechAppendQ_noUniq("Katze Speech Recognition Log With Date", "[" + localDateWithMilliseconds() + (typed ? ", typed" : "") + "] " + s);
    Map map = litorderedmap(
      where := typed ? "typed" : "voice",
      type := 'heard,
      date := localDateWithMilliseconds(),
      globalID := lastGlobalID = aGlobalID(),
      text := s);
    mechAppendQ_noUniq("Voice I/O Log", struct(map));
  }
  
  S info = typed ? "User typed" : "Chrome Speech";
  vmBus_send googleSpeechRecognized(s, info);
  
  if (doLog)
    logQuoted(usePassiveLog ? passiveSpeechRecognitionLog() : speechRecognitionLog(), now() + " [" + info + "] " + s);
  
  thread {
    pcallF(onUtterance, s);
  }
  hotCommands(s);
}

svoid openSpeechRecognizer {
  speechRecognizerOpened = sysNow();
  if (hideChromeWindow)
    startInvisibleChromeAppForSpeech(myURL);
  else
    startChromeAppForSpeech(myURL);
}

svoid openSpeechRecognizerIfNone {
  if (empty(webSockets) && sysNow() >= speechRecognizerOpened + 5000)
    openSpeechRecognizer();
}

sS decensor(S s) { ret googleDecensor_static(s); }