// File: /workspace/github_cpp_makefile_star2_O3/Eba-M[P]E3DC-Control/awattar.cpp
// Function: SimuWATTar(std::vector<watt_s, std::allocator<watt_s>>&, std::vector<wetter_s, std::allocator<wetter_s>>&, int, float&, float&, float, float, float, float, float)
int SimuWATTar(std::vector<watt_s> &w, std::vector<wetter_s> &wetter, int h, float &fSoC,float &anforderung,float Diff,float aufschlag, float reserve, float notstromreserve,float ladeleistung) // fConsumption Verbrauch in % SoC Differenz Laden/Endladen

// Returncode 0 = keine Aktion, 1 Batterieentladen stoppen 2 Batterie mit Netzstrom laden
{
    // Ermitteln Stundenanzahl
    // Analyseergebnisse in die Datei schreiben
    static float lowpp;
    time_t  rawtime;
    time(&rawtime);
    struct tm * ptm;
    ptm = gmtime (&rawtime);
    
    int x1,x2,x3,x4;
    int Minuten = rawtime%(24*3600)/60;
    float fConsumption;
    float maxsoc;
    //    return 2;  // Zu testzwecken  dann 9 Minuten Netzladebetrieb
    /*
     if (Minuten%60<1)
     return 1;  else // Zu testzwecken erst eine Minute Entladen erlauben
     {
     if (Minuten%60<6)
     return 2;  // Zu testzwecken  dann 9 Minuten Netzladebetrieb
     }
     */
    
    {
        float offset;
        float SollSoc = 0;
        float ZielSoC = 95;
        float Verbrauch = 0;
// Verbrauch bis solarenÜberschuss??
        int ret = 0;
        if (wetter.size() > h+1)
            ret = suchenSolar(wetter,h+1, Verbrauch) - h -1;

        // Überprüfen ob entladen werden kann
        fSoC = fSoC - notstromreserve;
    // Wenn der verfügbare Speicher > dem Verbrauch bis Überschuss ist
        if (Verbrauch*0.8<reserve&&ret<10&&ret>=0)
            reserve = Verbrauch*0.8;
//        if (ret == 0) reserve = 0;
        if (reserve < 0) reserve = 0;
        fSoC = fSoC - reserve;
        float minsoc = 0;
        fConsumption = fHighprice(w,wetter,h,w.size()-1,w[h].pp,minsoc,maxpos,maxsoc);
//        if (maxpos < w.size()-1)
//            fConsumption = fHighprice(w,wetter,h,maxpos,w[h].pp,fSoC+reserve,maxpos,maxsoc);
// wieviel Einträge sind höher mit dem SoC in Consumption abgleichen
        float faval = fSoC - fConsumption;
/*        if (fConsumption<minsoc&&minsoc>0&&faval>-0.01)
        {
//            if (fConsumption > ZielSoC-reserve) fConsumption = ZielSoC-reserve;
            faval = fSoC -minsoc;
        }
*/        if (faval>0&&faval+anforderung<0)
            anforderung = faval*-1;
        else
            faval = faval + anforderung;
//        if (faval >=-0.01||maxsoc+fSoC-minsoc>=100)
        if (faval >=0) // x1 Anzahl der Einträge mit höheren Preisen
        {
                fSoC = fSoC + anforderung + reserve + notstromreserve;
                return 1;
        } 

/*        else
        {
                fSoC = fSoC + faval;
                anforderung = anforderung + faval;
        }
*/
        // suche über den gesamten Bereich
        if  (SucheDiff(w,h, aufschlag,Diff)) // es wird gandenlos bis zum nächsten low entladen
        do
        {
            fConsumption = fHighprice(w,wetter,h,l1,w[h].pp,minsoc,maxpos,maxsoc);  // nächster Nachladepunkt überprüfen
//            if (float(fSoC-fConsumption+reserve) > 0) // x1 Anzahl der Einträge mit höheren Preisen
            if (fConsumption==0||fConsumption-anforderung<fSoC) // x1 Anzahl der Einträge mit höheren Preisen
//                if ((w[h].pp>w[l1].pp*aufschlag+Diff)&&fConsumption<fSoC)
                if ((w[h].pp>(w[l1].pp)*aufschlag+Diff))
                    // Es könnte nachgeladen werden
                {
                    fSoC = fSoC + anforderung + reserve + notstromreserve;
                    if (fSoC < 0)
                        fSoC = 0;
                    return 1;
                }
            if (h1>l1)
            {if (not (SucheDiff(w,h1, aufschlag,Diff))) break;} // suche low nach einem high
            else
            {if (not (SucheDiff(w,l1, aufschlag,Diff))) break;} // suche low nach einem high
        }
        while (l1 < w.size());
        
        if (SucheDiff(w,h, aufschlag,Diff))
        {
            if (h1>l1)       // erst kommt ein low dann ein high, überprüfen ob zum low geladen werden soll
            {
                int lw = l1;
                do
                    if (not (SucheDiff(w,h1, aufschlag,Diff))) break; // suche low nach einem high
                while (h1 > l1);
                // suche das nächste low
                // suchen nach dem low before next high das low muss niedriger als das akutelle sein
                int hi = h1;
                while ((l1 > h1)||(w[0].pp<w[l1].pp)) {
                    if (h1>l1)
                    {if (not (SucheDiff(w,h1, aufschlag,Diff))) {
                        l1 = w.size()-1;
                        break;}} // suche low nach einem high
                    else
                    {if (not (SucheDiff(w,l1, aufschlag,Diff))) {
                        l1 = w.size()-1;
                        break;}} // suche low nach einem high
                }
                // Überprüfen ob Geladen werden kann
                x3 = w.size()-1;
                x1 = Lowprice(w,h, hi, w[h].pp);   // bis zum high suchen
                x2 = Lowprice(w,h, w.size()-1, w[h].pp);   // bis zum high suchen
                
                SollSoc = fHighprice(w,wetter,h,l1,(w[h].pp)*aufschlag+Diff,minsoc,maxpos,maxsoc);  // Preisspitzen, es muss mindestens eine vorliegen
                float SollSoc2 = 0;
                SollSoc2 = fHighprice(w,wetter,h,x3,(w[h].pp)*aufschlag+Diff,minsoc,maxpos,maxsoc);
                SollSoc2 = fHighprice(w,wetter,h,maxpos,(w[h].pp)*aufschlag+Diff,minsoc,maxpos,maxsoc);
                if (SollSoc>SollSoc2)
                {
                    if (SollSoc > ZielSoC) SollSoc = ZielSoC;
                    if (SollSoc>maxsoc)
                    {
                        SollSoc2 = SollSoc2 + SollSoc - maxsoc;
//                        SollSoc2 = minsoc + SollSoc2;
                    }
                }
                if (SollSoc2 < fSoC)
                {
                    fSoC = fSoC + reserve + notstromreserve;
                    if (anforderung>0)
                        fSoC = fSoC + anforderung;

                    return 0;
                }
                // Nachladen aus dem Netz erforderlich, wenn für die Abdeckung der Preisspitzen
                // Stunden mit hohen Börsenpreisen, Nachladen wenn SoC zu niedrig
                if (x2 == x1) // keine weiteren Lows
                    //                    SollSoc = SollSoc2 +fSoC;
                    if (SollSoc2>SollSoc)
                        SollSoc = SollSoc2;
                if (SollSoc > ZielSoC-reserve) SollSoc = ZielSoC-reserve;
                if ((SollSoc>fSoC+0.5)&&        // Damit es kein Überschwingen gibt, wird 1% weniger als das Soll geladen
                    ((x1==0)||((SollSoc-fSoC)>x1*ladeleistung)))      // Stunden mit hohen Börsenpreisen, Nachladen wenn SoC zu niedrig
                {
                    
                    if ((SollSoc-fSoC)>ladeleistung)
                        fSoC = fSoC + ladeleistung;
                    else
                        fSoC = SollSoc;
                    //                    if (fSoC > SollSoc-0.5)
                    //                        (fSoC = SollSoc-0.5);
                    fSoC = fSoC + reserve + notstromreserve;
                    return 2;
                }
                else
                    //                if ((SollSoc)>fSoC-1)
                {
                    fSoC = fSoC + reserve + notstromreserve;
                    if (anforderung>0)
                        fSoC = fSoC + anforderung;
                    return 0;
                } // Nicht entladen da die Preisdifferenz zur Spitze noch zu groß
            }
        }
        //        if (taglaenge > Wintertag) // tagsüber noch hochpreise es werden mind. die 2h nach sonnaufgang geprüft
        {
            fConsumption = fHighprice(w,wetter,h,w.size()-1,w[h].pp,minsoc,maxpos,maxsoc);  // folgender Preis höher, dann anteilig berücksichtigen
            
            
//            if (float(fSoC-fConsumption+reserve) > 0) // x1 Anzahl der Einträge mit höheren Preisen
            if (float(fSoC-fConsumption+anforderung) >=0) // x1 Anzahl der Einträge mit höheren Preisen
            {
                fSoC = fSoC + reserve + notstromreserve + anforderung;
                return 1;
            }
        }
        fSoC = fSoC + reserve + notstromreserve;
        if (anforderung>0)
            fSoC = fSoC + anforderung;
        
        return 0;  // kein Ergebniss gefunden
        
        
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movaps %xmm4, 0x50(%rsp)
movss %xmm3, 0x14(%rsp)
movss %xmm2, 0x10(%rsp)
movss %xmm1, 0xc(%rsp)
movss %xmm0, 0x8(%rsp)
movq %r8, %rbx
movq %rcx, %rbp
movl %edx, %r15d
movq %rsi, %r12
movq %rdi, %r13
leaq 0x60(%rsp), %r14
movq %r14, %rdi
callq 0x2250
movq %r14, %rdi
callq 0x2220
movl $0x0, 0x44(%rsp)
movq 0x8(%r12), %rax
subq (%r12), %rax
sarq $0x3, %rax
movabsq $0x6db6db6db6db6db7, %rcx # imm = 0x6DB6DB6DB6DB6DB7
imulq %rax, %rcx
leal 0x1(%r15), %esi
movslq %esi, %rax
cmpq %rax, %rcx
jbe 0x25396
leaq 0x44(%rsp), %r14
movq %r12, %rdi
movq %r14, %rdx
callq 0x251ea
movl %r15d, %ecx
subl %eax, %ecx
cmpl $-0xa, %ecx
setae %al
xorps %xmm1, %xmm1
cvtss2sd (%r14), %xmm1
mulsd 0xaf7c(%rip), %xmm1     # 0x30310
jmp 0x2539c
movb $0x1, %al
xorpd %xmm1, %xmm1
movss (%rbp), %xmm0
movss 0x10(%rsp), %xmm3
xorps %xmm2, %xmm2
cvtss2sd %xmm3, %xmm2
ucomisd %xmm1, %xmm2
ja 0x253b9
movaps %xmm3, %xmm1
jmp 0x253bd
cvtsd2ss %xmm1, %xmm1
subss 0x14(%rsp), %xmm0
testb %al, %al
jne 0x253ca
movaps %xmm3, %xmm1
xorps %xmm2, %xmm2
maxss %xmm1, %xmm2
movss %xmm2, 0x10(%rsp)
subss %xmm2, %xmm0
movss %xmm0, (%rbp)
leaq 0x1c(%rsp), %r8
movl $0x0, (%r8)
movq (%r13), %rax
movq 0x8(%r13), %rcx
subq %rax, %rcx
shrq $0x3, %rcx
imull $0xaaaaaaab, %ecx, %ecx # imm = 0xAAAAAAAB
decl %ecx
movslq %r15d, %rdx
leaq (%rdx,%rdx,2), %r14
movss 0x8(%rax,%r14,8), %xmm0
leaq 0x18(%rsp), %rax
movq %rax, (%rsp)
leaq 0x1fccf(%rip), %r9      # 0x450f0
movq %r13, %rdi
movq %r12, %rsi
movl %r15d, %edx
callq 0x24cec
xorps %xmm4, %xmm4
movss (%rbp), %xmm1
movaps %xmm1, %xmm2
subss %xmm0, %xmm2
ucomiss %xmm4, %xmm2
movss (%rbx), %xmm0
movaps %xmm2, %xmm3
addss %xmm0, %xmm3
jbe 0x2546b
ucomiss %xmm3, %xmm4
jbe 0x2546b
xorps 0xad96(%rip), %xmm2     # 0x301f0
movss %xmm2, (%rbx)
movss (%rbp), %xmm1
movaps %xmm2, %xmm0
jmp 0x25626
ucomiss %xmm4, %xmm3
jae 0x25626
movq %r12, 0x30(%rsp)
movq %rbx, 0x20(%rsp)
movq %rbp, 0x28(%rsp)
movq %r13, %rdi
movl %r15d, %esi
movss 0xc(%rsp), %xmm0
movss 0x8(%rsp), %xmm1
callq 0x24fd9
testb %al, %al
je 0x2557c
movl 0x1fc9c(%rip), %ebp     # 0x45144
movq (%r13), %r12
movabsq $-0x5555555555555555, %rbx # imm = 0xAAAAAAAAAAAAAAAB
movss 0x8(%r12,%r14,8), %xmm0
leaq 0x18(%rsp), %rax
movq %rax, (%rsp)
movq %r13, %rdi
movq 0x30(%rsp), %rsi
movl %r15d, %edx
movl %ebp, %ecx
leaq 0x1c(%rsp), %r8
leaq 0x1fc11(%rip), %r9      # 0x450f0
callq 0x24cec
ucomiss 0xaf1d(%rip), %xmm0     # 0x30408
jne 0x254ef
jnp 0x25506
movq 0x20(%rsp), %rax
subss (%rax), %xmm0
movq 0x28(%rsp), %rax
movss (%rax), %xmm1
ucomiss %xmm0, %xmm1
jbe 0x25535
leaq (%r12,%r14,8), %rax
addq $0x8, %rax
movss (%rax), %xmm0
movslq %ebp, %rax
leaq (%rax,%rax,2), %rax
movss 0x8(%r12,%rax,8), %xmm1
mulss 0xc(%rsp), %xmm1
addss 0x8(%rsp), %xmm1
ucomiss %xmm1, %xmm0
ja 0x256e3
movl 0x1fc05(%rip), %esi     # 0x45140
movq %r13, %rdi
cmpl %ebp, %esi
jg 0x25544
movl %ebp, %esi
movss 0xc(%rsp), %xmm0
movss 0x8(%rsp), %xmm1
callq 0x24fd9
testb %al, %al
je 0x2557c
movslq 0x1fbe4(%rip), %rbp     # 0x45144
movq (%r13), %r12
movq 0x8(%r13), %rax
subq %r12, %rax
sarq $0x3, %rax
imulq %rbx, %rax
cmpq %rbp, %rax
ja 0x254b6
movq %r13, %rdi
movl %r15d, %esi
movss 0xc(%rsp), %xmm0
movss 0x8(%rsp), %xmm1
callq 0x24fd9
testb %al, %al
je 0x25653
movl 0x1fb9f(%rip), %ebp     # 0x45140
cmpl 0x1fb9d(%rip), %ebp     # 0x45144
jle 0x25653
movq %r13, %rdi
movl %ebp, %esi
movss 0xc(%rsp), %xmm0
movss 0x8(%rsp), %xmm1
callq 0x24fd9
movl 0x1fb77(%rip), %ebp     # 0x45140
testb %al, %al
je 0x255d5
cmpl 0x1fb71(%rip), %ebp     # 0x45144
jg 0x255ad
movl %ebp, %esi
movl 0x1fb67(%rip), %ecx     # 0x45144
cmpl %esi, %ecx
jg 0x255fc
movslq %ecx, %rdx
movq (%r13), %rax
leaq (%rdx,%rdx,2), %rdx
movss 0x8(%rax,%rdx,8), %xmm0
ucomiss 0x8(%rax), %xmm0
jbe 0x2573f
movq %r13, %rdi
cmpl %ecx, %esi
jg 0x25605
movl %ecx, %esi
movss 0xc(%rsp), %xmm0
movss 0x8(%rsp), %xmm1
callq 0x24fd9
testb %al, %al
je 0x2571a
movl 0x1fb1c(%rip), %esi     # 0x45140
jmp 0x255d7
addss %xmm1, %xmm0
movss 0x10(%rsp), %xmm4
addss %xmm0, %xmm4
addss 0x14(%rsp), %xmm4
movl $0x1, %eax
movss %xmm4, (%rbp)
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq (%r13), %rax
movq 0x8(%r13), %rcx
subq %rax, %rcx
shrq $0x3, %rcx
imull $0xaaaaaaab, %ecx, %ecx # imm = 0xAAAAAAAB
decl %ecx
movss 0x8(%rax,%r14,8), %xmm0
leaq 0x18(%rsp), %rax
movq %rax, (%rsp)
leaq 0x1fa6f(%rip), %r9      # 0x450f0
leaq 0x1c(%rsp), %r8
movq %r13, %rdi
movq 0x30(%rsp), %rsi
movl %r15d, %edx
callq 0x24cec
movq 0x28(%rsp), %rbp
movss (%rbp), %xmm1
movss 0x10(%rsp), %xmm4
addss %xmm1, %xmm4
movaps %xmm1, %xmm2
subss %xmm0, %xmm2
movq 0x20(%rsp), %rax
movss (%rax), %xmm0
addss %xmm0, %xmm2
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm2
addss 0x14(%rsp), %xmm4
jae 0x256da
movss %xmm4, (%rbp)
movss (%rax), %xmm0
jmp 0x25951
addss %xmm0, %xmm4
jmp 0x2563a
movq 0x28(%rsp), %rbp
movss (%rbp), %xmm0
movq 0x20(%rsp), %rax
addss (%rax), %xmm0
movss 0x10(%rsp), %xmm1
addss %xmm0, %xmm1
addss 0x14(%rsp), %xmm1
xorps %xmm0, %xmm0
maxss %xmm1, %xmm0
movl $0x1, %eax
movaps %xmm0, %xmm4
jmp 0x2563f
movq (%r13), %rax
movq 0x8(%r13), %rcx
subq %rax, %rcx
shrq $0x3, %rcx
imull $0xaaaaaaab, %ecx, %edx # imm = 0xAAAAAAAB
leal -0x1(%rdx), %r8d
movl %r8d, 0x1fa0a(%rip)     # 0x45144
movl %r8d, %ecx
jmp 0x25754
movq 0x8(%r13), %rdx
subq %rax, %rdx
shrq $0x3, %rdx
imull $0xaaaaaaab, %edx, %edx # imm = 0xAAAAAAAB
leal -0x1(%rdx), %r8d
leaq (%rax,%r14,8), %r9
addq $0x8, %r9
movss (%r9), %xmm0
xorl %r12d, %r12d
movl $0x0, %ebx
subl %r15d, %ebp
jl 0x25788
incl %ebp
xorl %ebx, %ebx
movq %r9, %rsi
xorl %edi, %edi
ucomiss (%rsi), %xmm0
seta %dil
addl %edi, %ebx
addq $0x18, %rsi
decl %ebp
jne 0x25775
movq %r9, 0x48(%rsp)
movl %r8d, 0x40(%rsp)
cmpl %r15d, %r8d
jl 0x257b9
subl %r15d, %edx
leaq (%rax,%r14,8), %rax
addq $0x8, %rax
xorl %r12d, %r12d
xorl %esi, %esi
ucomiss (%rax), %xmm0
seta %sil
addl %esi, %r12d
addq $0x18, %rax
decl %edx
jne 0x257a5
mulss 0xc(%rsp), %xmm0
addss 0x8(%rsp), %xmm0
leaq 0x18(%rsp), %rbp
movq %rbp, (%rsp)
leaq 0x1f91b(%rip), %r9      # 0x450f0
leaq 0x1c(%rsp), %r8
movq %r13, %rdi
movq 0x30(%rsp), %r14
movq %r14, %rsi
movl %r15d, %edx
callq 0x24cec
movss %xmm0, 0x3c(%rsp)
movq 0x48(%rsp), %rbp
movss (%rbp), %xmm0
mulss 0xc(%rsp), %xmm0
addss 0x8(%rsp), %xmm0
leaq 0x18(%rsp), %rax
movq %rax, (%rsp)
movq %r13, %rdi
movq %r14, %rsi
movl %r15d, %edx
movl 0x40(%rsp), %ecx
leaq 0x1c(%rsp), %r8
leaq 0x1f8c5(%rip), %r9      # 0x450f0
callq 0x24cec
movl 0x1f8ba(%rip), %ecx     # 0x450f0
movss 0xc(%rsp), %xmm0
mulss (%rbp), %xmm0
addss 0x8(%rsp), %xmm0
leaq 0x18(%rsp), %rax
movq %rax, (%rsp)
movq %r13, %rdi
movq %r14, %rsi
movl %r15d, %edx
leaq 0x1c(%rsp), %r8
leaq 0x1f88b(%rip), %r9      # 0x450f0
callq 0x24cec
movss 0x3c(%rsp), %xmm1
ucomiss %xmm0, %xmm1
jbe 0x258a1
movss 0xabcf(%rip), %xmm2     # 0x3044c
minss %xmm1, %xmm2
movss 0x18(%rsp), %xmm1
ucomiss %xmm1, %xmm2
movq 0x28(%rsp), %rbp
movss 0x10(%rsp), %xmm4
jbe 0x258af
addss %xmm2, %xmm0
subss %xmm1, %xmm0
jmp 0x258af
movaps %xmm1, %xmm2
movq 0x28(%rsp), %rbp
movss 0x10(%rsp), %xmm4
movss (%rbp), %xmm1
ucomiss %xmm0, %xmm1
ja 0x25936
cmpl %ebx, %r12d
jne 0x258c5
maxss %xmm2, %xmm0
movaps %xmm0, %xmm2
movss 0xab7f(%rip), %xmm0     # 0x3044c
subss %xmm4, %xmm0
minss %xmm2, %xmm0
xorps %xmm2, %xmm2
cvtss2sd %xmm0, %xmm2
cvtss2sd %xmm1, %xmm3
addsd 0xa9f8(%rip), %xmm3     # 0x302e0
ucomisd %xmm3, %xmm2
jbe 0x25936
movaps %xmm0, %xmm2
subss %xmm1, %xmm2
testl %ebx, %ebx
je 0x2590b
xorps %xmm3, %xmm3
cvtsi2ss %ebx, %xmm3
mulss 0x50(%rsp), %xmm3
ucomiss %xmm3, %xmm2
jbe 0x25936
movaps 0x50(%rsp), %xmm3
addss %xmm3, %xmm1
cmpltss %xmm2, %xmm3
andps %xmm3, %xmm1
andnps %xmm0, %xmm3
orps %xmm1, %xmm3
addss %xmm3, %xmm4
addss 0x14(%rsp), %xmm4
movl $0x2, %eax
jmp 0x2563f
addss %xmm1, %xmm4
addss 0x14(%rsp), %xmm4
movss %xmm4, (%rbp)
movq 0x20(%rsp), %rax
movss (%rax), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jbe 0x25961
addss %xmm0, %xmm4
xorl %eax, %eax
jmp 0x2563f
xorl %eax, %eax
jmp 0x25644