!7

// for sub-bots
please include function serveRedirect.
please include function serve403.
please include function serve404.
please include function serve500.
please include function serveFile.
please include function serveFileWithName.
please include function serveFile_maxCache.
please include function serveByteArray.
please include function serveByteArray_maxCache.
please include function serveInputStream.

sclass WebSocketWithWebRequest extends WebSocket {
  WebRequest request;
  
  *(NanoHTTPD.IHTTPSession session, WebRequest *request) {
    super(session);
  }
  
  IWebRequest webRequest() { ret request; }
}

sclass WebRequest implements IWebRequest {
  NanoHTTPD.IHTTPSession httpSession;
  S uri, subURI;
  SS params, files;
  S cookie, clientIP;
  Session session;
  bool isHttps, noSpam;
  
  *(NanoHTTPD.IHTTPSession *httpSession, S *uri, SS *params) {
    files = httpSession.getFiles();
    clientIP =  getClientIPFromHeaders(httpSession.getHeaders());
  }
  
  public S uri() { ret uri; }
  public SS params() { ret params; }
  public SS files() { ret files; }
  
  public SS headers() { ret httpSession.getHeaders(); }
  
  public S cookie() { ret cookie; }
  
  public bool isHttps() { ret isHttps; }
  
  User loggedInUser() {
    ret session == null ? null : session.user();
  }
  
  S googleClientID() {
    S domain = lower(domain());
    File jsonFile = googleClientSecretFileForDomain(domain);
    if (!fileExists(jsonFile)) null;
    
    Map map = decodeJSONMap(loadTextFile(jsonFile));
    map = (Map) map.get("web");
    ret (S) map.get("client_id");
  }
  
  public void noSpam {
    if (noSpam) ret;
    set noSpam;
    //print("noSpam count: " + simpleSpamClientDetect2_markNoSpam(clientIP, uri) + " (" + clientIP + "/" + uri + ")");
  }
}

concept User > ConceptWithGlobalID {
  long lastSeen;
}

concept CookieUser > User {
  S cookie;

  toString { ret "[cookieUser " + md5(cookie) + "]"; }
}

concept GoogleUser > User {
  long googleLogInDate;
  S googleEmail, googleFirstName, googleLastName;
  bool googleEmailVerified;

  toString { ret googleFirstName + " " + googleLastName; }
}

concept Session {
  S cookie;
  User user;
  long accesses;
  
  User user() {
    if (user == null)
      cset(this, user := uniq CookieUser(+cookie));
    ret user;
  }
}

abstract sclass DynEleuMultiIP extends DynPrintLogAndEnabled {
  transient autoDispose Set<WebSocketHTTPD> httpServers = syncLinkedHashSet();
  switchable int httpPort = 8000;
    
  double clearSessionsInterval = 60.0;
  double clearSessionsTimeout = 300.0;
  switchable double maxModuleReloadWait = 20.0;
  switchable double strayWebSocketDelay = 5.0;
  
  // Eleu-wide sessions... I don't think anyone uses these anymore
  switchable bool useSessions;
  
  void start {
    super.start();
    dbIndexing(Session, 'cookie, CookieUser, 'cookie, GoogleUser, 'googleEmail);
    dm_restartOnFieldChange enabled();
    if (!enabled) ret;
    dm_startThread("Start Web Servers", r {
      start_webServers(ipsToBindTo());
    });
    dm_doEvery(clearSessionsInterval, r clearSessions);
    
    //ownResource(serverSocketFactory_autoUpdate());
  }
  
  void clearSessions {
    Cl<Session> l = filter(list(Session),
      s -> s.accesses <= 1 && elapsedSeconds_timestamp(s.created) >= clearSessionsTimeout);
    if (nempty(l)) {
      print("Dropping " + nSessions(l));
      deleteConcepts(l);
    }
  }
  
  WebSocket newWebSocket(NanoHTTPD.IHTTPSession handshake) enter {
    vmBus_send haveNewWebSocket(module(), handshake);
    S domain = mapGet(handshake.getHeaders(), "host");
    S uri = handshake.getUri();
    SS params = handshake.getParms();
    print("Making WebSocket. domain: " + domain + ", uri: " + uri);
    WebRequest req = new(handshake, uri, params);
    WebSocket ws = new WebSocketWithWebRequest(handshake, req);
    
    S module = moduleForDomainAndURI(domain, uri);
    if (nempty(module) && !dm_moduleIsStartingOrReloading(module)) pcall {
      dm_callOpt(module, 'handleWebSocket, ws);
    } else {
      sleepSeconds(strayWebSocketDelay);
      ws.close(); // Hopefully just a reload
    }
      
    ret ws;
  }
  
  O webServe(S uri, SS params) {
    WebRequest req = new(NanoHTTPD.currentSession!, uri, params);
    print("IP: " + req.clientIP);
    
    /*Pair<Int, Bool> spamCheck = spamBlocker.checkRequest(req.uri, req.clientIP);
    if (spamCheck.b) {
      print("Request from blocked IP: " + req.clientIP);
      sleepSeconds(60.0);
      ret print("go away");
    }*/

    // fill more fields of WebRequest
    
    fillWebRequest(req);
    
    // log some
    
    printVars("webServe", +uri, userAgent := req.userAgent());
    
    // Serve Let's encrypt challenges
    
    if (startsWith(uri, "/.well-known/")) {
      S fileName = "validation.txt";
      /*if (swic(req.domain(), "www."))
        fileName = "validation-www.txt";*/
      ret loadTextFile(userDir(fileName));
    }
      
    S module = moduleForDomainAndURI(req.domain(), uri);
    if (nempty(module)) {
      if (sleepWhile(() -> dm_moduleIsStartingOrReloading(module), max := maxModuleReloadWait))
        ret subBot_serve500("Reload taking too long");
      ret eleu_callModuleHTMLMethod(module, req);
    }
    
    ret subBot_serve404();
  }

  // override me
  S moduleForDomain(S domain) { null; }
  
  // or me
  S moduleForDomainAndURI(S domain, S uri) { ret moduleForDomain(domain); }

  ServeHttp_CookieHandler makeCookieHandler() {
    ret nu ServeHttp_CookieHandler(verbose := true);
  }

  void fillWebRequest(WebRequest req) {  
    req.cookie = makeCookieHandler().handle();
    req.isHttps = false;
    
    // Get session
    req.session = nempty(req.cookie) && useSessions ? uniq Session(cookie := req.cookie) : null;
    if (req.session != null)
      cset(req.session, accesses := req.session.accesses+1);
    print(session := req.session);
  }
  
  /*void enhanceFrame(Container c) {
    super.enhanceFrame(c);
    internalFrameMenuItem(c, "Show blocked IPs", rEnterThread {
      print("Blocked IPs: " + spamBlocker.blockedIPs);
    });
  }*/

  // bind to all non-public IPs by default
  LS ipsToBindTo() {
    ret myLocalIPs();
  }
  
  void start_webServers(LS ips) {
    if (empty(ips))
      ret with print("No IPs to bind to");
      
    forEach_pcall(ips, ip -> {
      var httpd = new WebSocketHTTPD(ip, httpPort, lambda1 newWebSocket);
      httpd.enter = lambda0 enter;
      httpd.serveFunction = func(S uri, SS parms) { webServe(uri, parms) };
    
      ctex { httpd.start(); }
      httpServers.add(httpd);
      print("Web server started at http://" + ip + ":" + httpd.getPort());
    });
  }
} // end of module