// File: /workspace/github_cpp_makefile_star2_O1/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, %r12
movl %edx, %r15d
movq %rsi, %rbp
movq %rdi, %r13
leaq 0x60(%rsp), %r14
movq %r14, %rdi
callq 0x2250
movq %r14, %rdi
callq 0x2220
movl $0x0, 0x34(%rsp)
movq 0x8(%rbp), %rax
movq %rbp, 0x28(%rsp)
subq (%rbp), %rax
sarq $0x3, %rax
movabsq $0x6db6db6db6db6db7, %rcx # imm = 0x6DB6DB6DB6DB6DB7
imulq %rax, %rcx
leal 0x1(%r15), %esi
movslq %esi, %rdx
movb $0x1, %al
cmpq %rdx, %rcx
jbe 0x25475
leaq 0x34(%rsp), %rdx
movq 0x28(%rsp), %rdi
callq 0x252d4
movl %r15d, %ecx
subl %eax, %ecx
cmpl $-0xa, %ecx
setae %al
movss (%r12), %xmm0
subss 0x14(%rsp), %xmm0
movss %xmm0, (%r12)
xorps %xmm1, %xmm1
cvtss2sd 0x34(%rsp), %xmm1
mulsd 0xae78(%rip), %xmm1     # 0x30310
movss 0x10(%rsp), %xmm3
xorps %xmm2, %xmm2
cvtss2sd %xmm3, %xmm2
ucomisd %xmm1, %xmm2
ja 0x254b0
movaps %xmm3, %xmm1
jmp 0x254b4
cvtsd2ss %xmm1, %xmm1
testb %al, %al
jne 0x254bb
movaps %xmm3, %xmm1
xorps %xmm2, %xmm2
maxss %xmm1, %xmm2
movss %xmm2, 0x10(%rsp)
subss %xmm2, %xmm0
movss %xmm0, (%r12)
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 0x1fbdd(%rip), %r9      # 0x450f0
movq %r13, %rdi
movq 0x28(%rsp), %rsi
movl %r15d, %edx
callq 0x24dc2
xorps %xmm2, %xmm2
movss (%r12), %xmm1
subss %xmm0, %xmm1
ucomiss %xmm2, %xmm1
jbe 0x25552
movss (%rbx), %xmm0
addss %xmm1, %xmm0
ucomiss %xmm0, %xmm2
jbe 0x25552
xorps 0xaca7(%rip), %xmm1     # 0x301f0
movss %xmm1, (%rbx)
jmp 0x25896
addss (%rbx), %xmm1
ucomiss %xmm2, %xmm1
jae 0x25896
movq %rbx, 0x20(%rsp)
movq %r12, 0x38(%rsp)
movq %r13, %rdi
movl %r15d, %esi
movss 0xc(%rsp), %xmm0
movss 0x8(%rsp), %xmm1
callq 0x250c4
testb %al, %al
je 0x2565f
movabsq $-0x5555555555555555, %rbx # imm = 0xAAAAAAAAAAAAAAAB
movl 0x1fbac(%rip), %ebp     # 0x45144
movq (%r13), %r12
movss 0x8(%r12,%r14,8), %xmm0
leaq 0x18(%rsp), %rax
movq %rax, (%rsp)
movq %r13, %rdi
movq 0x28(%rsp), %rsi
movl %r15d, %edx
movl %ebp, %ecx
leaq 0x1c(%rsp), %r8
leaq 0x1fb2b(%rip), %r9      # 0x450f0
callq 0x24dc2
ucomiss 0xae37(%rip), %xmm0     # 0x30408
jne 0x255d5
jnp 0x255ec
movq 0x20(%rsp), %rax
subss (%rax), %xmm0
movq 0x38(%rsp), %rax
movss (%rax), %xmm1
ucomiss %xmm0, %xmm1
jbe 0x2561b
movslq %ebp, %rax
leaq (%r12,%r14,8), %rcx
addq $0x8, %rcx
movss (%rcx), %xmm0
leaq (%rax,%rax,2), %rax
movss 0x8(%r12,%rax,8), %xmm1
mulss 0xc(%rsp), %xmm1
addss 0x8(%rsp), %xmm1
ucomiss %xmm1, %xmm0
ja 0x2595c
movl 0x1fb1f(%rip), %esi     # 0x45140
movq %r13, %rdi
cmpl %ebp, %esi
jg 0x2562a
movl %ebp, %esi
movss 0xc(%rsp), %xmm0
movss 0x8(%rsp), %xmm1
callq 0x250c4
testb %al, %al
je 0x2565f
movq 0x8(%r13), %rax
subq (%r13), %rax
movslq 0x1faf6(%rip), %rcx     # 0x45144
sarq $0x3, %rax
imulq %rbx, %rax
cmpq %rcx, %rax
ja 0x25592
movq %r13, %rdi
movl %r15d, %esi
movss 0xc(%rsp), %xmm0
movss 0x8(%rsp), %xmm1
callq 0x250c4
testb %al, %al
je 0x258ca
movl 0x1fabc(%rip), %eax     # 0x45140
cmpl 0x1faba(%rip), %eax     # 0x45144
jle 0x258ca
movl 0x1faaa(%rip), %esi     # 0x45140
movq %r13, %rdi
movss 0xc(%rsp), %xmm0
movss 0x8(%rsp), %xmm1
callq 0x250c4
testb %al, %al
je 0x256bc
movl 0x1fa8c(%rip), %eax     # 0x45140
cmpl 0x1fa8a(%rip), %eax     # 0x45144
jg 0x25690
movl 0x1fa7d(%rip), %r12d    # 0x45140
movslq 0x1fa7a(%rip), %rsi     # 0x45144
movl 0x1fa70(%rip), %eax     # 0x45140
cmpl %eax, %esi
jg 0x256e8
movq (%r13), %rcx
leaq (%rsi,%rsi,2), %rdx
movss 0x8(%rcx,%rdx,8), %xmm0
ucomiss 0x8(%rcx), %xmm0
jbe 0x25722
movq %r13, %rdi
cmpl %esi, %eax
jle 0x256f3
movl %eax, %esi
jmp 0x256f3
movss 0xc(%rsp), %xmm0
movss 0x8(%rsp), %xmm1
callq 0x250c4
testb %al, %al
jne 0x256c3
movq 0x8(%r13), %rax
subq (%r13), %rax
shrq $0x3, %rax
imull $0xaaaaaaab, %eax, %eax # imm = 0xAAAAAAAB
decl %eax
movl %eax, 0x1fa22(%rip)     # 0x45144
movq (%r13), %rcx
movq 0x8(%r13), %rax
subq %rcx, %rax
shrq $0x3, %rax
imull $0xaaaaaaab, %eax, %eax # imm = 0xAAAAAAAB
leal -0x1(%rax), %r8d
leaq (%rcx,%r14,8), %rdi
addq $0x8, %rdi
movss (%rdi), %xmm0
xorl %ebx, %ebx
movl $0x0, %ebp
subl %r15d, %r12d
jl 0x2576f
incl %r12d
xorl %ebp, %ebp
movq %rdi, %rdx
xorl %esi, %esi
ucomiss (%rdx), %xmm0
seta %sil
addl %esi, %ebp
addq $0x18, %rdx
decl %r12d
jne 0x2575b
movq %rdi, 0x48(%rsp)
movl %r8d, 0x44(%rsp)
cmpl %r15d, %r8d
jl 0x2579d
subl %r15d, %eax
leaq (%rcx,%r14,8), %rcx
addq $0x8, %rcx
xorl %ebx, %ebx
xorl %edx, %edx
ucomiss (%rcx), %xmm0
seta %dl
addl %edx, %ebx
addq $0x18, %rcx
decl %eax
jne 0x2578b
movl 0x1f9a1(%rip), %ecx     # 0x45144
mulss 0xc(%rsp), %xmm0
addss 0x8(%rsp), %xmm0
leaq 0x18(%rsp), %r14
movq %r14, (%rsp)
leaq 0x1f931(%rip), %r9      # 0x450f0
leaq 0x1c(%rsp), %r8
movq %r13, %rdi
movq 0x28(%rsp), %r12
movq %r12, %rsi
movl %r15d, %edx
callq 0x24dc2
movss %xmm0, 0x40(%rsp)
movq 0x48(%rsp), %r14
movss (%r14), %xmm0
mulss 0xc(%rsp), %xmm0
addss 0x8(%rsp), %xmm0
leaq 0x18(%rsp), %rax
movq %rax, (%rsp)
movq %r13, %rdi
movq %r12, %rsi
movl %r15d, %edx
movl 0x44(%rsp), %ecx
leaq 0x1c(%rsp), %r8
leaq 0x1f8db(%rip), %r9      # 0x450f0
callq 0x24dc2
movl 0x1f8d0(%rip), %ecx     # 0x450f0
movss 0xc(%rsp), %xmm0
mulss (%r14), %xmm0
addss 0x8(%rsp), %xmm0
leaq 0x18(%rsp), %rax
movq %rax, (%rsp)
movq %r13, %rdi
movq %r12, %rsi
movl %r15d, %edx
leaq 0x1c(%rsp), %r8
leaq 0x1f8a1(%rip), %r9      # 0x450f0
callq 0x24dc2
movss 0x40(%rsp), %xmm1
ucomiss %xmm0, %xmm1
movq 0x38(%rsp), %r12
jbe 0x25994
movss 0xabdc(%rip), %xmm2     # 0x3044c
minss %xmm1, %xmm2
movss 0x18(%rsp), %xmm1
ucomiss %xmm1, %xmm2
movss 0x10(%rsp), %xmm4
jbe 0x2599d
addss %xmm2, %xmm0
subss %xmm1, %xmm0
jmp 0x2599d
movss (%r12), %xmm0
addss (%rbx), %xmm0
movss 0x10(%rsp), %xmm4
addss %xmm0, %xmm4
addss 0x14(%rsp), %xmm4
movl $0x1, %eax
movss %xmm4, (%r12)
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 0x1f7f8(%rip), %r9      # 0x450f0
leaq 0x1c(%rsp), %r8
movq %r13, %rdi
movq 0x28(%rsp), %rsi
movl %r15d, %edx
callq 0x24dc2
movq 0x38(%rsp), %r12
movss (%r12), %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 0x25953
movss %xmm4, (%r12)
movss (%rax), %xmm0
jmp 0x25a4b
addss %xmm0, %xmm4
jmp 0x258b0
movq 0x38(%rsp), %r12
movss (%r12), %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 0x258b5
movaps %xmm1, %xmm2
movss 0x10(%rsp), %xmm4
movss (%r12), %xmm1
ucomiss %xmm0, %xmm1
ja 0x25a2f
cmpl %ebp, %ebx
jne 0x259b7
maxss %xmm2, %xmm0
movaps %xmm0, %xmm2
movss 0xaa8d(%rip), %xmm0     # 0x3044c
subss %xmm4, %xmm0
minss %xmm2, %xmm0
xorps %xmm2, %xmm2
cvtss2sd %xmm0, %xmm2
cvtss2sd %xmm1, %xmm3
addsd 0xa906(%rip), %xmm3     # 0x302e0
ucomisd %xmm3, %xmm2
jbe 0x25a2f
testl %ebp, %ebp
je 0x259fd
movaps %xmm0, %xmm2
xorps %xmm3, %xmm3
cvtsi2ss %ebp, %xmm3
subss %xmm1, %xmm2
mulss 0x50(%rsp), %xmm3
ucomiss %xmm3, %xmm2
jbe 0x25a2f
movaps %xmm0, %xmm2
subss %xmm1, %xmm2
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 0x258b5
addss %xmm1, %xmm4
addss 0x14(%rsp), %xmm4
movss %xmm4, (%r12)
movq 0x20(%rsp), %rax
movss (%rax), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jbe 0x25a5b
addss %xmm0, %xmm4
xorl %eax, %eax
jmp 0x258b5
xorl %eax, %eax
jmp 0x258bb