#define DEBUG 5
/// \file conn_http_dynamic.cpp
/// Contains the main code for the HTTP Dynamic Connector

#include <iostream>
#include <iomanip>
#include <sstream>
#include <queue>
#include <cstdlib>
#include <cstdio>
#include <cmath>
#include <unistd.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <getopt.h>
#include <mist/socket.h>
#include <mist/http_parser.h>
#include <mist/json.h>
#include <mist/dtsc.h>
#include <mist/mp4.h>
#include <mist/config.h>
#include <sstream>
#include <mist/stream.h>
#include <mist/timing.h>
#include <mist/ts_packet.h>

/// Holds everything unique to HTTP Connectors.
namespace Connector_HTTP {
  /// Parses the list of keyframes into 10 second fragments
  std::vector<int> keyframesToFragments( JSON::Value & metadata ) {
    std::vector<int> result;
    if( metadata.isNull() ) {
      return result;
    }
    result.push_back(0);
    int currentBase = 0;
    for (int i = 0; i < metadata["keytime"].size(); i++){
      if ((metadata["keytime"][i].asInt() - currentBase) > 10000){
        currentBase = metadata["keytime"][i].asInt();
        result.push_back(i);
      }
    }
    return result;
  }

  /// Returns a m3u or m3u8 index file
  std::string BuildIndex(std::string & MovieId, JSON::Value & metadata){
    std::stringstream Result;
    std::vector<int> fragIndices = keyframesToFragments( metadata );
    int longestFragment = 0;
    for (int i = 1; i < fragIndices.size(); i++){
      int fragDuration = metadata["keytime"][fragIndices[i]].asInt() - metadata["keytime"][fragIndices[i-1]].asInt();
      if (fragDuration > longestFragment){
        longestFragment = fragDuration;
      }
    }
    if (metadata.isMember("length") && metadata["length"].asInt() > 0){
      Result <<
          "#EXTM3U\r\n"
              "#EXT-X-VERSION:3\r\n"
              "#EXT-X-MEDIA-SEQUENCE:1\r\n"
              //"#EXT-X-ALLOW-CACHE:YES\r\n"
              "#EXT-X-TARGETDURATION:" << (longestFragment / 1000) + 1 << "\r\n"
              "#EXT-X-PLAYLIST-TYPE:VOD\r\n";
      int lastDuration = 0;
      int lastBytePos = 0;
      bool writeOffset = true;
      int j = 0;
      for (int i = 0; i < fragIndices.size(); i++) {
        if (lastDuration != 0){
          Result << "#EXTINF:" << (metadata["keytime"][fragIndices[i]].asInt() - lastDuration) / 1000 << "." << std::setw(3) << std::setfill('0') << ((metadata["keytime"][fragIndices[i]].asInt() - lastDuration) % 1000) << ",\r\n"
          << ++j << ".ts\r\n";
        }
        lastDuration = metadata["keytime"][fragIndices[i]].asInt();
        lastBytePos = metadata["keybpos"][fragIndices[i]].asInt();
      }
      Result << "#EXT-X-ENDLIST";
    }else{
      Result <<
          "#EXTM3U\r\n"
              "#EXT-X-VERSION:4\r\n"
              "#EXT-X-MEDIA-SEQUENCE:1\r\n"
              "#EXT-X-TARGETDURATION:" << ((metadata["video"]["keyms"].asInt() + metadata["video"]["keyvar"].asInt()) / 1000) + 1 << "\r\n";
    }
#if DEBUG >= 8
    std::cerr << "Sending this index:" << std::endl << Result.str() << std::endl;
#endif
    return Result.str();
  } //BuildIndex

  /// Main function for Connector_HTTP_Live
  int Connector_HTTP_Live(Socket::Connection conn){
    std::stringstream TSBuf;
    long long int TSBufTime = 0;

    DTSC::Stream Strm; //Incoming stream buffer.
    HTTP::Parser HTTP_R, HTTP_S; //HTTP Receiver en HTTP Sender.

    bool ready4data = false; //Set to true when streaming is to begin.
    bool pending_manifest = false;
    bool receive_marks = false; //when set to true, this stream will ignore keyframes and instead use pause marks
    bool inited = false;
    Socket::Connection ss( -1);
    std::string streamname;
    std::string recBuffer = "";

    std::string ToPack;
    TS::Packet PackData;
    std::string DTMIData;
    int PacketNumber = 0;
    long long unsigned int TimeStamp = 0;
    int ThisNaluSize;
    char VideoCounter = 0;
    char AudioCounter = 0;
    bool WritePesHeader;
    bool IsKeyFrame;
    bool FirstKeyFrame = true;
    bool FirstIDRInKeyFrame;
    MP4::AVCC avccbox;
    bool haveAvcc = false;
    
    std::vector<int> fragIndices;

    int Segment = -1;
    int temp;
    int Flash_RequestPending = 0;
    unsigned int lastStats = 0;
    conn.setBlocking(false); //do not block on conn.spool() when no data is available

    while (conn.connected()){
      if (conn.spool() || conn.Received().size()){
        //make sure it ends in a \n
        if ( *(conn.Received().get().rbegin()) != '\n'){
          std::string tmp = conn.Received().get();
          conn.Received().get().clear();
          if (conn.Received().size()){
            conn.Received().get().insert(0, tmp);
          }else{
            conn.Received().append(tmp);
          }
        }
        if (HTTP_R.Read(conn.Received().get())){
#if DEBUG >= 4
          std::cout << "Received request: " << HTTP_R.getUrl() << std::endl;
#endif
          conn.setHost(HTTP_R.GetHeader("X-Origin"));
          if (HTTP_R.url.find(".m3u") == std::string::npos){
            streamname = HTTP_R.url.substr(5, HTTP_R.url.find("/", 5) - 5);
            if ( !ss){
              ss = Util::Stream::getStream(streamname);
              if ( !ss.connected()){
#if DEBUG >= 1
                fprintf(stderr, "Could not connect to server!\n");
#endif
                ss.close();
                HTTP_S.Clean();
                HTTP_S.SetBody("No such stream is available on the system. Please try again.\n");
                conn.SendNow(HTTP_S.BuildResponse("404", "Not found"));
                ready4data = false;
                continue;
              }
              ss.setBlocking(false);
              inited = true;
            }
            temp = HTTP_R.url.find("/", 5) + 1;
            Segment = atoi(HTTP_R.url.substr(temp, HTTP_R.url.find(".ts", temp) - temp).c_str());
            if( !fragIndices.size() ) {
              fragIndices = keyframesToFragments( Strm.metadata );
            }

#if DEBUG >= 4
            fprintf( stderr, "Fragment number %d\n", Segment);
            fprintf( stderr, "Fragment indices %d\n", fragIndices.size() );
            fprintf( stderr, "Seeking to fragment %d\n", fragIndices[Segment-1] + 1 );
#endif

            std::stringstream sstream;
            sstream << "f " << fragIndices[Segment-1] + 1 << "\n";
            int frameCount;

            if (Segment == fragIndices.size() - 1){
fprintf( stderr, "Last Fragment\n" );
              frameCount = Strm.metadata["keytime"].size() - fragIndices[Segment];
            }else{
fprintf( stderr, "Not Last Fragment\n" );
              frameCount = fragIndices[Segment+1] - fragIndices[Segment];
            }
#if DEBUG >= 4
            fprintf( stderr, "Frame count %d\n", frameCount);
#endif
            for (int i = 0; i < frameCount; i++){
              sstream << "o \n";
            }
            ss.SendNow(sstream.str().c_str());
            Flash_RequestPending++;
          }else{
            streamname = HTTP_R.url.substr(5, HTTP_R.url.find("/", 5) - 5);
            if ( !Strm.metadata.isNull()){
              HTTP_S.Clean();
              if (HTTP_R.url.find(".m3u8") != std::string::npos) {
                HTTP_S.SetHeader("Content-Type", "application/vnd.apple.mpegurl");//m3u8
              }else{
                HTTP_S.SetHeader("Content-Type", "audio/mpegurl");//m3u
              }
              HTTP_S.SetHeader("Cache-Control", "no-cache");
              if (Strm.metadata.isMember("length")){
                receive_marks = true;
              }
              std::string manifest = BuildIndex(streamname, Strm.metadata);
              HTTP_S.SetBody(manifest);
              conn.SendNow(HTTP_S.BuildResponse("200", "OK"));
#if DEBUG >= 3
              printf("Sent manifest\n");
#endif
              pending_manifest = false;
            }else{
              pending_manifest = true;
            }
          }
          ready4data = true;
          HTTP_R.Clean(); //clean for any possible next requests
        }
      }else{
        if (Flash_RequestPending){
          usleep(1000); //sleep 1ms
        }else{
          usleep(10000); //sleep 10ms
        }
      }
      if (ready4data){
        if ( !inited){
          //we are ready, connect the socket!
          ss = Util::Stream::getStream(streamname);
          if ( !ss.connected()){
#if DEBUG >= 1
            fprintf(stderr, "Could not connect to server!\n");
#endif
            ss.close();
            HTTP_S.Clean();
            HTTP_S.SetBody("No such stream is available on the system. Please try again.\n");
            conn.SendNow(HTTP_S.BuildResponse("404", "Not found"));
            ready4data = false;
            continue;
          }
          ss.setBlocking(false);
#if DEBUG >= 3
          fprintf(stderr, "Everything connected, starting to send video data...\n");
#endif
          inited = true;
        }
        unsigned int now = Util::epoch();
        if (now != lastStats){
          lastStats = now;
          ss.SendNow(conn.getStats("HTTP_Live").c_str());
        }
        if (ss.spool()){
          while (Strm.parsePacket(ss.Received())){
            if (Strm.getPacket(0).isMember("time")){
              if ( !Strm.metadata.isMember("firsttime")){
                Strm.metadata["firsttime"] = Strm.getPacket(0)["time"];
              }else{
                if ( !Strm.metadata.isMember("length") || Strm.metadata["length"].asInt() == 0){
                  Strm.getPacket(0)["time"] = Strm.getPacket(0)["time"].asInt() - Strm.metadata["firsttime"].asInt();
                }
              }
              Strm.metadata["lasttime"] = Strm.getPacket(0)["time"];
            }
            if (pending_manifest){
              HTTP_S.Clean();
              HTTP_S.SetHeader("Cache-Control", "no-cache");
              if (Strm.metadata.isMember("length")){
                receive_marks = true;
              }
              std::string manifest = BuildIndex(streamname, Strm.metadata);
              if (HTTP_R.url.find(".m3u8") != std::string::npos) {
                HTTP_S.SetHeader("Content-Type", "application/vnd.apple.mpegurl");//m3u8
              }else{
                HTTP_S.SetHeader("Content-Type", "audio/mpegurl");//m3u
              }
              HTTP_S.SetBody(manifest);
              conn.SendNow(HTTP_S.BuildResponse("200", "OK"));
#if DEBUG >= 3
              printf("Sent manifest\n");
#endif
              pending_manifest = false;
            }
            if ( !receive_marks && Strm.metadata.isMember("length")){
              receive_marks = true;
            }
            if ((Strm.getPacket(0).isMember("keyframe") && !receive_marks) || Strm.lastType() == DTSC::PAUSEMARK){
#if DEBUG >= 4
              fprintf(stderr, "Received a %s fragment of %i bytes.\n", Strm.getPacket(0)["datatype"].asString().c_str(), TSBuf.rdbuf()->in_avail());
#endif
              if (Flash_RequestPending > 0 && TSBuf.rdbuf()->in_avail()){
#if DEBUG >= 3
                fprintf(stderr, "Sending a fragment...");
#endif
                HTTP_S.Clean();
                HTTP_S.SetHeader("Content-Type", "video/MP2T");
                HTTP_S.SetBody("");
                HTTP_S.SetHeader("Content-Length", TSBuf.rdbuf()->in_avail());
                conn.SendNow(HTTP_S.BuildResponse("200", "OK"));
                conn.SendNow(TSBuf.str().c_str(),TSBuf.rdbuf()->in_avail());
                TSBuf.str("");
                Flash_RequestPending--;
                PacketNumber = 0;
#if DEBUG >= 3
                fprintf(stderr, "Done\n");
#endif
              }
              TSBuf.str("");
            }
            if( !haveAvcc ) {
              avccbox.setPayload( Strm.metadata["video"]["init"].asString() );
              haveAvcc = true;
            }
            if (Strm.lastType() == DTSC::VIDEO || Strm.lastType() == DTSC::AUDIO){
              if( Strm.lastType() == DTSC::VIDEO ) {
                DTMIData = Strm.lastData();
                if( Strm.getPacket(0).isMember("keyframe") ) {
fprintf( stderr, "  Received Keyframe of size %d\n", Strm.lastData().size() );
                  IsKeyFrame = true;
                  FirstIDRInKeyFrame = true;
                } else {
                  IsKeyFrame = false;
                  FirstKeyFrame = false;
                }
                if( IsKeyFrame ) {
                  TimeStamp = ( Strm.getPacket(0)["time"].asInt() * 27000 );
                }
                int TSType;
                bool FirstPic = true;
                std::string videoBuffer;
                while( DTMIData.size() ) {
                  ThisNaluSize =  (DTMIData[0] << 24) + (DTMIData[1] << 16) +
                                  (DTMIData[2] << 8) + DTMIData[3];
                  DTMIData.erase(0,4);//Erase the first four characters;
                  TSType = (int)DTMIData[0] & 0x1F;
                  if( !( TSType == 0x09 ) ) {
                    if( TSType == 0x05 ) {
                      if( FirstPic ) {
                        ToPack += avccbox.asAnnexB( );
                        FirstPic = false;
                      } 
                      if( IsKeyFrame ) {
                        if( !FirstKeyFrame && FirstIDRInKeyFrame ) {
                          ToPack += (char)0x00;
                          FirstIDRInKeyFrame = false;
                        }
                        ToPack.append(TS::ShortNalHeader,3);
                      }
                    } else if ( TSType == 0x01 ) {
                      if( FirstPic ) {
                        ToPack += (char)0x00;
                        FirstPic = false;
                      }
                      ToPack.append(TS::ShortNalHeader,3);
                    } else {
                      ToPack.append(TS::NalHeader,4);
                    }
                    ToPack.append(DTMIData,0,ThisNaluSize);
                  }
                  DTMIData.erase(0,ThisNaluSize);
                }
                WritePesHeader = true;
                while( ToPack.size() ) {
                  if (PacketNumber == 0) {
                    PackData.DefaultPAT();
                    TSBuf.write(PackData.ToString(), 188);
                    PackData.DefaultPMT();
                    TSBuf.write(PackData.ToString(), 188);
                    PacketNumber += 2;
                  }
                  PackData.Clear();
                  PackData.PID( 0x100 );
                  PackData.ContinuityCounter( VideoCounter );
                  VideoCounter ++;
                  if( WritePesHeader ) {
                    PackData.UnitStart( 1 );
                    if( IsKeyFrame ) {
                      PackData.RandomAccess( 1 );
                      PackData.PCR( TimeStamp );
                    } else {
                      PackData.AdaptationField( 1 );
                    }
                    PackData.AddStuffing( 184 - (20+ToPack.size()) );
                    PackData.PESVideoLeadIn( ToPack.size(), Strm.getPacket(0)["time"].asInt() * 90 );
                    WritePesHeader = false;
                  } else {
                    PackData.AdaptationField( 1 );
                    PackData.AddStuffing( 184 - (ToPack.size()) );
                  }
                  PackData.FillFree( ToPack );
                  TSBuf.write(PackData.ToString(), 188);
                  PacketNumber ++;
                }
              } else if( Strm.lastType() == DTSC::AUDIO ) {
                WritePesHeader = true;
                DTMIData = Strm.lastData();
                ToPack = TS::GetAudioHeader( DTMIData.size(), Strm.metadata["audio"]["init"].asString() );
                ToPack += DTMIData;
                TimeStamp = Strm.getPacket(0)["time"].asInt() * 81000;
                while( ToPack.size() ) {
                  if ( ( PacketNumber == 0 ) ) {
                    PackData.DefaultPAT();
                    TSBuf.write(PackData.ToString(), 188);
                    PackData.DefaultPMT();
                    TSBuf.write(PackData.ToString(), 188);
                    PacketNumber += 2;
                  }
                  PackData.Clear();
                  PackData.PID( 0x101 );
                  PackData.ContinuityCounter( AudioCounter );
                  AudioCounter ++;
                  if( WritePesHeader ) {
                    PackData.UnitStart( 1 );
                    PackData.AddStuffing( 184 - (14 + ToPack.size()) );
                    PackData.PESAudioLeadIn( ToPack.size(), TimeStamp );
                    WritePesHeader = false;
                  } else {
                    PackData.AdaptationField( 1 );
                    PackData.AddStuffing( 184 - ToPack.size() );
                  }
                  PackData.FillFree( ToPack );
                  TSBuf.write(PackData.ToString(), 188);
                  PacketNumber ++;
                }
              }  
            }
          }
          if (pending_manifest && !Strm.metadata.isNull()){
            HTTP_S.Clean();
            HTTP_S.SetHeader("Cache-Control", "no-cache");
            if (Strm.metadata.isMember("length")){
              receive_marks = true;
            }
            if (HTTP_R.url.find(".m3u8") != std::string::npos) {
              HTTP_S.SetHeader("Content-Type", "application/vnd.apple.mpegurl");//m3u8
            }else{
              HTTP_S.SetHeader("Content-Type", "audio/mpegurl");//m3u
            }
            std::string manifest = BuildIndex(streamname, Strm.metadata);
            HTTP_S.SetBody(manifest);
            conn.SendNow(HTTP_S.BuildResponse("200", "OK"));
#if DEBUG >= 3
            printf("Sent manifest\n");
#endif
            pending_manifest = false;
          }
        }
        if ( !ss.connected()){
          break;
        }
      }
    }
    conn.close();
    ss.SendNow(conn.getStats("HTTP_Live").c_str());
    ss.close();
#if DEBUG >= 1
    fprintf(stderr, "User %i disconnected.\n", conn.getSocket());
    if (inited){
      fprintf(stderr, "Status was: inited\n");
    }else{
      if (ready4data){
        fprintf(stderr, "Status was: ready4data\n");
      }else{
        fprintf(stderr, "Status was: connected\n");
      }
    }
#endif
    return 0;
  } //Connector_HTTP_Dynamic main function

} //Connector_HTTP_Dynamic namespace

int main(int argc, char ** argv){
  Util::Config conf(argv[0], PACKAGE_VERSION);
  conf.addConnectorOptions(1935);
  conf.parseArgs(argc, argv);
  Socket::Server server_socket = Socket::Server("/tmp/mist/http_live");
  if ( !server_socket.connected()){
    return 1;
  }
  conf.activate();

  while (server_socket.connected() && conf.is_active){
    Socket::Connection S = server_socket.accept();
    if (S.connected()){ //check if the new connection is valid
      pid_t myid = fork();
      if (myid == 0){ //if new child, start MAINHANDLER
        return Connector_HTTP::Connector_HTTP_Live(S);
      }else{ //otherwise, do nothing or output debugging text
#if DEBUG >= 3
        fprintf(stderr, "Spawned new process %i for socket %i\n", (int)myid, S.getSocket());
#endif
      }
    }
  } //while connected
  server_socket.close();
  return 0;
} //main