#include <sys/stat.h>
#include "output_http_internal.h"
#include <mist/stream.h>
#include <mist/encode.h>
#include <mist/langcodes.h>
#include "flashPlayer.h"
#include "oldFlashPlayer.h"
#include <mist/websocket.h>

namespace Mist {
  /// Helper function to find the protocol entry for a given port number
  std::string getProtocolForPort(uint16_t portNo){
    std::string ret;
    Util::DTSCShmReader rCapa(SHM_CAPA);
    DTSC::Scan conns = rCapa.getMember("connectors");
    Util::DTSCShmReader rProto(SHM_PROTO);
    DTSC::Scan prtcls = rProto.getScan();
    unsigned int pro_cnt = prtcls.getSize();
    for (unsigned int i = 0; i < pro_cnt; ++i){
      DTSC::Scan capa = conns.getMember(prtcls.getIndice(i).getMember("connector").asString());
      uint16_t port = prtcls.getIndice(i).getMember("port").asInt();
      //get the default port if none is set
      if (!port){
        port = capa.getMember("optional").getMember("port").getMember("default").asInt();
      }
      if (port == portNo){
        ret = capa.getMember("protocol").asString();
        break;
      }
    }
    if (ret.find(':') != std::string::npos){
      ret.erase(ret.find(':'));
    }
    return ret;
  }

  OutHTTP::OutHTTP(Socket::Connection & conn) : HTTPOutput(conn){
    stayConnected = false;
    if (myConn.getPureSocket() >= 0){
      std::string host = getConnectedHost();
      dup2(myConn.getSocket(), STDIN_FILENO);
      dup2(myConn.getSocket(), STDOUT_FILENO);
      myConn.drop();
      myConn = Socket::Connection(fileno(stdout),fileno(stdin) );
      myConn.setHost(host);
    }
    if (config->getString("nostreamtext").size()){
      setenv("MIST_HTTP_nostreamtext", config->getString("nostreamtext").c_str(), 1);
    }
    if (config->getString("pubaddr").size()){
      setenv("MIST_HTTP_pubaddr", config->getString("pubaddr").c_str(), 1);
    }
    if (config->getOption("wrappers",true).size() == 0 || config->getString("wrappers") == ""){
      JSON::Value & wrappers = config->getOption("wrappers",true);
      wrappers.shrink(0);
      jsonForEach(capa["optional"]["wrappers"]["allowed"],it){
        wrappers.append(*it);
      }
    }
  }

  OutHTTP::~OutHTTP() {}
  
  bool OutHTTP::listenMode(){
    return !(config->getString("ip").size());
  }
  
  void OutHTTP::onFail(const std::string & msg, bool critical){
    std::string method = H.method;
    // send logo icon
    if (H.url.length() > 4 && H.url.substr(H.url.length() - 4, 4) == ".ico"){
      sendIcon();
      return;
    }
    if (H.url.length() > 6 && H.url.substr(H.url.length() - 5, 5) == ".html"){
      HTMLResponse();
      return;
    }
    if (H.url.size() >= 3 && H.url.substr(H.url.size() - 3) == ".js"){
      if (websocketHandler()){return;}
      JSON::Value json_resp;
      json_resp["error"] = "Could not retrieve stream. Sorry.";
      json_resp["error_guru"] = msg;
      if (config->getString("nostreamtext") != ""){
        json_resp["on_error"] = config->getString("nostreamtext");
      }
      if (H.url.size() >= 5 && H.url.substr(0, 5) == "/json"){
        H.Clean();
        H.SetBody(json_resp.toString());
      }else{
        H.Clean();
        H.SetBody("if (!mistvideo){var mistvideo = {};}\nmistvideo['" + streamName + "'] = "+json_resp.toString()+";\n");
      }
      H.setCORSHeaders();
      if(method == "OPTIONS" || method == "HEAD"){
        H.SendResponse("200", "OK", myConn);
        H.Clean();
        return;
      }
      H.SendResponse("200", "Stream not found", myConn);
      H.Clean();
      return;
    }
    HTTPOutput::onFail(msg, critical);
  }

  void OutHTTP::init(Util::Config * cfg){
    HTTPOutput::init(cfg);
    capa.removeMember("deps");
    capa["name"] = "HTTP";
    capa["desc"] = "Generic HTTP handler, required for all other HTTP-based outputs.";
    capa["provides"] = "HTTP";
    capa["protocol"] = "http://";
    capa["codecs"][0u][0u].append("*");
    capa["url_rel"] = "/$.html";
    capa["url_match"].append("/crossdomain.xml");
    capa["url_match"].append("/clientaccesspolicy.xml");
    capa["url_match"].append("/$.html");
    capa["url_match"].append("/favicon.ico");
    capa["url_match"].append("/$.smil");
    capa["url_match"].append("/info_$.js");
    capa["url_match"].append("/json_$.js");
    capa["url_match"].append("/player.js");
    capa["url_match"].append("/player.css");
    capa["url_match"].append("/videojs.js");
    capa["url_match"].append("/dashjs.js");
    capa["url_match"].append("/embed_$.js");
    capa["url_match"].append("/flashplayer.swf");
    capa["url_match"].append("/oldflashplayer.swf");
    capa["optional"]["wrappers"]["name"] = "Active players";
    capa["optional"]["wrappers"]["help"] = "Which players are attempted and in what order.";
    capa["optional"]["wrappers"]["default"] = "";
    capa["optional"]["wrappers"]["type"] = "ord_multi_sel";
    /*capa["optional"]["wrappers"]["allowed"].append("theoplayer");
    capa["optional"]["wrappers"]["allowed"].append("jwplayer");*/
    capa["optional"]["wrappers"]["allowed"].append("html5");
    capa["optional"]["wrappers"]["allowed"].append("videojs");
    capa["optional"]["wrappers"]["allowed"].append("dashjs");
    //capa["optional"]["wrappers"]["allowed"].append("polytrope"); //currently borked
    capa["optional"]["wrappers"]["allowed"].append("flash_strobe");
    capa["optional"]["wrappers"]["allowed"].append("silverlight");
    capa["optional"]["wrappers"]["allowed"].append("img");
    capa["optional"]["wrappers"]["option"] = "--wrappers";
    capa["optional"]["wrappers"]["short"] = "w";
    cfg->addConnectorOptions(8080, capa);
    /*LTS-START*/
    cfg->addOption("nostreamtext", JSON::fromString("{\"arg\":\"string\", \"default\":\"\", \"short\":\"t\",\"long\":\"nostreamtext\",\"help\":\"Text or HTML to display when streams are unavailable.\"}"));
    capa["optional"]["nostreamtext"]["name"] = "Stream unavailable text";
    capa["optional"]["nostreamtext"]["help"] = "Text or HTML to display when streams are unavailable.";
    capa["optional"]["nostreamtext"]["default"] = "";
    capa["optional"]["nostreamtext"]["type"] = "str";
    capa["optional"]["nostreamtext"]["option"] = "--nostreamtext";
    cfg->addOption("pubaddr", JSON::fromString("{\"arg\":\"string\", \"default\":\"\", \"short\":\"A\",\"long\":\"public-address\",\"help\":\"Full public address this output is available as.\"}"));
    capa["optional"]["pubaddr"]["name"] = "Public address";
    capa["optional"]["pubaddr"]["help"] = "Full public address this output is available as, if being proxied";
    capa["optional"]["pubaddr"]["default"] = "";
    capa["optional"]["pubaddr"]["type"] = "str";
    capa["optional"]["pubaddr"]["option"] = "--public-address";
    /*LTS-END*/
  }
  
  /// Sorts the JSON::Value objects that hold source information by preference.
  struct sourceCompare {
    bool operator() (const JSON::Value& lhs, const JSON::Value& rhs) const {
      //first compare simultaneous tracks
      if (lhs["simul_tracks"].asInt() > rhs["simul_tracks"].asInt()){
        //more tracks = higher priority = true.
        return true;
      }
      if (lhs["simul_tracks"].asInt() < rhs["simul_tracks"].asInt()){
        //less tracks = lower priority = false
        return false;
      }
      //same amount of tracks - compare "hardcoded" priorities
      if (lhs["priority"].asInt() > rhs["priority"].asInt()){
        //higher priority = true.
        return true;
      }
      if (lhs["priority"].asInt() < rhs["priority"].asInt()){
        //lower priority = false
        return false;
      }
      //same priority - compare total matches
      if (lhs["total_matches"].asInt() > rhs["total_matches"].asInt()){
        //more matches = higher priority = true.
        return true;
      }
      if (lhs["total_matches"].asInt() < rhs["total_matches"].asInt()){
        //less matches = lower priority = false
        return false;
      }
      //also same amount of matches? just compare the URL then.
      return lhs["url"].asStringRef() < rhs["url"].asStringRef();
    }
  };
  
  void addSource(const std::string & rel, std::set<JSON::Value, sourceCompare> & sources, const HTTP::URL & url, JSON::Value & conncapa, unsigned int most_simul, unsigned int total_matches){
    JSON::Value tmp;
    tmp["type"] = conncapa["type"];
    tmp["relurl"] = rel;
    tmp["priority"] = conncapa["priority"];
    if (conncapa.isMember("player_url")){tmp["player_url"] = conncapa["player_url"].asStringRef();}
    tmp["simul_tracks"] = most_simul;
    tmp["total_matches"] = total_matches;
    if (url.path.size()){
      tmp["url"] = url.protocol + "://" + url.host + ":" + url.port + "/" + url.path + rel;
    }else{
      tmp["url"] = url.protocol + "://" + url.host + ":" + url.port + rel;
    }
    sources.insert(tmp);
  }
 
  /// Checks if a given user agent is allowed according to the given exception.
  bool checkException(const JSON::Value & ex, const std::string & useragent){
    //No user agent? Always allow everything.
    if (!useragent.size()){return true;}
    if (!ex.isArray() || !ex.size()){return true;}
    bool ret = true;
    jsonForEachConst(ex, e){
      if (!e->isArray() || !e->size()){continue;}
      bool setTo = ((*e)[0u].asStringRef() == "whitelist");
      if (e->size() == 1){
        ret = setTo;
        continue;
      }
      if (!(*e)[1].isArray()){continue;}
      jsonForEachConst((*e)[1u], i){
        if (useragent.find(i->asStringRef()) != std::string::npos){
          ret = setTo;
        }
      }
    }
    return ret;
  }

  void addSources(std::string & streamname, std::set<JSON::Value, sourceCompare> & sources, HTTP::URL url, JSON::Value & conncapa, JSON::Value & strmMeta, const std::string & useragent){
    if (strmMeta.isMember("live") && conncapa.isMember("exceptions") && conncapa["exceptions"].isObject() && conncapa["exceptions"].size()){
      jsonForEach(conncapa["exceptions"], ex){
        if (ex.key() == "live"){
          if (!checkException(*ex, useragent)){
            return;
          }
        }
      }
    }
    const std::string & rel = conncapa["url_rel"].asStringRef();
    unsigned int most_simul = 0;
    unsigned int total_matches = 0;
    if (conncapa.isMember("codecs") && conncapa["codecs"].size() > 0){
      jsonForEach(conncapa["codecs"], it) {
        unsigned int simul = 0;
        if ((*it).size() > 0){
          jsonForEach((*it), itb) {
            unsigned int matches = 0;
            if ((*itb).size() > 0){
              jsonForEach((*itb), itc) {
                jsonForEach(strmMeta["tracks"], trit) {
                  if ((*trit)["codec"].asStringRef() == (*itc).asStringRef()){
                    matches++;
                    total_matches++;
                    if (conncapa.isMember("exceptions") && conncapa["exceptions"].isObject() && conncapa["exceptions"].size()){
                      jsonForEach(conncapa["exceptions"], ex){
                        if (ex.key() == "codec:"+(*trit)["codec"].asStringRef()){
                          if (!checkException(*ex, useragent)){
                            matches--;
                            total_matches--;
                          }
                          break;
                        }
                      }
                    }
                  }
                }
              }
            }
            if (matches){
              simul++;
            }
          }
        }
        if (simul > most_simul){
          most_simul = simul;
        }
      }
    }
    if (conncapa.isMember("methods") && conncapa["methods"].size() > 0){
      std::string relurl;
      size_t found = rel.find('$');
      if (found != std::string::npos){
        relurl = rel.substr(0, found) + Encodings::URL::encode(streamname) + rel.substr(found+1);
      }else{
        relurl = "/";
      }
      jsonForEach(conncapa["methods"], it) {
        if (it->isMember("url_rel")){
          size_t foundb = (*it)["url_rel"].asStringRef().find('$');
          if (foundb != std::string::npos){
            relurl = (*it)["url_rel"].asStringRef().substr(0, foundb) + Encodings::URL::encode(streamname) + (*it)["url_rel"].asStringRef().substr(foundb+1);
          }
        }
        if (!strmMeta.isMember("live") || !it->isMember("nolive")){
          if (!url.protocol.size() && it->isMember("handler")){
            url.protocol = (*it)["handler"].asStringRef();
          }
          addSource(relurl, sources, url, *it, most_simul, total_matches);
        }
      }
    }
  }

  void OutHTTP::HTMLResponse(){
    std::string method = H.method;
    HTTP::URL fullURL(H.GetHeader("Host"));
    if (!fullURL.protocol.size()){
      fullURL.protocol = getProtocolForPort(fullURL.getPort());
    }
    /*LTS-START*/
    if (config->getString("pubaddr") != ""){
      HTTP::URL altURL(config->getString("pubaddr"));
      fullURL.protocol = altURL.protocol;
      if (altURL.host.size()){fullURL.host = altURL.host;}
      fullURL.port = altURL.port;
      fullURL.path = altURL.path;
    }
    /*LTS-END*/
    std::string uAgent = H.GetHeader("User-Agent");
    H.Clean();
    H.SetHeader("Content-Type", "text/html");
    H.SetHeader("Server", "MistServer/" PACKAGE_VERSION);
    H.setCORSHeaders();
    if(method == "OPTIONS" || method == "HEAD"){
      H.SendResponse("200", "OK", myConn);
      H.Clean();
      return;
    }
    
    std::string hlsUrl = "/hls/"+streamName+"/index.m3u8";
    std::string mp4Url = "/"+streamName+".mp4";
    
    H.SetBody("<!DOCTYPE html><html><head><title>"+streamName+"</title><style>body{color:white;background:black;}</style></head><body><div class=mistvideo id=\""+streamName+"\"><noscript><video controls autoplay><source src=\""+hlsUrl+"\" type=\"application/vnd.apple.mpegurl\"><source src=\""+mp4Url+"\" type=\"video/mp4\"><a href=\""+hlsUrl+"\">Click here to play the video [Apple]</a><br><a href=\""+mp4Url+"\">Click here to play the video [MP4]</a></video></noscript><script src=\"player.js\"></script><script>mistPlay('"+streamName+"',{host:'"+fullURL.getUrl()+"',target:document.getElementById('"+streamName+"')})</script></div></body></html>");
    if ((uAgent.find("iPad") != std::string::npos) || (uAgent.find("iPod") != std::string::npos) || (uAgent.find("iPhone") != std::string::npos)) {
      H.SetHeader("Location",hlsUrl);
      H.SendResponse("307", "HLS redirect", myConn);
      return;
    }
    H.SendResponse("200", "OK", myConn);
  }
  
  JSON::Value OutHTTP::getStatusJSON(std::string & reqHost, const std::string & useragent){
    JSON::Value json_resp;
    if (config->getString("nostreamtext") != ""){
      json_resp["on_error"] = config->getString("nostreamtext");
    }
    uint8_t streamStatus = Util::getStreamStatus(streamName);
    if (streamStatus != STRMSTAT_READY){
      switch (streamStatus){
        case STRMSTAT_OFF:
          json_resp["error"] = "Stream is offline";
          break;
        case STRMSTAT_INIT:
          json_resp["error"] = "Stream is initializing";
          break;
        case STRMSTAT_BOOT:
          json_resp["error"] = "Stream is booting";
          break;
        case STRMSTAT_WAIT:
          json_resp["error"] = "Stream is waiting for data";
          break;
        case STRMSTAT_SHUTDOWN:
          json_resp["error"] = "Stream is shutting down";
          break;
        case STRMSTAT_INVALID:
          json_resp["error"] = "Stream status is invalid?!";
          break;
        default:
          json_resp["error"] = "Stream status is unknown?!";
          break;
      }
      return json_resp;
    }
    initialize();
    if (!myConn){
      return json_resp;
    }

    bool hasVideo = false;
    for (std::map<unsigned int, DTSC::Track>::iterator trit = myMeta.tracks.begin(); trit != myMeta.tracks.end(); trit++){
      if (trit->second.type == "video"){
        hasVideo = true;
        if (trit->second.width > json_resp["width"].asInt()){
          json_resp["width"] = trit->second.width;
        }
        if (trit->second.height > json_resp["height"].asInt()){
          json_resp["height"] = trit->second.height;
        }
      }
    }
    if (json_resp["width"].asInt() < 1 || json_resp["height"].asInt() < 1){
      json_resp["width"] = 640ll;
      json_resp["height"] = 480ll;
      if (!hasVideo){json_resp["height"] = 20ll;}
    }
    if (myMeta.vod){
      json_resp["type"] = "vod";
    }
    if (myMeta.live){
      json_resp["type"] = "live";
    }
    
    // show ALL the meta datas!
    json_resp["meta"] = myMeta.toJSON();
    jsonForEach(json_resp["meta"]["tracks"], it) {
      if (it->isMember("lang")){
        (*it)["language"] = Encodings::ISO639::decode((*it)["lang"].asStringRef());
      }
      it->removeMember("fragments");
      it->removeMember("keys");
      it->removeMember("keysizes");
      it->removeMember("parts");
      it->removeMember("ivecs");/*LTS*/
    }
    json_resp["meta"].removeMember("source");

    //Get sources/protocols information
    Util::DTSCShmReader rCapa(SHM_CAPA);
    DTSC::Scan connectors = rCapa.getMember("connectors");
    Util::DTSCShmReader rProto(SHM_PROTO);
    DTSC::Scan prots = rProto.getScan();
    if (!prots || !connectors){
      json_resp["error"] = "Server configuration unavailable at this time.";
      return json_resp;
    }
 
    //create a set for storing source information
    std::set<JSON::Value, sourceCompare> sources;
    
    //find out which connectors are enabled
    std::set<std::string> conns;
    unsigned int prots_ctr = prots.getSize();
    for (unsigned int i = 0; i < prots_ctr; ++i){
      conns.insert(prots.getIndice(i).getMember("connector").asString());
    }
    //loop over the connectors.
    for (unsigned int i = 0; i < prots_ctr; ++i){
      std::string cName = prots.getIndice(i).getMember("connector").asString();
      DTSC::Scan capa = connectors.getMember(cName);
      //if the connector has a port,
      if (capa.getMember("optional").getMember("port")){
        HTTP::URL outURL(reqHost);
        //get the default port if none is set
        outURL.port = prots.getIndice(i).getMember("port").asString();
        if (!outURL.port.size()){
          outURL.port = capa.getMember("optional").getMember("port").getMember("default").asString();
        }
        outURL.protocol = capa.getMember("protocol").asString();
        if (outURL.protocol.find(':') != std::string::npos){
          outURL.protocol.erase(outURL.protocol.find(':'));
        }
        /*LTS-START*/
        if (prots.getIndice(i).hasMember("pubaddr") && prots.getIndice(i).getMember("pubaddr").asString().size()){
          HTTP::URL altURL(prots.getIndice(i).getMember("pubaddr").asString());
          outURL.protocol = altURL.protocol;
          if (altURL.host.size()){outURL.host = altURL.host;}
          outURL.port = altURL.port;
          outURL.path = altURL.path;
        }
        /*LTS-END*/
        //and a URL - then list the URL
        JSON::Value capa_json = capa.asJSON();
        if (capa.getMember("url_rel") || capa.getMember("methods")){
          addSources(streamName, sources, outURL, capa_json, json_resp["meta"], useragent);
        }
        //Make note if this connector can be depended upon by other connectors
        if (capa.getMember("provides")){
          std::string cProv = capa.getMember("provides").asString();
          //if this connector can be depended upon by other connectors, loop over the rest
          //check each enabled protocol separately to see if it depends on this connector
          unsigned int capa_lst_ctr = connectors.getSize();
          for (unsigned int j = 0; j < capa_lst_ctr; ++j){
            //if it depends on this connector and has a URL, list it
            if (conns.count(connectors.getIndiceName(j)) && connectors.getIndice(j).getMember("deps").asString() == cProv && connectors.getIndice(j).getMember("methods")){
              JSON::Value subcapa_json = connectors.getIndice(j).asJSON();
              addSources(streamName, sources, outURL, subcapa_json, json_resp["meta"], useragent);
            }
          }
        }
      }
    }
    
    //loop over the added sources, add them to json_resp["sources"]
    for (std::set<JSON::Value, sourceCompare>::iterator it = sources.begin(); it != sources.end(); it++){
      if ((*it)["simul_tracks"].asInt() > 0){
        json_resp["source"].append(*it);
      }
    }
    return json_resp;
  }

  void OutHTTP::onHTTP(){
    std::string method = H.method;
    
    if (H.url == "/crossdomain.xml"){
      H.Clean();
      H.SetHeader("Content-Type", "text/xml");
      H.SetHeader("Server", "MistServer/" PACKAGE_VERSION);
      H.setCORSHeaders();
      if(method == "OPTIONS" || method == "HEAD"){
        H.SendResponse("200", "OK", myConn);
        H.Clean();
        return;
      }
      H.SetBody("<?xml version=\"1.0\"?><!DOCTYPE cross-domain-policy SYSTEM \"http://www.adobe.com/xml/dtds/cross-domain-policy.dtd\"><cross-domain-policy><allow-access-from domain=\"*\" /><site-control permitted-cross-domain-policies=\"all\"/></cross-domain-policy>");
      H.SendResponse("200", "OK", myConn);
      H.Clean();
      return;
    } //crossdomain.xml
    
    if (H.url == "/clientaccesspolicy.xml"){
      H.Clean();
      H.SetHeader("Content-Type", "text/xml");
      H.SetHeader("Server", "MistServer/" PACKAGE_VERSION);
      H.setCORSHeaders();
      if(method == "OPTIONS" || method == "HEAD"){
        H.SendResponse("200", "OK", myConn);
        H.Clean();
        return;
      }
      H.SetBody("<?xml version=\"1.0\" encoding=\"utf-8\"?><access-policy><cross-domain-access><policy><allow-from http-methods=\"*\" http-request-headers=\"*\"><domain uri=\"*\"/></allow-from><grant-to><resource path=\"/\" include-subpaths=\"true\"/></grant-to></policy></cross-domain-access></access-policy>");
      H.SendResponse("200", "OK", myConn);
      H.Clean();
      return;
    } //clientaccesspolicy.xml
    
    if (H.url == "/flashplayer.swf"){
      H.Clean();
      H.SetHeader("Content-Type", "application/x-shockwave-flash");
      H.SetHeader("Server", "MistServer/" PACKAGE_VERSION);
      H.SetBody((const char*)FlashMediaPlayback_101_swf, FlashMediaPlayback_101_swf_len);
      H.SendResponse("200", "OK", myConn);
      return;
    }
    if (H.url == "/oldflashplayer.swf"){
      H.Clean();
      H.SetHeader("Content-Type", "application/x-shockwave-flash");
      H.SetHeader("Server", "MistServer/" PACKAGE_VERSION);
      H.SetBody((const char *)FlashMediaPlayback_swf, FlashMediaPlayback_swf_len);
      H.SendResponse("200", "OK", myConn);
      return;

    }
    // send logo icon
    if (H.url.length() > 4 && H.url.substr(H.url.length() - 4, 4) == ".ico"){
      sendIcon();
      return;
    }
    
    // send generic HTML page
    if (H.url.length() > 6 && H.url.substr(H.url.length() - 5, 5) == ".html"){
      HTMLResponse();
      return;
    }
    
    // send smil MBR index
    if (H.url.length() > 6 && H.url.substr(H.url.length() - 5, 5) == ".smil"){
      std::string reqHost = HTTP::URL(H.GetHeader("Host")).host;
      std::string port, url_rel;
      std::string trackSources;//this string contains all track sources for MBR smil
      {
        Util::DTSCShmReader rProto(SHM_PROTO);
        DTSC::Scan prtcls = rProto.getScan();
        Util::DTSCShmReader rCapa(SHM_CAPA);
        DTSC::Scan capa = rCapa.getMember("connectors").getMember("RTMP");
        unsigned int pro_cnt = prtcls.getSize();
        for (unsigned int i = 0; i < pro_cnt; ++i){
          if (prtcls.getIndice(i).getMember("connector").asString() != "RTMP"){
            continue;
          }
          port = prtcls.getIndice(i).getMember("port").asString();
          //get the default port if none is set
          if (!port.size()){
            port = capa.getMember("optional").getMember("port").getMember("default").asString();
          }
          //extract url
          url_rel = capa.getMember("url_rel").asString();
          if (url_rel.find('$')){
            url_rel.resize(url_rel.find('$'));
          }
        }
        
        initialize();
        if (!myConn){return;}
        for (std::map<unsigned int, DTSC::Track>::iterator trit = myMeta.tracks.begin(); trit != myMeta.tracks.end(); trit++){
          if (trit->second.type == "video"){
            trackSources += "      <video src='"+ streamName + "?track=" + JSON::Value((long long)trit->first).asString() + "' height='" + JSON::Value((long long)trit->second.height).asString() + "' system-bitrate='" + JSON::Value((long long)trit->second.bps).asString() + "' width='" + JSON::Value((long long)trit->second.width).asString() + "' />\n";
          }
        }
      }
      
      H.Clean();
      H.SetHeader("Content-Type", "application/smil");
      H.SetHeader("Server", "MistServer/" PACKAGE_VERSION);
      H.setCORSHeaders();
      if(method == "OPTIONS" || method == "HEAD"){
        H.SendResponse("200", "OK", myConn);
        H.Clean();
        return;
      }
      H.SetBody("<smil>\n  <head>\n    <meta base='rtmp://" + reqHost + ":" + port + url_rel + "' />\n  </head>\n  <body>\n    <switch>\n"+trackSources+"    </switch>\n  </body>\n</smil>");
      H.SendResponse("200", "OK", myConn);
      H.Clean();
      return;
    }
    
    if ((H.url.length() > 9 && H.url.substr(0, 6) == "/info_" && H.url.substr(H.url.length() - 3, 3) == ".js") || (H.url.length() > 10 && H.url.substr(0, 7) == "/embed_" && H.url.substr(H.url.length() - 3, 3) == ".js") || (H.url.length() > 9 && H.url.substr(0, 6) == "/json_" && H.url.substr(H.url.length() - 3, 3) == ".js")){
      if (websocketHandler()){return;}
      std::string reqHost = HTTP::URL(H.GetHeader("Host")).host;
      std::string useragent = H.GetVar("ua");
      if (!useragent.size()){
        useragent = H.GetHeader("User-Agent");
      }
      std::string response;
      std::string rURL = H.url;
      if(method != "OPTIONS" && method != "HEAD"){
        initialize();
      }
      H.Clean();
      H.SetHeader("Server", "MistServer/" PACKAGE_VERSION);
      H.setCORSHeaders();
      if (rURL.substr(0, 6) != "/json_"){
        H.SetHeader("Content-Type", "application/javascript");
      }else{
        H.SetHeader("Content-Type", "application/json");
      }
      if(method == "OPTIONS" || method == "HEAD"){
        H.SendResponse("200", "OK", myConn);
        H.Clean();
        return;
      }
      response = "// Generating info code for stream " + streamName + "\n\nif (!mistvideo){var mistvideo = {};}\n";
      JSON::Value json_resp = getStatusJSON(reqHost, useragent);
      if (rURL.substr(0, 6) != "/json_"){
        response += "mistvideo['" + streamName + "'] = " + json_resp.toString() + ";\n";
      }else{
        response = json_resp.toString();
      }
      if (rURL.substr(0, 7) == "/embed_" && !json_resp.isMember("error")){
        #include "embed.js.h"
        response.append("\n(");
        if (embed_js[embed_js_len - 2] == ';'){//check if we have a trailing ;\n or just \n
          response.append((char*)embed_js, (size_t)embed_js_len - 2); //remove trailing ";\n" from xxd conversion
        }else{
          response.append((char*)embed_js, (size_t)embed_js_len - 1); //remove trailing "\n" from xxd conversion
        }
        response.append("(\"" + streamName + "\"));\n");
      }
      H.SetBody(response);
      H.SendResponse("200", "OK", myConn);
      H.Clean();
      return;
    } //embed code generator
    
    
    if (H.url == "/player.js"){
      HTTP::URL fullURL(H.GetHeader("Host"));
      if (!fullURL.protocol.size()){
        fullURL.protocol = getProtocolForPort(fullURL.getPort());
      }
      /*LTS-START*/
      if (config->getString("pubaddr") != ""){
        HTTP::URL altURL(config->getString("pubaddr"));
        fullURL.protocol = altURL.protocol;
        if (altURL.host.size()){fullURL.host = altURL.host;}
        fullURL.port = altURL.port;
        fullURL.path = altURL.path;
      }
      /*LTS-END*/
      std::string response;
      std::string rURL = H.url;
      H.Clean();
      H.SetHeader("Server", "MistServer/" PACKAGE_VERSION);
      H.setCORSHeaders();
      H.SetHeader("Content-Type", "application/javascript");
      if(method == "OPTIONS" || method == "HEAD"){
        H.SendResponse("200", "OK", myConn);
        H.Clean();
        return;
      }
      
      response.append("if (typeof mistoptions == 'undefined') { mistoptions = {}; }\nif (!('host' in mistoptions)) { mistoptions.host = '"+fullURL.getUrl()+"'; }\n");
      #include "core.js.h"
      response.append((char*)core_js, (size_t)core_js_len);
      jsonForEach(config->getOption("wrappers",true),it){
        bool used = false;
        if (it->asStringRef() == "html5"){
          #include "html5.js.h"
          response.append((char*)html5_js, (size_t)html5_js_len);
          used = true;
        }
        if (it->asStringRef() == "flash_strobe"){
          #include "flash_strobe.js.h"
          response.append((char*)flash_strobe_js, (size_t)flash_strobe_js_len);
          used = true;
        }
        if (it->asStringRef() == "silverlight"){
          #include "silverlight.js.h"
          response.append((char*)silverlight_js, (size_t)silverlight_js_len);
          used = true;
        }
        if (it->asStringRef() == "theoplayer"){
          #include "theoplayer.js.h"
          response.append((char*)theoplayer_js, (size_t)theoplayer_js_len);
          used = true;
        }
        if (it->asStringRef() == "jwplayer"){
          #include "jwplayer.js.h"
          response.append((char*)jwplayer_js, (size_t)jwplayer_js_len);
          used = true;
        }
        if (it->asStringRef() == "polytrope"){
          #include "polytrope.js.h"
          response.append((char*)polytrope_js, (size_t)polytrope_js_len);
          used = true;
        }
        if (it->asStringRef() == "dashjs"){
          #include "dashjs.js.h"
          response.append((char*)dash_js, (size_t)dash_js_len);
          used = true;
        }
        if (it->asStringRef() == "videojs"){
          #include "videojs.js.h"
          response.append((char*)video_js, (size_t)video_js_len);
          used = true;
        }
        if (it->asStringRef() == "img"){
          #include "img.js.h"
          response.append((char*)img_js, (size_t)img_js_len);
          used = true;
        }
        if (!used) {
          WARN_MSG("Unknown player type: %s",it->asStringRef().c_str());
        }
      }
      
      H.SetBody(response);
      H.SendResponse("200", "OK", myConn);
      H.Clean();
      return;
      
    }
    
    if (H.url == "/player.css"){
      std::string response;
      H.Clean();
      H.SetHeader("Server", "MistServer/" PACKAGE_VERSION);
      H.setCORSHeaders();
      H.SetHeader("Content-Type", "text/css");
      if (method == "OPTIONS" || method == "HEAD"){
        H.SendResponse("200", "OK", myConn);
        H.Clean();
        return;
      }
      
      #include "mist.css.h"
      response.append((char*)mist_css, (size_t)mist_css_len);
      
      H.SetBody(response);
      H.SendResponse("200", "OK", myConn);
      H.Clean();
      return;
    }
    if (H.url == "/videojs.js"){
      std::string response;
      H.Clean();
      H.SetHeader("Server", "MistServer/" PACKAGE_VERSION);
      H.setCORSHeaders();
      H.SetHeader("Content-Type", "application/javascript");
      if (method == "OPTIONS" || method == "HEAD"){
        H.SendResponse("200", "OK", myConn);
        H.Clean();
        return;
      }
      
      #include "playervideo.js.h"
      response.append((char*)playervideo_js, (size_t)playervideo_js_len);
      #include "playerhlsvideo.js.h"
      response.append((char*)playerhlsvideo_js, (size_t)playerhlsvideo_js_len);
      
      H.SetBody(response);
      H.SendResponse("200", "OK", myConn);
      H.Clean();
      return;
    }
    if (H.url == "/dashjs.js"){
      std::string response;
      H.Clean();
      H.SetHeader("Server", "MistServer/" PACKAGE_VERSION);
      H.setCORSHeaders();
      H.SetHeader("Content-Type", "application/javascript");
      if (method == "OPTIONS" || method == "HEAD"){
        H.SendResponse("200", "OK", myConn);
        H.Clean();
        return;
      }
      
      #include "playerdashlic.js.h"
      response.append((char*)playerdashlic_js, (size_t)playerdashlic_js_len);
      #include "playerdash.js.h"
      response.append((char*)playerdash_js, (size_t)playerdash_js_len);
      
      H.SetBody(response);
      H.SendResponse("200", "OK", myConn);
      H.Clean();
      return;
    }
  }

  void OutHTTP::sendIcon(){
    std::string method = H.method;
    /*LTS-START*/
    if (H.GetVar("s").size() && H.GetVar("s") == SUPER_SECRET){
      H.Clean();
      H.SetHeader("Server", "mistserver/" PACKAGE_VERSION);
      H.setCORSHeaders();
      if(method == "OPTIONS" || method == "HEAD"){
        H.SendResponse("200", "OK", myConn);
        H.Clean();
        return;
      }
      H.SetBody("Yup");
      H.SendResponse("200", "OK", myConn);
      H.Clean();
      return;
    }
    /*LTS-END*/
    H.Clean();
    #include "../icon.h"
    H.SetHeader("Content-Type", "image/x-icon");
    H.SetHeader("Server", "MistServer/" PACKAGE_VERSION);
    H.SetHeader("Content-Length", icon_len);
    H.setCORSHeaders();
    if(method == "OPTIONS" || method == "HEAD"){
      H.SendResponse("200", "OK", myConn);
      H.Clean();
      return;
    }
    H.SendResponse("200", "OK", myConn);
    myConn.SendNow((const char*)icon_data, icon_len);
    H.Clean();
  }

  bool OutHTTP::websocketHandler(){
    stayConnected = true;
    std::string reqHost = HTTP::URL(H.GetHeader("Host")).host;
    std::string useragent = H.GetVar("ua");
    if (!useragent.size()){
      useragent = H.GetHeader("User-Agent");
    }
    if (H.GetHeader("Upgrade") != "websocket"){return false;}
    HTTP::Websocket ws(myConn, H);
    if (!ws){return false;}
    //start the stream, if needed
    Util::startInput(streamName, "", true, false);

    char pageName[NAME_BUFFER_SIZE];
    snprintf(pageName, NAME_BUFFER_SIZE, SHM_STREAM_STATE, streamName.c_str());
    IPC::sharedPage streamStatus(pageName, 1, false, false);
    uint8_t prevState, newState, metaCounter;
    uint64_t prevTracks;
    prevState = newState = STRMSTAT_INVALID;
    while (keepGoing()){
      if (!streamStatus || !streamStatus.exists()){streamStatus.init(pageName, 1, false, false);}
      if (!streamStatus){newState = STRMSTAT_OFF;}else{newState = streamStatus.mapped[0];}

      if (newState != prevState || (newState == STRMSTAT_READY && myMeta.tracks.size() != prevTracks)){
        if (newState == STRMSTAT_READY){
          reconnect();
          updateMeta();
          prevTracks = myMeta.tracks.size();
        }else{
          disconnect();
        }
        JSON::Value resp = getStatusJSON(reqHost, useragent);
        ws.sendFrame(resp.toString());
        prevState = newState;
      }else{
        if (newState == STRMSTAT_READY){
          stats();
        }
        Util::sleep(250);
        if (newState == STRMSTAT_READY && (++metaCounter % 4) == 0){
          updateMeta();
        }
      }
    }
    return true;
  }

}