#!/bin/bash

# -*- coding: utf-8 -*-

### BEGIN INIT INFO
# Provides:          softcam
# Required-Start:    $local_fs
# Required-Stop:     
# Should-Start:      $time $remote_fs cardserver
# Should-Stop:     
# Default-Start:     2 3 4 5
# Default-Stop:      0 1 6
# Short-Description: oscam
# Description:       oscam SoftCAM, card reader and server.
### END INIT INFO

# Debbuging aktivieren
# set -x
#
#####################################
EMUNAME="oscamicamall"
EMUBIN="oscamicamall"

#####################################
OSD="oscamicamall"
CAMNAME="oscamicamall"
#####################################
PIDFILE=/var/tmp/${CAMNAME}.pid

CAMCONFIG_PATH="/etc/tuxbox/config/$CAMNAME"
CAM_BINARY="$CAMCONFIG_PATH/binary/$CAMNAME"
DAEMON="$CAMCONFIG_PATH/binary/$CAMNAME"
# Pfad zur oscam.conf
CAMCONFIG_PATH="$CAMCONFIG_PATH"
OSC_PATH="$CAMCONFIG_PATH/oscam.conf"
OSS_PATH="$CAMCONFIG_PATH/oscam.server"
OSU_PATH="$CAMCONFIG_PATH/oscam.user"
#####################################
#ANSWER_FILE="/tmp/message_answer.txt"           # muss wie in der message script heisen
ANSWER_FILE="/tmp/yesno"             # muss wie in der message script heisen

ANSWER_URL="http://localhost/web/messageanswer"  # Enigma2 Antwort-API von der message in den file geschrieben
LOGDIR="/tmp"
LOGFILE=$LOGDIR/kitte888_StartScript.log
#Generelles Logging.
exec 3>&1 4>&2
trap 'exec 2>&4 1>&3' 0 1 2 3
# Log-Ausgaben mit Zeitstempel versehen
# exec > >(while IFS= read -r line; do echo "$(date '+%Y-%m-%d %H:%M:%S') - $line"; done >> $LOGFILE) 2>&1


echo " ###########################################################      Start Variablen " >> $LOGFILE

MESSAGE_PATH=$CAMCONFIG_PATH/message/message_box.sh
echo "$MESSAGE_PATH" >> $LOGFILE

# msg-type ist die art der message , info , warnung usw , message_zeit ist die zeit wie lange sie angezeigt wird
msg_type=1
message_zeit=1

echo "############################################################" >> $LOGFILE
echo " $PIDFILE " >> $LOGFILE
echo " $CAMCONFIG_PATH" >> $LOGFILE
echo " $CAM_BINARY" >> $LOGFILE
echo " $OSC_PATH" >> $LOGFILE
echo " $OSS_PATH" >> $LOGFILE
echo " $OSU_PATH" >> $LOGFILE
echo "############################################################" >> $LOGFILE

IP_ADDR=$(ip route get 1 | awk '{print $7; exit}')
echo "$IP_ADDR" >> $LOGFILE
echo "############################################################" >> $LOGFILE
###############################################################################


############################################## hier aufrufen des camscripts  #############################################################
# ---------------------------------------------------------------------------------------------------------------------------------------- Funktion zum Starten von OSCam
camstart() {
    echo "----------------------------------------------------------------------------------------------------------------------- Cam Start" >> $LOGFILE
    echo "###########################################################              Oscam start  " >> $LOGFILE
    echo "$CAMCONFIG_PATH" >> $LOGFILE
    echo "$CAM_BINARY" >> $LOGFILE
    echo "$DAEMON" >> $LOGFILE
    echo "$IP_ADDR" >> $LOGFILE
    echo "###########################################################              Parameter start  " >> $LOGFILE

    MESSAGE="OSCAM start "
    # Python-Skript aufrufen
    sleep 0
    #python "$MESSAGE_PATH" "$MESSAGE" "$msg_type" "$message_zeit" >> $LOGFILE 2>&1
    
echo "$(date) - Starte OSCam..."
    ulimit -s 1024
    # Setze den Statuscode auf 0
    STATUS=0
    # Hier den Befehl zum Starten von OSCam einfügen
    echo "$DAEMON --config-dir $CAMCONFIG_PATH --daemon --pidfile $PIDFILE --restart 2 " 2>&1 >> $LOGFILE
    $DAEMON -b -B -r 2 -w 1 -c $CAMCONFIG_PATH  --pidfile $PIDFILE 

    STATUS=$?  # Setze den Statuscode basierend auf dem Ausführungsstatus des Befehls
    echo "Statuscode: $STATUS" >> $LOGFILE
    
    if [ $STATUS -ne 0 ]; then
        sleep 1
        echo "oscam hat nicht gestartet , nochmal starten fehler ausgabe" >> $LOGFILE
        CAM_UP_OUTPUT="$($DAEMON --config-dir $CAMCONFIG_PATH --daemon --pidfile $PIDFILE --restart 2 2>&1)"
        echo "cam start gestartet error message " >> $LOGFILE
        ERROR_MESSAGE="Fehler beim Starten der Oscam: $CAM_UP_OUTPUT"
        echo "$ERROR_MESSAGE" >> $LOGFILE
        
        echo "cam start error mesage ausgabe ende " >> $LOGFILE
    fi
    sleep 1         # keine komma eingeben o.5 
    echo "Fehlerausgabe: $output" >> $LOGFILE
    echo "Fehlerausgabe2 : $?" >> $LOGFILE

    if [ $? -eq 0 ]; then
        echo "$(date) - OSCam erfolgreich gestartet." >> $LOGFILE
    else
        echo "$(date) - Fehler beim Starten von OSCam!" >> $LOGFILE
        echo "Fehlerausgabe: $output" >> $LOGFILE
    fi
}

# ---------------------------------------------------------------------------------------------------------------------------------------- Funktion zum Stoppen von OSCam
camstop() {
    echo "----------------------------------------------------------------------------------------------------------------------- Cam Stop" >> $LOGFILE
    echo "$(date) - Stoppe OSCam..." >> $LOGFILE

    kill `cat $PIDFILE 2> /dev/null` 2> /dev/null
    RETVAL=$?
    
    if [ "$RETVAL" -eq "0" ]; then
        echo " retval ok " >> $LOGFILE
        echo "OK" >> $LOGFILE
    else
        echo " retval fail " >> $LOGFILE
        echo "FAILED" >> $LOGFILE
    fi


    # Hier den Befehl zum Beenden von OSCam einfügen
    echo "killall" >> $LOGFILE
    echo $CAMNAME >> $LOGFILE
    killall $CAMNAME 2> /dev/null
    
if [ $? -eq 0 ]; then
        echo "$(date) - OSCam erfolgreich gestoppt." >> $LOGFILE
    else
        echo "$(date) - Fehler beim Stoppen von OSCam!" >> $LOGFILE
        MESSAGE="OSCAM not stopt  "
        message_zeit=3
        msg_type=1
        # Python-Skript aufrufen
        #python "$MESSAGE_PATH" "$MESSAGE" "$msg_type" "$message_zeit" >> $LOGFILE 2>&1
        message_zeit=1      # wieder zurueck setzen
    fi
}
# ---------------------------------------------------------------------------------------------------------------------------------------- Funktion für Version oder Info
camversion_info() {
    echo "----------------------------------------------------------------------------------------------------------------------- version info" >> $LOGFILE
    echo "$(date) - OSCam Version oder Info anzeigen..." >> $LOGFILE
    # Beispiel für Version-Info von OSCam
    /usr/bin/oscam --version
    echo " version " >> $LOGFILE
    $CAMNAME -V | grep 'Version\|IPv6' | sed 's/Version:[ ]*//' | sed 's/IPv6.*yes/with IPv6/g' | sed 's/IPv6.*no/IPv4-only/g' | sed ':a;N;$!ba;s/\n/ /g'
}

configfiles_vorhanden() {
    echo " ---------------------------------------------------------------------------------------------------------------------- check sind die configfiles vorhanden " >> $LOGFILE
    OSC_not=0
    OSS_not=0
    OSU_not=0

    if [ -d "$CAMCONFIG_PATH" ]; then
        echo "Config Directory exist" >> $LOGFILE

        if [ -f "$OSC_PATH" ]; then
            echo "Oscam.config file exist" >> $LOGFILE
        else
            echo "Oscam.config file not exist" >> $LOGFILE
            OSC_not=1
        fi

        if [ -f "$OSS_PATH" ]; then
            echo "Oscam.server file exist" >> $LOGFILE
        else
            echo "Oscam.server file not exist" >> $LOGFILE
            OSS_not=1
        fi

        if [ -f "$OSU_PATH" ]; then
            echo "Oscam.user file exist" >> $LOGFILE
        else
            echo "Oscam.user file not exist" >> $LOGFILE
            OSU_not=1
        fi

        if [ "$OSC_not" -eq 1 ] || [ "$OSS_not" -eq 1 ] || [ "$OSU_not" -eq 1 ]; then
            MESSAGE="OSCAM config or server or user not exist"
            message_zeit=3
            python "$MESSAGE_PATH" "$MESSAGE" "$msg_type" "$message_zeit" >> $LOGFILE 2>&1
            message_zeit=1      # wieder zurueck setzen
        else
            echo "Oscam files all exist" >> $LOGFILE
        fi

    else
        echo "Config Directory not exist" >> $LOGFILE
        message_zeit=3
        MESSAGE="OSCAM config Direction not exist"
        python "$MESSAGE_PATH" "$MESSAGE" "$msg_type" "$message_zeit" >> $LOGFILE 2>&1
        message_zeit=1      # wieder zurueck setzen
    fi
}
###########################################################################

check_binary() {
    echo "----------------------------------------------------------------------------------------------------------------------- check Binary exist und dateirechte" >> $LOGFILE
  PYTHON_VERSION=$(python --version 2>&1)
  echo "Python version ist : $PYTHON_VERSION" >> $LOGFILE
  if [ -f "$CAM_BINARY" ]; then
    echo "datei  ist vorhanden in : $CAM_BINARY" >> $LOGFILE
    if [[ $PYTHON_VERSION == *"Python 3."* ]]; then
      echo "Python 3 ist installiert." >> $LOGFILE
      # Berechtigungen der Datei auslesen
      PERMISSIONS=$(stat -c "%a" $CAM_BINARY)
      echo "Aktuelle Berechtigungen: $PERMISSIONS" >> $LOGFILE
      if [[ -s "$CAM_BINARY" ]]; then
        echo "Die Datei $CAM_BINARY existiert und hat Inhalt"  >> $LOGFILE
        # Überprüfen, ob die Berechtigungen auf 755 gesetzt sind
        if [ "$PERMISSIONS" != "755" ]; then
          echo "Berechtigungen sind nicht korrekt, werden auf 755 gesetzt" >> $LOGFILE
          # Setze die Berechtigungen auf 755
          chmod 755 $CAM_BINARY
          echo "Neue Berechtigungen: $(stat -c "%a" $CAM_BINARY)" >> $LOGFILE
          MESSAGE="$CAM Binaryhatte keine 755 rechte , 755 gemacht - Oscam not Startet "
          message_zeit=3
          #python "$MESSAGE_PATH" "$MESSAGE" "$msg_type" "$message_zeit" >> $LOGFILE 2>&1
          message_zeit=1        # wieder zurueck setzen
        else
          echo "Berechtigungen sind bereits korrekt" >> $LOGFILE
        fi
      else
        echo "Kopiere Binary backup nach $CAM_BINARY"  >> $LOGFILE
        cp /etc/tuxbox/config/oscamicamall/backup/oscamicamall $CAM_BINARY
        echo "file copiert" >> $LOGFILE
        chmod +x $CAM_BINARY
        echo "rechte gesetzt " >> $LOGFILE
        echo "Die Datei $CAM_BINARY existiert, ist aber leer o bytes neu copiert." >> $LOGFILE
        #MESSAGE="$CAM Binary ist 0 byts - Binary copiert "
        #message_zeit=5
        #python "$MESSAGE_PATH" "$MESSAGE" "$msg_type" "$message_zeit" >> $LOGFILE 2>&1
        #message_zeit=1     # wieder zurueck setzen
      fi
    else
        echo "Python 2 ist installiert." >> $LOGFILE
        if [[ -s "$CAM_BINARY" ]]; then
          echo "Die Datei $CAM_BINARY existiert und hat Inhalt"  >> $LOGFILE
          chmod 755 $CAM_BINARY
        else
          echo "Kopiere Binary backup nach $CAM_BINARY"  >> $LOGFILE
          cp /etc/tuxbox/config/oscamicamall/backup/oscamicamall $CAM_BINARY
          echo "file copiert" >> $LOGFILE
          chmod +x $CAM_BINARY
          echo "rechte gesetzt " >> $LOGFILE
        fi
    fi
  else
        echo "Kopiere Binary aus backup nach $CAM_BINARY"  >> $LOGFILE
        cp /etc/tuxbox/config/oscamicamall/backup/oscamicamall $CAM_BINARY
        echo "file copiert" >> $LOGFILE
        chmod +x $CAM_BINARY
        echo "rechte gesetzt " >> $LOGFILE
        echo " $CAM Binary not exist" >> $LOGFILE
        MESSAGE="$CAM Binary not exist "
        message_zeit=5
        python "$MESSAGE_PATH" "$MESSAGE" "$msg_type" "$message_zeit" >> $LOGFILE 2>&1
        message_zeit=1      # wieder zurueck setzen
    fi

    
}

check_readerupdate() {
    # ------------------------------------------------ check oscam.server oder cccam.cfg , kann man noch script aufrufen einbauen 
    echo "----------------------------------------------------------------------------------------------------------------------- check oscam.server oder cccam.cfg exist " >> $LOGFILE
    if [ -f "/tmp/oscam.server" ] || [ -f "/tmp/CCcam.cfg" ]; then
        echo " es ist eine datei vorhnaden "  >> $LOGFILE
        MESSAGEENDE="oscam.server or cccam.cfg in tmp exist \ndu kannst das script aufrufen"
        messageout=1
        echo $messageout  >> $LOGFILE
    else
        echo "keine Dateien existieren."  >> $LOGFILE
        messageout=0
    
    fi
    echo "###########################################################" >> $LOGFILE
}
###########################################################################

port_auslesen() {
    echo "----------------------------------------------------------------------------------------------------------------------- port auslesen" >> $LOGFILE

    # httpport aus oscam.conf auslesen
    HTTP_PORT=$(grep -E '^httpport\s*=' $OSC_PATH | awk -F'=' '{print $2}' | tr -d ' ')
    # Überprüfen, ob der Port erfolgreich ausgelesen wurde
    if [ -z "$HTTP_PORT" ]; then
        echo "Fehler: httpport konnte nicht aus oscam.conf ausgelesen werden."
        #exit 1
    fi
    echo "###########################################################" >> $LOGFILE
    echo "HTTP Port ist: $HTTP_PORT" >> $LOGFILE
    echo "###########################################################" >> $LOGFILE
    echo "">> $LOGFILE
}
###########################################################################


binary_update() {
    # Binary Update
    echo "----------------------------------------------------------------------------------------------------------------------- check Binary in Tmp" >> $LOGFILE
    # Prüfen, ob die neue Binary existiert
    if [ -f "/tmp/${CAMNAME}.new" ]; then
        MESSAGE="OSCAMBINARY UPDATE"
        echo "Gefunden: Neue Binary für $CAM_BINARY im /tmp Verzeichnis." >> $LOGFILE

        # Nachricht anzeigen
        msg_type=0  # Typ 0 = Ja/Nein-Frage
        message_zeit=10
        python "$MESSAGE_PATH" "$MESSAGE" "$msg_type" "$message_zeit" >>  $LOGFILE

        # Benutzerantwort auswerten
        echo "Warte auf Benutzerantwort..." >> $LOGFILE
        response=$(curl -s "$ANSWER_URL")  # API-Abfrage durchführen
        echo "API-Antwort: $response" >>  $LOGFILE
        echo "Abgefragte URL: $ANSWER_URL" >> $LOGFILE



        # Warte auf Antwortdatei (max. 12 Sekunden)
        timeout=12
        elapsed=0
        while [[ ! -s "$ANSWER_FILE" && $elapsed -lt $timeout ]]; do
            sleep 1
            elapsed=$((elapsed + 1))
            echo "Warte... ($elapsed Sekunden)" >> $LOGFILE
        done

        # Prüfen, ob die Datei existiert und nicht leer ist
        if [[ -s "$ANSWER_FILE" ]]; then
            file_content=$(cat "$ANSWER_FILE")
            echo "Antwortdatei ist $file_content!" >> $LOGFILE

            if [[ "$file_content" == "yes" ]]; then
                echo "Antwort ist yes" >> $LOGFILE
                user_response="yes"
            else
                echo "Antwort ist no" >> $LOGFILE
                user_response="no"
            fi
        else
            echo "KEINE Antwort erhalten, Timeout!" >> $LOGFILE
        fi


        echo "Antwort Neue Binary ist: $user_response (yes = weiter, no = abbrechen)" >> $LOGFILE

        if [ "$user_response" = "yes" ]; then
            # Update-Skript ausführen
            echo "Starte Binary-Update für $CAM_BINARY" >> $LOGFILE

            #etc/tuxbox/config/oscamicamall/scripte/binary_update.sh

            # Neue Binary kopieren und ausführbar machen
            echo "Kopiere neue Binary /tmp/${CAMNAME}.new nach $CAM_BINARY"  >> $LOGFILE
            cp /tmp/${CAMNAME}.new $CAM_BINARY
            echo "file copiert" >> $LOGFILE
            chmod +x $CAM_BINARY
            echo "rechte gesetzt " >> $LOGFILE

            sleep 1
            MESSAGE="OSCAMBINARY UPDATE FINISH"
            msg_type=1
            message_zeit=2
            python "$MESSAGE_PATH" "$MESSAGE" "$msg_type" "$message_zeit"
            rm -f /tmp/${CAMNAME}.new
        else
            # Update abbrechen
            MESSAGE="OSCAMBINARY UPDATE ABGEBROCHEN"
            msg_type=1
            message_zeit=2
            #python "$MESSAGE_PATH" "$MESSAGE" "$msg_type" "$message_zeit"
            echo "Update wurde abgebrochen." >> $LOGFILE
        fi
    else
        echo "Keine neue Binary in tmp gefunden ." >> $LOGFILE
        
    fi

}
###########################################################################
check_camrunning () {
    echo "----------------------------------------------------------------------------------------------------------------------- check ist eine cam noch running " >> $LOGFILE
    echo " zu check cam runnig und wenn ja stoppen" >> $LOGFILE
    echo " " >> $LOGFILE
    /etc/tuxbox/config/oscamicamall/scripte/oscam_run_stop.sh
    echo " zurueck check cam runnig" >> $LOGFILE
    echo " " >> $LOGFILE
}
###########################################################################
check_oscam_start_ok() {
    echo "----------------------------------------------------------------------------------------------------------------------- check oscam start ok" >> $LOGFILE
    echo "check oscam start ok"
    RETVAL=1
    [ -e $PIDFILE ] && RETVAL=0
    echo " $RETVAL  " >> $LOGFILE

    if [ "$RETVAL" -eq "0" ]; then
        echo "retval ok " >> $LOGFILE
      

        echo "##########################################################" >> $LOGFILE
        # Prüfen, ob der HTTP_PORT definiert und nicht leer ist
        if [ -n "$HTTP_PORT" ]; then
            echo "Check WebIF..." >> $LOGFILE
            echo "Http port: $HTTP_PORT" >> $LOGFILE
            
            # Überprüfen des WebIF
            #WEBIF_CHECK=$(wget --spider -S "http://localhost:$HTTP_PORT" 2>&1 | grep "HTTP/" | awk '{print $2}') die geht in der Dream nicht -S
    
            WEBIF_CHECK=$(wget --spider "http://localhost:$HTTP_PORT" 2>&1)
            
                        
            
            #if [ "$WEBIF_CHECK" -eq 200 ]; then
            if echo "$WEBIF_CHECK" | grep -q "Connecting to"; then
                echo "WebIF ist erreichbar." >> $LOGFILE
                MESSAGE="OSCAM Webif is running ------ $IP_ADDR:$HTTP_PORT "
                message_zeit=3
				msg_type=1
                # Python-Skript aufrufen
                python "$MESSAGE_PATH" "$MESSAGE" "$msg_type" "$message_zeit" >> $LOGFILE 2>&1
                message_zeit=1      # wieder zurueck setzen

            else
                echo "WebIF nicht erreichbar, HTTP Status: $WEBIF_CHECK" >> $LOGFILE
                MESSAGE="OSCAM not start - Oscam Webif is not running."
                MESSAGE="$ERROR_MESSAGE"
                echo "$ERROR_MESSAGE" >> $LOGFILE
                echo "$MESSAGE" >> $LOGFILE
                # Python-Skript aufrufen
                message_zeit=5
                python "$MESSAGE_PATH" "$MESSAGE" "$msg_type" "$message_zeit" >> $LOGFILE 2>&1
                message_zeit=1      # wieder zurueck setzen
            fi
            
            
            
        fi
    else
        echo " retval fail " >> $LOGFILE
        echo "FAILED Oscam not running " >> $LOGFILE
        MESSAGE=$ERROR_MESSAGE
        #MESSAGE="OSCAM not start - Oscam Webif is not running."
        message_zeit=5
        python "$MESSAGE_PATH" "$MESSAGE" "$msg_type" "$message_zeit" >> $LOGFILE 2>&1
        message_zeit=1      # wieder zurueck setzen
    fi

}
########################################################################################


check_oscamserverversion () {
    echo "----------------------------------------------------------------------------------------------------------------------- check oscam version server " >> $LOGFILE
    echo "oscamversion"
	MESSAGE="Check OSCAM UPDATE"
	echo "Messagge check update" >> $LOGFILE
	# Nachricht anzeigen
	msg_type=1  
	message_zeit=1
	python "$MESSAGE_PATH" "$MESSAGE" "$msg_type" "$message_zeit" >>  $LOGFILE
    # Pfad zur OSCam-Informationsdatei
    OSCAM_INFO_FILE="/tmp/.oscam/oscam.version"  # Beispiel: /usr/local/etc/oscam

    # Zielort im /tmp-Ordner
    TMP_FILE="/tmp/oscam.version"
    #sleep 2
    # Datei in /tmp kopieren
    cp -rf "$OSCAM_INFO_FILE" "$TMP_FILE"

    if [ -e "$TMP_FILE" ]; then
        camversion=99999
        cpuversion=""

        while IFS= read -r zeile; do
            if [[ $zeile == *"Version"* ]]; then
                echo "cam version gefunden" >> $LOGFILE
                camversion=$(echo "$zeile" | cut -d':' -f2 | xargs)
                break  # Sobald die Version gefunden wurde, die Schleife beenden
            fi
        done < "$TMP_FILE"

        if [ -n "$camversion" ]; then
            echo "cam version ausgabe: $camversion" >> $LOGFILE
        else
            echo "cam version nicht gefunden" >> $LOGFILE
        fi

        while IFS= read -r zeile; do
            if [[ $zeile == *"Compiler"* ]]; then
                echo "cpu version gefunden" >> $LOGFILE
                cpuversion=$(echo "$zeile" | cut -d':' -f2 | xargs)
                break  # Sobald die Version gefunden wurde, die Schleife beenden
            fi
        done < "$TMP_FILE"

        if [ -n "$cpuversion" ]; then
            echo "cpu version ausgabe: $cpuversion" >> $LOGFILE
        else
            echo "cpu version nicht gefunden" >> $LOGFILE
        fi
    fi

    
    result=$(echo "$camversion" | cut -d'-' -f2-)
    echo "$result"  >> $LOGFILE

    camversion=$(echo "$result" | cut -d'-' -f1)
    echo "$camversion"  >> $LOGFILE

    echo "cpu version"  >> $LOGFILE
    result=$(echo "$cpuversion" | cut -d'-' -f1)
    echo "$result"  >> $LOGFILE
    cpuversion="$result"
    echo "$cpuversion"  >> $LOGFILE

    CPU_FILE="/etc/tuxbox/config/oscamicamall/versionen/cpu"
    # Datei erstellen oder ueberschreiben mit cpuversion
    echo  "$cpuversion" + "$CPU_FILE" >> $LOGFILE

    echo "zu download datei"  >> $LOGFILE
    /etc/tuxbox/config/oscamicamall/scripte/update_oscam.sh         # datei version oscam  herunterladen in version 
    #sleep 2
    echo "von download zurueck"  >> $LOGFILE

    local_path="/etc/tuxbox/config/oscamicamall/versionen/version.new"
###################################################################################################################
    # Überprüfen, ob die Datei existiert
    if [ -f $local_path ]; then
        # Versionsnummer aus der Datei lesen
        file_version=$(head -n 1 "$local_path" | tr -d '\r')

        #with open($local_path, 'r') as datei:
        #    file_version = datei.read().strip()  # Den gelesenen Text bereinigen

        echo "Gelesene Version aus der Datei: $file_version" >> $LOGFILE
        echo "camversion: $camversion" >> $LOGFILE

        # Versionsvergleich
        #if [[ $(echo -e "$file_version\n$camversion" | sort -V | tail -n1) == "$file_version" && "$file_version" != "$camversion" ]]; then
        if [ "$file_version" -gt "$camversion" ]; then
            echo "Die datei Version ist größer der camversion." >> $LOGFILE

            MESSAGE="OSCAMVERSION UPDATE"
            echo "Gefunden: Neue Oscam $file_version alte version : $camversion ." >> $LOGFILE
            echo "Messagge Antwort fragen" >> $LOGFILE
            # Nachricht anzeigen
            msg_type=0  # Typ 0 = Ja/Nein-Frage
            message_zeit=10
            python "$MESSAGE_PATH" "$MESSAGE" "$msg_type" "$message_zeit" >>  $LOGFILE
            echo "Messagge Antwort ende" >> $LOGFILE
            # Antwort aus XML extrahieren
            # Pfad zur Antwortdatei
            user_response="no"
            echo "DEBUG: ANSWER_FILE=$ANSWER_FILE" >> $LOGFILE


            # Warte auf Antwortdatei (max. 12 Sekunden)
            timeout=12
            elapsed=0
            while [[ ! -s "$ANSWER_FILE" && $elapsed -lt $timeout ]]; do
                sleep 1
                elapsed=$((elapsed + 1))
                echo "Warte... ($elapsed Sekunden)" >> $LOGFILE
            done

            # Prüfen, ob die Datei existiert und nicht leer ist
            if [[ -s "$ANSWER_FILE" ]]; then
                file_content=$(cat "$ANSWER_FILE")
                echo "Antwortdatei ist $file_content!" >> $LOGFILE

                if [[ "$file_content" == "yes" ]]; then
                    echo "Antwort ist yes" >> $LOGFILE
                    user_response="yes"
                else
                    echo "Antwort ist no" >> $LOGFILE
                    user_response="no"
                fi
            else
                echo "KEINE Antwort erhalten, Timeout!" >> $LOGFILE
            fi

            echo "Antwort : $user_response (yes = weiter, no = abbrechen)" >> $LOGFILE

            if [ "$user_response" = "yes" ]; then
                # Update-Skript ausführen
                echo "Starte Oscam-Update für $CAM_BINARY" >> $LOGFILE

                camstop                                                             # erst cam stoppen

                #/etc/tuxbox/config/oscamicamall/scripte/download_oscam.sh
                echo "------------------------------------------------------------- zu download oscam server" >> $LOGFILE
                CPU_VERSION="$cpuversion"   # von außen übergeben
                echo "------------------------------------------------------------- zu download oscam server cpu ist" $CPU_VERSION >> $LOGFILE
                PYTHON_SCRIPT="/etc/tuxbox/config/oscamicamall/scripte/download_oscam.sh"
                #
                #Aufruf mit Übergabe der CPU-Version
                python "$PYTHON_SCRIPT" "$CPU_VERSION"       # datei oscambinary herunterladen

                DOWNLOAD_STATUS=$?

                if [ $DOWNLOAD_STATUS -eq 0 ]; then
                    echo "Download erfolgreich" >> $LOGFILE
                    MESSAGE="OSCAMBINARY UPDATE FINISH"
                    msg_type=1
                else
                    echo "Download fehlgeschlagen! Status: $DOWNLOAD_STATUS" >> $LOGFILE
                    MESSAGE="OSCAMBINARY DOWNLOAD ERROR"
                    msg_type=2
                fi

                echo "zurueck von download oscam server" >> $LOGFILE
                sleep 1

                msg_type=1
                message_zeit=2
                python "$MESSAGE_PATH" "$MESSAGE" "$msg_type" "$message_zeit"
                camstart
                check_oscam_start_ok
                        
                
            else
                # Update abbrechen
                MESSAGE="OSCAM UPDATE ABGEBROCHEN"
                msg_type=1
                message_zeit=2
                #python "$MESSAGE_PATH" "$MESSAGE" "$msg_type" "$message_zeit"
                echo "Update wurde abgebrochen." >> $LOGFILE
            fi


            
        else
            echo "Die datei Version ist kleiner oder gleich,  als die camversion." >> $LOGFILE
        fi

        
    else
        echo "Die Datei $local_path existiert nicht." >> $LOGFILE
    fi
    

}




###########################################################################
ende_message() {
    echo "----------------------------------------------------------------------------------------------------------------------- message am ende fuer user " >> $LOGFILE
    echo $messageout 
    if [ "$messageout" -eq 1 ]; then
        echo " es ist eine datei vorhnaden "  >> $LOGFILE
        MESSAGE=$MESSAGEENDE
        sleep 3
        msg_type=1
        message_zeit=5
        python "$MESSAGE_PATH" "$MESSAGE" "$msg_type" "$message_zeit" >> $LOGFILE 2>&1
        message_zeit=1  # Wieder zurücksetzen
    else
        echo "keine message."  >> $LOGFILE
    
    fi
    echo "###########################################################" >> $LOGFILE
}

###########################################################################

cam_remove_clean () {
    echo "----------------------------------------------------------------------------------------------------------------------- remove/ clean files" >> $LOGFILE
    rm -rf /tmp/*.info* /tmp/*.tmp* /tmp/*share* /tmp/*.pid* /tmp/*sbox*
}
###########################################################################
systemzeit () {
    echo "----------------------------------------------------------------------------------------------------------------------- Check Systemzeit" >> $LOGFILE

    # Python-Skript ausführen und Ausgabe in einer Variablen speichern
    output=$(python /etc/tuxbox/config/oscamicamall/scripte/zeit.py)
    echo "Die Systemzeit ist $output  " >> $LOGFILE
    # Prüfen, ob das Skript "OK" zurückgegeben hat
    if [[ "$output" == *"OK"* ]]; then
        echo "Zeit erfolgreich gesetzt!" >> $LOGFILE

    else
        echo "Fehler beim Setzen der Zeit!" >> $LOGFILE
        MESSAGE="Die systemzeit stimmt nicht , konnte nicht aus dem Internet gesetzt werden"
        message_zeit=5
        msg_type=1
        python "$MESSAGE_PATH" "$MESSAGE" "$msg_type" "$message_zeit" >> $LOGFILE 2>&1
        message_zeit=1  # Wieder zurücksetzen
    fi
}

#######################################################  DreamoSat Nonsolosat Pure 2 #######################################################################
Action=$1
echo "---------------------------------------------------------------------------------------------------------------------------------------------------------- Befehle " >> $LOGFILE
echo "$Action" >> $LOGFILE
echo "---------------------------------------------------------------------------------------------------------------------------------------------------------- Action ist : "$Action >> $LOGFILE
echo "$1" >> $LOGFILE
if test "$Action" = "cam_startup" ; then
    
    if test -z "${PID}" ; then
        echo "------------------------------------------------------------------------------------------------------------------------------------------------------ Befehl Pid" >> $LOGFILE
        systemzeit
        camstop
        configfiles_vorhanden
        check_binary
        binary_update
        port_auslesen
        camstart
        check_oscam_start_ok
        ende_message
    else
        echo "------------------------------------------------------------------------------------------------------------------------------------------------------ Befehl is running" >> $LOGFILE
        echo "$CAM already running, exiting..." >> $LOGFILE
    fi

elif test   "$Action" = "cam_res" ; then
    echo "---------------------------------------------------------------------------------------------------------------------------------------------------------- Befehl cam res" >> $LOGFILE
    systemzeit
    camstop
    sleep 1
    configfiles_vorhanden
    check_binary
    binary_update
    check_readerupdate
    port_auslesen
    sleep 1
    camstart
    check_oscam_start_ok
    check_oscamserverversion
    ende_message

elif test "$Action" = "cam_down" ; then
    echo "---------------------------------------------------------------------------------------------------------------------------------------------------------- Befehl cam down" >> $LOGFILE
    camstop
    sleep 1
    cam_remove_clean

elif test "$Action" = "cam_up" ; then
    echo "---------------------------------------------------------------------------------------------------------------------------------------------------------- Befehl cam up" >> $LOGFILE
    systemzeit
    cam_remove_clean
    configfiles_vorhanden
    check_binary
    binary_update
    check_readerupdate
    port_auslesen
    check_camrunning
    sleep 1
    camstart
    check_oscam_start_ok
    check_oscamserverversion
    
    ende_message
    


############################################################################# openatv ###############################################

    
echo "---------------------------------------------------------------------------------------------------------------------------------------------------------- 1 ist : "$1 >> $LOGFILE
elif test "$Action" = "start" ; then
    echo "------------------------------------------------------------------------------------------------------------------------------------------------------ Befehl Start" >> $LOGFILE
   	systemzeit
    cam_remove_clean
    configfiles_vorhanden
    check_binary
    binary_update
    check_readerupdate
    port_auslesen
    check_camrunning
    sleep 1
    echo "camstart"
    camstart

    echo "camstart ende zu check webif"
    check_oscam_start_ok
    echo "check webif ende zu oscamversion"
    check_oscamserverversion
    ende_message
    
    

elif test "$Action" = "stop" ; then
    echo "------------------------------------------------------------------------------------------------------------------------------------------------------ Befehl Stop" >> $LOGFILE

    cam_remove_clean
    camstop
    sleep 1
    
    

elif test "$Action" = "restart" ; then              # nur restart ohne reload???
    echo "------------------------------------------------------------------------------------------------------------------------------------------------------ Befehl Restart" >> $LOGFILE
    systemzeit
    camstop
    sleep 1
    cam_remove_clean
    configfiles_vorhanden
    check_binary
    binary_update
    check_readerupdate
    port_auslesen
    check_camrunning
    sleep 1
    camstart
    check_oscam_start_ok
    check_oscamserverversion
    
    ende_message
    
        

elif test "$Action" = "version" ; then
    echo "------------------------------------------------------------------------------------------------------------------------------------------------------ Befehl Version" >> $LOGFILE
    camversion_info
        

elif test "$Action" = "info" ; then
    echo "------------------------------------------------------------------------------------------------------------------------------------------------------ Befehl Info" >> $LOGFILE
    camversion_info
        

else
    echo "------------------------------------------------------------------------------------------------------------------------------------------ falscher befehl , nicht vorhanden" >> $LOGFILE
    echo "Usage: $0 start|stop|restart" >> $LOGFILE         # wenn ein falscher befehl kommt wird die ausgabe zurueck gegeben
    exit 1
    




fi
    

exit 0