/*
    Calypso - Media Player Remote Control via HTTP for Raspberry Pi
    Copyright (C) 2021-2023  Ulrich Hilger

    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU Affero General Public License as
    published by the Free Software Foundation, either version 3 of the
    License, or (at your option) any later version.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU Affero General Public License for more details.

    You should have received a copy of the GNU Affero General Public License
    along with this program.  If not, see <https://www.gnu.org/licenses/>.
*/

package de.uhilger.calypso.http;

import com.sun.net.httpserver.HttpContext;
import com.sun.net.httpserver.HttpExchange;
import de.uhilger.calypso.actor.PlayActor;
import de.uhilger.calypso.actor.ShellActor;
import de.uhilger.calypso.actor.StopServerActor;
import java.io.IOException;
import java.io.OutputStream;
import java.util.Collection;
import java.util.Map;
import java.util.logging.Level;
import java.util.logging.Logger;

/**
 * Der ApiHandler ist die proprietaer fuer Calypso vorgesehene 
 * Weise, HTTP-Anfragen zu verarbeiten.
 *
 * Der ApiHandler ist ein HttpHandler, der vom Server ueber die 
 * gesamte Laufzeit des Programmes hinweg gehalten wird. Deswegen 
 * beschraenkt sich der Programmcode des ApiHandlers auf die
 * Verteilung der Kommandos auf Aktoren. Die Aktoren werden je nach 
 * Bedarf instanziiert und enthalten zusammengenommen den Code 
 * des Anwendungskerns.
 *
 * @author Ulrich Hilger
 */
public class ApiHandler extends HttpApi {

  public static final int PLAYERCMD = 2;
  public static final int SERVERCMD = 3;
  public static final String PLAY = "play";
  public static final String PAUSE = "pause";
  public static final String SEEK = "seek";
  public static final String STOP = "stop";
  public static final String SERVER = "server";
  public static final String PING = "ping";
  
  public static final String PLAYER = "player-proc";
  
  /**
   * Die HTTP-Anfrage ausführen
   * 
   * WICHTIG: Die HTTP-Parameter aus dem Query-Teil muessen in 
   * der Reihenfolge sein, die vom Shell-Skript erwartet wird. 
   *
   * @param elems die Elemente des URI-Pfads
   * @param parameter die Parameter des Query-Teils der URI
   * @param exchange das Objekt mit Infos zum HTTP-Aufruf
   * @return die Antwort, die gesendet werden soll
   */
  @Override
  protected String process(String[] elems, Map parameter, HttpExchange exchange) {
    String antwort;
    Object o;

    switch (elems[PLAYERCMD]) {
      case PLAY:
        PlayActor a = new PlayActor();
        o = a.run(parameter);
        if (o instanceof Process) {
          exchange.getHttpContext().getAttributes().put(PLAYER, o);
          antwort = "Abspielprozess gestartet.";
        } else {
          // kein Prozess, es ist etwas schief gelaufen
          antwort = "Abspielen konnte nicht gestartet werden.";
        }
        break;

      case PAUSE:
      case SEEK:
        ShellActor pa = new ShellActor();      
        try {
          pa.run(getSkriptDir(exchange), elems[PLAYERCMD], toShellParams(parameter));
          antwort = elems[PLAYERCMD] + " ausgefuehrt";
        } catch (IOException ex) {
          Logger.getLogger(ApiHandler.class.getName()).log(Level.SEVERE, null, ex);
          antwort = "Fehler bei der Ausfuehrung von " + elems[PLAYERCMD];
        }        
        break;

      case STOP:
        o = exchange.getHttpContext().getAttributes().get(PLAYER);
        if(o instanceof Process) {
          Process p = (Process) o;
          p.destroy();
          antwort = "Player gestoppt.";
        } else {
          antwort = "Es wurde kein Player-Prozess zum Stoppen gefunden.";
        }
        break;
        
      case SERVER:
        if(elems[SERVERCMD].equals(STOP)) {
          try {
            antwort = "Calypso: Der Server wird angehalten und die App beendet.";
            sendResponse(exchange, antwort);
            new StopServerActor().run(exchange.getHttpContext());
          } catch (IOException ex) {
            Logger.getLogger(ApiHandler.class.getName()).log(Level.SEVERE, null, ex);
            antwort = "Fehler: " + ex.getLocalizedMessage();
          }
        } else {
          antwort = elems[SERVERCMD] + " ist ein unbekanntes Serverkommando";
        }
        break;
        
      case PING:
        antwort = elems[PLAYERCMD];
        break;
        
      default:
        antwort = "Kommando " + elems[PLAYERCMD] + " unbekannt";
        break;
    }

    return antwort;
  }
  
  private String[] toShellParams(Map parameter) {
    Collection<String> c = parameter.values();
    return c.toArray(String[]::new);
  }

  private String getSkriptDir(HttpExchange exchange) {
    HttpContext context = exchange.getHttpContext();
    Object o = context.getAttributes().get(Server.SKRIPT_DIR);
    if (o instanceof String) {
      return (String) o;
    } else {
      // kein Skript-Dir
      return "";
    }
  }
}