var JSPath                  = "javascript.0.";             // JS- Pfad
var path                    = JSPath + 'Heizung.Heizplan';  // Pfad fuer create states
var debug = true;
var VerwendungSelectValue = true;
var Gparameterpath          = path + ".GlobaleParameter";  // Pfad in die Globalen Parameter
var StateUrlaubAnwesend     = Gparameterpath + ".Urlaub_Anwesend";    // Wenn kein Arbeitstag, dann wird der Tag wie ein Sonntag behandelt
var StateFeiertagHeute = JSPath +"Heizung.Heizplan.GlobaleParameter.Feiertag_Heute";
var StateFeiertagMorgenAdapter = "feiertage.0.morgen.boolean"; // wenn UseFeiertagskalender, dann wird dieser Pfad verwendet wenn es darum geht den nächsten Schaltpunkt zu ermitteln wenn dieser am nächsten Tag liegt

// var StateFeiertagHeute = JSPath + "Heizung.Heizplan.Feiertag_Heute";
//var StateFeiertagMorgenAdapter = "javascript.0.Heizung.Heizplan.Feiertag_Morgen"; // wenn UseFeiertagskalender, dann wird dieser Pfad verwendet wenn es darum geht den nächsten Schaltpunkt zu ermitteln wenn dieser am nächsten Tag liegt



var returnvalue1 = SelectSwichTime_V2 ("MeinRaum", "1", "CurrSollTemp");
var returnvalue2 = SelectSwichTime_V2 ("MeinRaum", "1", "CurrSlot");
var returnvalue3 = SelectSwichTime_V2 ("MeinRaum", "1", "NextSollTemp");
var returnvalue4 = SelectSwichTime_V2 ("MeinRaum", "1", "NextSlot");



//-----------------------------------------------------------------------------------------------------
// Funktion SelectSwichTime_V2  Finde Schaltzeit im schedule und geplante Solltemperatur
// Find nächst Schaltzeit
// Finde nächste Solltemperatur
//-----------------------------------------------------------------------------------------------------
// Funktion =
// NextSlot = finde nächste Schaltzeit
// CurrSlot = finde aktuellen ZeitSlot
// CurrSollTemp = finde aktuelle Solltemperatur des Slots
// NextSollTemp = finde Solltemperatur des nächsten Slots
//
function SelectSwichTime_V2 (room, RaumProfil, Funktion) {
log("Funktion ist "+ Funktion)
if ( Funktion !== "CurrSlot" && Funktion !== "NextSlot" && Funktion !== "CurrSollTemp" && Funktion !== "NextSollTemp") {
    return 0 ; // Funktion unbekannt
}

room = room.replace(/\s/g, "_");  // Alle Leerzeichen aus der Raumbezeichnung entfernen
var weekday = new Date().getDay();
var currTime = formatDate(new Date(),"SS:mm:ss");
var TemperatureScheduledTemp = 0;
var TemperatureScheduledSlot;
var NextTemperatureScheduledTemp = 0;
var NextTemperatureScheduledSlot;
var TimeBisScheduled = " ";
var TimeFrom = "00:00:00";
var y = 1;
var NextSchedulePointer = 0;

weekday = DetermineSchedule(room, weekday, RaumProfil);  // tatsächlicher weekday wird uebersteuert, wenn ein "WieVortag" vorkommt
log ("weekday ist " + weekday);

for (i = 1; i <= 6; i++) {  // es gibt 6 schedules pro Tag
    TimeBisScheduled = getState(path + "." + room + ".Profil-" + RaumProfil + "." + Wochentag(weekday) + "_" + i + "_" + "bis").val;
    if (isTimeInRange(TimeFrom, TimeBisScheduled)) {
        Source_SchedulePoint = Wochentag(weekday) + "_" + TimeBisScheduled;
        if (Funktion === "CurrSollTemp" ) {       
            TemperatureScheduledTemp =  getState(path + "." + room + ".Profil-" + RaumProfil+  "." + Wochentag(weekday) + "_" + i +"_" + "Temp").val;
            TemperatureScheduledTemp =  Calculate_SollTemp(TemperatureScheduledTemp, "SetTemp");
            if(debug) { log("Routine  SelectSwitchTime - Aktuelle Solltemperatur ist " + TemperatureScheduledTemp + " fuer Raum " +  room + " Raumprofil ist "+ RaumProfil ,"info"); } 
            return TemperatureScheduledTemp;  //exakte Schaltzeit gefunden - also raus jetzt
        } // endif currsolltemp
        if (Funktion === "CurrSlot" ) {      
            TemperatureScheduledSlot = Wochentag(weekday) + "_" + TimeBisScheduled;
            if(debug) { log("Routine  SelectSwitchTime - Aktueller Zeitslot ist " + TemperatureScheduledSlot + " fuer Raum" +  room + " Raumprofil ist "+ RaumProfil ,"info"); } 
            return TemperatureScheduledSlot; // exakte Schaltzeit gefunden - also raus jetzt
        } // endif Currslot
        if (Funktion === "NextSollTemp" || Funktion ===  "NextSlot" ) {
            NextSchedulePointer = i; // merken der slotnummer
            break;   // schleife verlassen
        }
        
    } // endif timeInRange
}  // endfor

if( NextSchedulePointer < 6 ) {                     // Wenn noch mindestens ein Slot am Selben Tag zur Verfügung steht
    NextSchedulePointer = NextSchedulePointer + 1;
}

if (TimeBisScheduled === "00:00:00") {          // Ende der Planungszeit des Tages erreicht Tag muss gewechselt werden
    if ( weekday < 6)  {                      // Nicht Samstag und Nicht Feiertag
        weekday = weekday + 1;
        NextSchedulePointer = 1;   
    }
    if  (weekday === 6) {                    // 6 = Samstag
        weekday = 0;                             // 0 = Sonntag
        NextSchedulePointer = 1;
    }
    if(weekday === 7) {                    // 7 = Feiertag
        if ( new Date().getDay() === 6) {       // 1 = Morgen ist Sonntag
            weekday = 0;                          // also auf Sonntag gehen
            NextSchedulePointer = 1;
        } else {
            weekday = new Date().getDay() + 1;
            NextSchedulePointer = 1;
        }
    }
}

if( NextSchedulePointer >= 6 ) {
    weekday = weekday + 1;                      // der letzte Slot war erreicht also Tageswechsel
    NextSchedulePointer = 1;                    // next slot ist der erste
} // endif weekday

if ( NextSchedulePointer === 1 ) {              // Es liegt ein Tageswechsel vor
    weekday = DetermineSchedule(room, weekday, RaumProfil,true);  // weekday wird uebersteuert, wenn ein "WieVortag" vorkommt 
} else {
    weekday = DetermineSchedule(room, weekday, RaumProfil,false);  // weekday wird uebersteuert, wenn ein "WieVortag" vorkommt 
}

TimeBisScheduled = getState(path + "." + room + ".Profil-" + RaumProfil + "." + Wochentag(weekday) + "_" + NextSchedulePointer + "_" + "bis").val; // die BIS-Zeit lesen

if (Funktion === "NextSollTemp" ) {
    NextTemperatureScheduledTemp =  getState(path + "." + room + ".Profil-" + RaumProfil+  "." + Wochentag(weekday) + "_" + NextSchedulePointer +"_" + "Temp").val;
    NextTemperatureScheduledTemp =  Calculate_SollTemp(NextTemperatureScheduledTemp, "SetTemp");
    if(debug) { log("Routine  SelectSwitchTime - Nächte Solltemperatur ist " + NextTemperatureScheduledTemp + " fuer Raum" +  room + " Raumprofil ist "+ RaumProfil ,"info"); } 
    return NextTemperatureScheduledTemp;  //Next Schaltzeit gefunden - also raus jetzt
} // endif next Solltemp
            
if (Funktion === "NextSlot" ) { 
    NextTemperatureScheduledSlot = Wochentag(weekday) + "_" + TimeBisScheduled;
    if(debug) { log("Routine  SelectSwitchTime - Nächster Zeitslot ist " + NextTemperatureScheduledSlot + " fuer Raum" +  room + " Raumprofil ist "+ RaumProfil ,"info"); } 
    return NextTemperatureScheduledSlot //Next Schaltzeit gefunden - also raus jetzt
} // endif next slot



return 0;  // da ist was schiefgelaufen. es haette einen schedule geben sollen



} // ende der Function   






//-----------------------------------------------------------------------------------------------------
// Funktion Calculate SollTemperatur Urechnung des Select Value Wertes in Gradzahlen
//-----------------------------------------------------------------------------------------------------
function Calculate_SollTemp(SollTemp, Calc_type) {
    var MinVal;
    var StepVal;
    var MaxVal ;

    if (VerwendungSelectValue !== true) {
        return SollTemp;
    }

    if (SollTemp === 0) {
        return SollTemp;
    }

    if (Calc_type === "SetTemp") {
        MinVal = 12;  // Liste faengt mit 12 an
        StepVal = 0.5;  // Schrittwert ist 0.5
        SollTemp = MinVal + ( SollTemp *StepVal);  // Errechnung der SollTemp
    }
    if (Calc_type === "CorrectTemp") {
        MinVal = 0;  // Liste faengt mit 0 an
        MaxVal = 5;  // Der Maxvalue ist Positiv und Negativ
        StepVal = 0.5;
        SollTemp = SollTemp * StepVal;  // Errechnung der SollTemp  fuer positive Werte
        if (SollTemp > (MaxVal - MinVal)) {
            SollTemp = (SollTemp * -1 +StepVal) + MaxVal;  // fuer Negative Werte
        }
    }

    //log("aus Calc_SollTemp Ausstieg "+ SollTemp)
    return SollTemp;
} // ende Funktion

     

//-----------------------------------------------------------------------------------------------------
// Funktion um den richtigen Planungstag zu finden bei Verwendung von WieVortag im schedule
//-----------------------------------------------------------------------------------------------------
function DetermineSchedule(room,weekday,Profil,FeiertagMorgenChck) {
if (FeiertagMorgenChck === undefined) {
    FeiertagMorgenChck = false;
}
var currentday = weekday;
var prePath = path + "." + room + ".Profil-" + Profil+".";
var StateUrlaubWieFeiertag = prePath + "ProfilParameter_UrlaubWieFeiertag";                       // Profilparameter Urlaub = Feiertag gesetzt ?
if(getState(StateUrlaubAnwesend).val && getState(StateUrlaubWieFeiertag).val ) {               // Heute ist ein Urlaubstag und soll wie ein Feiertag behandelt werden              
    weekday = 7;                                                                            // Urlaub ist wie Feiertag also den Feiertagsschedule setzen
}
if(!FeiertagMorgenChck & getState(StateFeiertagHeute).val ) {                                                     // Heute ist Feiertag          
    weekday = 7;                                                                            // Urlaub ist wie Feiertag also den Feiertagsschedule setzen
}
if (FeiertagMorgenChck & getState(StateFeiertagMorgenAdapter).val ) {                                                     // Heute ist Feiertag          
    weekday = 7;                                                                            // Urlaub ist wie Feiertag also den Feiertagsschedule setzen
}
if (weekday === 1) {                                                                         // der schedule fuer Montag hat nie einen "wie Vortag"
    return weekday; 
}  

var TempWieVortag = getState(prePath + Wochentag(weekday)+ "_" + "wieVortag").val;  // Wenn es keinen "WieVortag gib, dann kann der Tag genommen werden"
if(TempWieVortag === false) { 
    return weekday; 
}
if(weekday === 0 ) {      // Sonntag
   TempWieVortag = getState(prePath + Wochentag(0)+ "_" + "wieVortag").val;
   if (TempWieVortag===false) { 
        if(debug) {log("Routine DetermineSchedule: Zu planedner Tag  ist  = " + Wochentag(weekday) + " Tag fuer den Schedule ist  = " + Wochentag(0),"info"); }
        return(0);                  // Sonntagschedule hat keinen "WieVortag"-tick
   } else {
        weekday = 6;                // Sonntagschedule hat einen "WieVortag"-tick also ist geht es jetzt mit Samstag weiter
    }       
}
// Erstmal bei Feiertag schauen ob der Sonntag-Schedule der richtige ist
if(weekday === 7 ) {      // Feiertag
    TempWieVortag = getState(prePath + Wochentag(0)+ "_" + "wieVortag").val; // Hat der folgende Sonntag einen WieVortag Tick ?
    if (TempWieVortag===false) {    // hater er nicht 
         if(debug) { log("Routine DetermineSchedule: zu planender Tag ist  = " + Wochentag(weekday) + " Tag fuer den Schedule ist  = " + Wochentag(0),"info"); }
        return(0);                  // Sonntagschedule hat keinen "WieVortag"-tick
    } else {
        weekday = 6;                // Sonntagschedule hat einen "WieVortag"-tick also ist geht es jetzt mit Samstag weiter
    }
}
// da Feiertag und Sonntag schon klar sind koennen die Tage von Samstag bis Montag (6-1) abgearbeitet werden
for (i = weekday; i >0; i--) { 
    TempWieVortag = getState(prePath + Wochentag(i)+ "_" + "wieVortag").val;
    if (TempWieVortag===false) { 
        if(debug) { log("Routine DetermineSchedule: zu planender Tag ist  = " + Wochentag(currentday) + " Tag fuer den Schedule ist  = " + Wochentag(i),"info"); }
        return(i);                  // Sonntagschedule ist richtig
    }
}


} // ende Funktion

    


//-----------------------------------------------------------------------------------------------------
// 3 Funktionen zum Zeitrange check zur Pruefung ob die Schaltungszeiten erreicht sind
// Autor ist Beatz - uebernommen aus:
// viewtopic.php?f=21&t=1072&p=11167&hilit=isTimeInRange&sid=4dca8ea2c7f9337cdc73a1a9e4824a40#p11167
//-----------------------------------------------------------------------------------------------------
function isTimeInRange(strLower, strUpper) {
    if (strLower === null || strUpper === null) {
        return;
    }
    //
    var now = new Date();
    var lower = addTime(strLower);
    var upper = addTime(strUpper);
    var inRange = false;
    if (upper > lower) {
        // opens and closes in same day
        inRange = (now >= lower && now <= upper) ? true : false;
    } else {
        // closes in the following day
        inRange = (now >= upper && now <= lower) ? false : true;
    }
    return inRange;
}

function currentDate() {
    var d = new Date();
    return new Date(d.getFullYear(), d.getMonth(), d.getDate());
}

function addTime(strTime) {
    var time = strTime.split(':');
    var d = currentDate();
    d.setHours(time[0]);
    d.setMinutes(time[1]);
    d.setSeconds(time[2]);
    return d;
} // Ende Funktion



//-----------------------------------------------------------------------------------------------------
// Funktion Wochentag zur ermittlung des Tages
//-----------------------------------------------------------------------------------------------------
function Wochentag(tag) {
    if (tag === 0) { tag = "So"; return tag; }
    if (tag === 1) { tag = "Mo"; return tag; }
    if (tag === 2) { tag = "Di"; return tag; }
    if (tag === 3) { tag = "Mi"; return tag; }
    if (tag === 4) { tag = "Do"; return tag; }
    if (tag === 5) { tag = "Fr"; return tag; }
    if (tag === 6) { tag = "Sa"; return tag; }
    if (tag === 7) { tag = "Feiertag"; return tag; }
} // ende Funktion