package de.uhilger.tango.api;

import com.sun.net.httpserver.Headers;
import com.sun.net.httpserver.HttpExchange;
import de.uhilger.tango.App;
import de.uhilger.tango.Server;
import static de.uhilger.tango.api.FileHandler.CONTENT_LENGTH;
import static de.uhilger.tango.api.FileHandler.HTTP_GET;
import static de.uhilger.tango.api.FileHandler.RANGE_HEADER;
import static de.uhilger.tango.api.FileHandler.RB_NOT_FOUND;
import static de.uhilger.tango.api.FileHandler.RB_WELCOME_FILE;
import static de.uhilger.tango.api.FileHandler.SC_NOT_FOUND;
import static de.uhilger.tango.api.FileHandler.SC_OK;
import static de.uhilger.tango.api.FileHandler.STR_BLANK;
import static de.uhilger.tango.api.FileHandler.STR_DOT;
import de.uhilger.tango.entity.Ablageort;
import de.uhilger.tango.entity.Abspielliste;
import de.uhilger.tango.entity.Entity;
import de.uhilger.tango.entity.Titel;
import de.uhilger.tango.store.FileStorage;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.nio.charset.StandardCharsets;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.ResourceBundle;
import java.util.logging.Level;
import java.util.logging.Logger;

/**
 * Der StreamHandler liefert ganze Abspiellisten als einzelnen Stream aus. Die in Tango mit dem
 * ListHandler erstellen Abspiellisten werden als ein zusammenhaengender Stream ausgegeben.
 *
 * Den Inhalt einer Abspielliste als Stream ausgeben HTTP GET /tango/api/stream/liste/[name]
 *
 *
 *
 *
 * die folgenden URLs ggf. wieder wegnehmen
 *
 * HTTP GET /tango/api/stream/play/liste/[name]
 *
 * HTTP GET /tango/api/stream/pause/liste/[name] HTTP GET /tango/api/stream/stop/liste/[name] HTTP
 * GET /tango/api/stream/seek/liste/[name]/[sekunden]
 *
 * Die Funktionen des StreamHandlers ergaenzen so die Ausgabe einzelner Media-Dateien als Stream,
 * wie sie mit dem FileHandler und seinen Subklassen sowie mit der MediaSteuerung erfolgen.
 *
 * @author Ulrich Hilger
 */
public class StreamHandler extends FileHandler {
  private static final Logger logger = Logger.getLogger(StreamHandler.class.getName());

  public static final String PLAY = "play";
  public static final String LISTE = "liste";

  private HashMap listen;
  private HashMap<String, File> files;
  private HashMap<String, Long> bytes;
  private HashMap<String, String> kataloge;
  private String conf;

  public StreamHandler(String conf) {
    super(""); // wird spaeter gesetzt
    listen = new HashMap<String, Integer>(); // abspiellistenname -> z.Zt. spielender Index
    kataloge = new HashMap(); // url -> abs. pfad
    files = new HashMap<String, File>(); // abspiellistenname -> z zt spielende datei
    bytes = new HashMap<String, Long>(); // abspiellistenname -> gespielte bytes
    this.conf = conf;
    ablageorteLesen();
  }

  @Override
  public void handle(HttpExchange e) throws IOException {
    String path = e.getRequestURI().toString();
    String[] elems = path.split(Server.SLASH);
    String lName = elems[5];

    Integer index;
    File file;
    FileStorage s = new FileStorage(conf);
    Object o = listen.get(lName);
    if (o instanceof Integer) {
      // liste spielt schon
      index = (Integer) o;
      file = files.get(lName);
    } else {
      index = 0;
      // liste spielt noch nicht
      listen.put(lName, index);
      file = getFileToPlay(s, lName, index.intValue());
      files.put(lName, file);
      bytes.put(lName, Long.valueOf(0));
    }

    //String fName = getFileName(e);
    String fName = file.getName();
    if (fName.startsWith(STR_DOT)) {
      sendNotFound(e, fName);
    } else {
      Headers headers = e.getRequestHeaders();
      int indexVal = index.intValue();
      if (headers.containsKey(RANGE_HEADER)) {
        logger.info("range header present, serving list file parts");
        serveListParts(e, s, lName, file, indexVal);
        //serveList(e, s, lName, file, indexVal);
      } else {
        //if (fName.length() < 1 || fName.endsWith(Server.SLASH)) {
        //  ResourceBundle rb = ResourceBundle.getBundle(App.RB_NAME);
        //  fName += getResString(RB_WELCOME_FILE);
        //}
        
        logger.info("no range header or header ignored, streaming whole files");
        serveList(e, s, lName, file, indexVal);
        //while(file != null) {
        //  files.put(lName, file);
        //  listen.put(lName, index);
        //  serveFile(e, file);
        //  file = getFileToPlay(s, lName, ++indexVal);
        //}
      }
    }
    
    /*
    String response = lName;
    Headers headers = e.getResponseHeaders();
    headers.add("Content-Type", "application/json");
    e.sendResponseHeaders(200, response.length());
    OutputStream os = e.getResponseBody();
    os.write(response.getBytes());
    os.close();
     */
  }
  
  private void serveListParts(HttpExchange e, FileStorage s, String lName, File file, int indexVal) throws IOException {
    if (file.exists()) {
      setHeaders(e, file);
      //e.getResponseHeaders().set(CONTENT_LENGTH, Long.toString(Long.MAX_VALUE));
      //e.sendResponseHeaders(SC_OK, Long.MAX_VALUE);
      //e.getResponseHeaders().set(CONTENT_LENGTH, Long.toString(Long.MAX_VALUE));
      //e.sendResponseHeaders(SC_OK, Long.MAX_VALUE);
      //e.sendResponseHeaders(SC_PARTIAL_CONTENT, Long.MAX_VALUE);
      logger.info("playing " + file.getName());
      logger.info("file length: " + file.length());
      InputStream is = new FileInputStream(file);
      OutputStream os = e.getResponseBody();
      while (file != null) {     
        //if(is instanceof InputStream) {
        //  is.close();
        //}
        //is = new FileInputStream(file);
        files.put(lName, file);
        listen.put(lName, indexVal);
        file = serveFileParts(e, file, is, os, s, lName, indexVal);
        //serveFile(e, file);
        if(bytes.get(lName) == 0l) {
          file = getFileToPlay(s, lName, ++indexVal);
          if(is instanceof InputStream) {
            is.close();
          }
          is = new FileInputStream(file);    
          logger.info("file length: " + file.length());
        }
        logger.info("playing " + file.getName());
      }
      //os.flush();
      if(is instanceof InputStream) {
        is.close();
      }
      logger.info("fertig os flush und close ");
      os.flush();
      os.close();
    } else {
      sendNotFound(e, file.getName());
    }
    logger.info("ende");
  }
  
  
  
  protected File serveFileParts(HttpExchange e, File file, InputStream is, OutputStream os, FileStorage s, String lName, int indexVal) throws IOException {
    if (file.exists()) {
      setHeaders(e, file);
      //Long byteCount = bytes.get(lName);
      //logger.info("byteCount at start: " + byteCount);
      long responseLength = 0;
      long start = 0;
      long end;
      String hdr;
      RangeGroup rangeGroup = parseRanges(e, file);
      Iterator<Range> i = rangeGroup.getRanges();
      Headers resHeaders = e.getResponseHeaders();
      while (i.hasNext()) {
        Range range = i.next();
        start = range.getStart();
        //start = 0;
        end = range.getEnd();
        //end = file.length();
        //responseLength += (end - start);
        //start = 0;
        //end = responseLength;
        //range.setStart(start);
        //range.setEnd(end);
        
        hdr = contentRangeHdr(range, file);
        resHeaders.add(CONTENT_RANGE_HEADER, hdr);
        logger.info("added header " + hdr);
        responseLength += (end - start);
      }
      logger.info("responseLength: " + responseLength);
      e.sendResponseHeaders(SC_PARTIAL_CONTENT, responseLength);
      //e.sendResponseHeaders(SC_PARTIAL_CONTENT, Long.MAX_VALUE);
      //logger.info("responseHeaders gesendet ");
      //if(HTTP_GET.equalsIgnoreCase(e.getRequestMethod())) {
        //InputStream is = new FileInputStream(file);
        //OutputStream os = e.getResponseBody();
        //long streamPos = bytes.get(lName);
        long count = 0;
        if (start > 0) {
          logger.info("skip to " + start);
          is.skip(start);
        }
        int byteRead = is.read();
        logger.info("starte while mit count=" + count);
        while (/*byteRead > -1 && */ count < responseLength) {
          ++count;
          //++streamPos;
          os.write(byteRead);
          byteRead = is.read();
          //logger.info("byteRead " + byteRead);
          if(byteRead < 0 && count < responseLength) {
            logger.info("dateiende, naechste Datei");
            
            file = getFileToPlay(s, lName, ++indexVal);
            if(file != null) {
              logger.info("playing " + file.getName());
              //streamPos = 0;
              is.close();
              is = new FileInputStream(file);
              byteRead = is.read();
              logger.info("neue Datei, count " + count + " responseLength " + responseLength);
              logger.info("file length: " + file.length());
            } else {
              //logger.info("Liste zuende");
              count = Long.MAX_VALUE;         
              logger.info("Liste zuende");
            }
          }
        }
        logger.info("while ende, count " + count);
        //if(streamPos != responseLength) {
        //  bytes.put(lName, streamPos);
        //  logger.info("streamPos " + streamPos);
        //} else {
        //  bytes.put(lName, Long.valueOf(0));
        //  logger.info("streamPos " + 0);
        //}
        //byteCount = count;
        
        //logger.info("byteCount at end: " + byteCount);
        //os.flush();
        //os.close();
        // is.close();
      }
    //} else {
    //  sendNotFound(e, file.getName());
    //}
    logger.info("ende");
    return file;
  }
  
  protected String contentRangeHdr(Range range, File file) {
    StringBuilder sb = new StringBuilder();
    sb.append(getResString(RB_BYTES));
    sb.append(STR_BLANK);
    sb.append(range.getStart());
    sb.append(getResString(RB_DASH));
    sb.append(range.getEnd());
    sb.append(Server.SLASH);
    //sb.append(file.length());
    sb.append(Long.MAX_VALUE);
    return sb.toString();
  }

  
  
  private void serveList(HttpExchange e, FileStorage s, String lName, File file, int indexVal) throws IOException {
    if (file.exists()) {
      setHeaders(e, file);
      e.getResponseHeaders().set(CONTENT_LENGTH, Long.toString(Long.MAX_VALUE));
      //e.sendResponseHeaders(SC_OK, Long.MAX_VALUE);
      InputStream in = new FileInputStream(file);
      OutputStream out = e.getResponseBody();
      while (file != null) {
        files.put(lName, file);
        listen.put(lName, indexVal);
        serveFile(e, file, in, out);
        file = getFileToPlay(s, lName, ++indexVal);
      }
      out.flush();
      out.close();
      in.close();
    } else {
      sendNotFound(e, file.getName());
    }
  }
  
  /**
   * Den Inhalt einer Datei ausliefern
   *
   * @param e das Objekt mit Methoden zur Untersuchung der Anfrage sowie zum
   * Anfertigen und Senden der Antwort
   * @param file die Datei, deren Inhalt ausgeliefert werden soll
   * @throws IOException falls etwas schief geht entsteht dieser Fehler
   */
  protected void serveFile(HttpExchange e, File file, InputStream in, OutputStream out) throws IOException {
    logger.info("serving file " + file.getName());
      //if(HTTP_GET.equalsIgnoreCase(e.getRequestMethod())) {
        int b = in.read();
        while (b > -1) {
          out.write(b);
          b = in.read();
        }
        logger.info("done serving file " + file.getName());
        //in.close();
        //out.flush();
      //}
  }

  

  private File getFileToPlay(FileStorage s, String lName, int index) {
    Entity entity = s.read(FileStorage.ST_ABSPIELLISTE, lName);
    if (entity instanceof Abspielliste) {
      Abspielliste liste = (Abspielliste) entity;
      List<Titel> titelListe = liste.getTitel();
      if(titelListe.size() > index) {
        Titel t = titelListe.get(index);
        String katalogUrl = t.getKatalogUrl();
        String pfad = kataloge.get(katalogUrl);
        return new File(pfad + t.getPfad(), t.getName());
      } else {
        return null;
      }
    } else {
      // keine Abspielliste
      return null;
    }
  }

  private void ablageorteLesen() {
    String typ = Ablageort.class.getSimpleName();
    FileStorage store = new FileStorage(conf);
    List<String> orte = store.list(typ);
    Iterator<String> i = orte.iterator();
    while (i.hasNext()) {
      String ortName = i.next();
      Entity e = store.read(typ, ortName);
      if (e instanceof Ablageort) {
        Ablageort ablageort = (Ablageort) e;
        Logger logger = Logger.getLogger(StreamHandler.class.getName());
        //logger.log(Level.FINE, "{0}{1}", new Object[]{ctx, ablageort.getUrl()});
        logger.fine(ablageort.getOrt() + " " + ablageort.getUrl());
        kataloge.put(ablageort.getUrl(), ablageort.getOrt());
        //server.createContext(ctx + ablageort.getUrl(),  
        //new ListFileHandler(new File(ablageort.getOrt()).getAbsolutePath(), conf));
      }
    }
  }

}