// File: /workspace/github_cpp_makefile_star2_O2/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, %rbp
movq %rcx, %r12
movl %edx, %r15d
movq %rsi, %rbx
movq %rdi, %r13
leaq 0x60(%rsp), %r14
movq %r14, %rdi
callq 0x2250
movq %r14, %rdi
callq 0x2220
movq %rbx, %r10
andl $0x0, 0x4c(%rsp)
movq 0x8(%rbx), %rax
subq (%rbx), %rax
pushq $0x38
popq %rcx
cqto
idivq %rcx
leal 0x1(%r15), %esi
movslq %esi, %rcx
cmpq %rcx, %rax
movq %rbx, 0x40(%rsp)
jbe 0x2196d
leaq 0x4c(%rsp), %r14
movq %r10, %rdi
movq %r14, %rdx
callq 0x217d4
movq 0x40(%rsp), %r10
movl %r15d, %ecx
subl %eax, %ecx
cmpl $-0xa, %ecx
setae %al
cvtss2sd (%r14), %xmm1
mulsd 0x98d5(%rip), %xmm1     # 0x2b240
jmp 0x21973
movb $0x1, %al
xorpd %xmm1, %xmm1
movss (%r12), %xmm0
movss 0x10(%rsp), %xmm3
cvtss2sd %xmm3, %xmm2
ucomisd %xmm1, %xmm2
ja 0x2198e
movaps %xmm3, %xmm1
jmp 0x21992
cvtsd2ss %xmm1, %xmm1
subss 0x14(%rsp), %xmm0
testb %al, %al
jne 0x2199f
movaps %xmm3, %xmm1
xorps %xmm2, %xmm2
maxss %xmm1, %xmm2
movss %xmm2, 0x10(%rsp)
subss %xmm2, %xmm0
movss %xmm0, (%r12)
leaq 0x1c(%rsp), %r8
andl $0x0, (%r8)
movq (%r13), %rsi
movq 0x8(%r13), %rax
subq %rsi, %rax
pushq $0x18
popq %rcx
cqto
idivq %rcx
leal -0x1(%rax), %ecx
movslq %r15d, %rax
imulq $0x18, %rax, %rbx
movss 0x8(%rsi,%rbx), %xmm0
leaq 0x18(%rsp), %rax
movq %rax, (%rsp)
leaq 0x2071e(%rip), %r9      # 0x42110
movq %r13, %rdi
movq %r10, %rsi
movl %r15d, %edx
callq 0x21343
xorps %xmm4, %xmm4
movss (%r12), %xmm1
movaps %xmm1, %xmm2
subss %xmm0, %xmm2
ucomiss %xmm4, %xmm2
movss (%rbp), %xmm0
movaps %xmm2, %xmm3
addss %xmm0, %xmm3
jbe 0x21a40
ucomiss %xmm3, %xmm4
jbe 0x21a40
xorps 0x96f3(%rip), %xmm2     # 0x2b120
movss %xmm2, (%rbp)
movss (%r12), %xmm1
movaps %xmm2, %xmm0
jmp 0x21bf6
ucomiss %xmm4, %xmm3
jae 0x21bf6
movq %rbp, 0x28(%rsp)
movq %r12, 0x30(%rsp)
movq %r13, %rdi
movl %r15d, %esi
movss 0xc(%rsp), %xmm0
movss 0x8(%rsp), %xmm1
callq 0x21615
testb %al, %al
je 0x21b45
movl 0x206ec(%rip), %ebp     # 0x42164
movq (%r13), %r12
leaq 0x1c(%rsp), %r14
movss 0x8(%r12,%rbx), %xmm0
leaq 0x18(%rsp), %rax
movq %rax, (%rsp)
movq %r13, %rdi
movq 0x40(%rsp), %rsi
movl %r15d, %edx
movl %ebp, %ecx
movq %r14, %r8
leaq 0x20668(%rip), %r9      # 0x42110
callq 0x21343
ucomiss 0x9884(%rip), %xmm0     # 0x2b338
jne 0x21ab8
jnp 0x21acf
movq 0x28(%rsp), %rax
subss (%rax), %xmm0
movq 0x30(%rsp), %rax
movss (%rax), %xmm1
ucomiss %xmm0, %xmm1
jbe 0x21afe
leaq (%r12,%rbx), %rax
addq $0x8, %rax
movss (%rax), %xmm0
movslq %ebp, %rax
imulq $0x18, %rax, %rax
movss 0x8(%r12,%rax), %xmm1
mulss 0xc(%rsp), %xmm1
addss 0x8(%rsp), %xmm1
ucomiss %xmm1, %xmm0
ja 0x21cb2
movl 0x2065c(%rip), %esi     # 0x42160
movq %r13, %rdi
cmpl %ebp, %esi
jg 0x21b0d
movl %ebp, %esi
movss 0xc(%rsp), %xmm0
movss 0x8(%rsp), %xmm1
callq 0x21615
testb %al, %al
je 0x21b45
movslq 0x2063b(%rip), %rbp     # 0x42164
movq (%r13), %r12
movq 0x8(%r13), %rax
subq %r12, %rax
cqto
pushq $0x18
popq %rcx
idivq %rcx
cmpq %rbp, %rax
ja 0x21a81
movq %r13, %rdi
movl %r15d, %esi
movss 0xc(%rsp), %xmm0
movss 0x8(%rsp), %xmm1
callq 0x21615
testb %al, %al
je 0x21c22
movl 0x205f6(%rip), %ebp     # 0x42160
cmpl 0x205f4(%rip), %ebp     # 0x42164
jle 0x21c22
movq %r13, %rdi
movl %ebp, %esi
movss 0xc(%rsp), %xmm0
movss 0x8(%rsp), %xmm1
callq 0x21615
movl 0x205ce(%rip), %ebp     # 0x42160
testb %al, %al
je 0x21b9e
cmpl 0x205c8(%rip), %ebp     # 0x42164
jg 0x21b76
movl %ebp, %esi
movl 0x205bd(%rip), %r14d    # 0x42164
cmpl %esi, %r14d
jg 0x21bca
movslq %r14d, %rax
movq (%r13), %r12
imulq $0x18, %rax, %rax
movss 0x8(%r12,%rax), %xmm0
ucomiss 0x8(%r12), %xmm0
jbe 0x21d0d
movq %r13, %rdi
cmpl %r14d, %esi
jg 0x21bd5
movl %r14d, %esi
movss 0xc(%rsp), %xmm0
movss 0x8(%rsp), %xmm1
callq 0x21615
testb %al, %al
je 0x21ce8
movl 0x2056c(%rip), %esi     # 0x42160
jmp 0x21ba0
addss %xmm1, %xmm0
movss 0x10(%rsp), %xmm4
addss %xmm0, %xmm4
addss 0x14(%rsp), %xmm4
pushq $0x1
popq %rax
movss %xmm4, (%r12)
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq (%r13), %rsi
movq 0x8(%r13), %rax
subq %rsi, %rax
cqto
pushq $0x18
popq %rcx
idivq %rcx
leal -0x1(%rax), %ecx
movss 0x8(%rsi,%rbx), %xmm0
leaq 0x18(%rsp), %rax
movq %rax, (%rsp)
leaq 0x204c2(%rip), %r9      # 0x42110
leaq 0x1c(%rsp), %r8
movq %r13, %rdi
movq 0x40(%rsp), %rsi
movl %r15d, %edx
callq 0x21343
movq 0x30(%rsp), %r12
movss (%r12), %xmm1
movss 0x10(%rsp), %xmm4
addss %xmm1, %xmm4
movaps %xmm1, %xmm2
subss %xmm0, %xmm2
movq 0x28(%rsp), %rax
movss (%rax), %xmm0
addss %xmm0, %xmm2
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm2
addss 0x14(%rsp), %xmm4
jae 0x21ca9
movss %xmm4, (%r12)
movss (%rax), %xmm0
jmp 0x21f02
addss %xmm0, %xmm4
jmp 0x21c0a
movq 0x30(%rsp), %r12
movss (%r12), %xmm0
movq 0x28(%rsp), %rax
addss (%rax), %xmm0
movss 0x10(%rsp), %xmm1
addss %xmm0, %xmm1
addss 0x14(%rsp), %xmm1
xorps %xmm0, %xmm0
maxss %xmm1, %xmm0
pushq $0x1
popq %rax
movaps %xmm0, %xmm4
jmp 0x21c0d
movq (%r13), %r12
movq 0x8(%r13), %rax
subq %r12, %rax
cqto
pushq $0x18
popq %rcx
idivq %rcx
decl %eax
movl %eax, 0x20461(%rip)     # 0x42164
movq %rax, 0x38(%rsp)
movl %eax, %r14d
jmp 0x21d23
movq 0x8(%r13), %rax
subq %r12, %rax
cqto
pushq $0x18
popq %rcx
idivq %rcx
decl %eax
movq %rax, 0x38(%rsp)
movss 0x8(%r12,%rbx), %xmm0
movss %xmm0, 0x20(%rsp)
movq %r13, %rdi
movl %r15d, %esi
movl %ebp, %edx
callq 0x21493
movl %eax, 0x24(%rsp)
movq %r13, %rdi
movl %r15d, %esi
movq 0x38(%rsp), %rdx
movss 0x20(%rsp), %xmm0
callq 0x21493
movl %eax, 0x48(%rsp)
movss 0x20(%rsp), %xmm0
mulss 0xc(%rsp), %xmm0
addss 0x8(%rsp), %xmm0
leaq 0x18(%rsp), %rax
movq %rax, (%rsp)
leaq 0x20393(%rip), %rax     # 0x42110
leaq 0x1c(%rsp), %r8
movq %r13, %rdi
movq 0x40(%rsp), %rbp
movq %rbp, %rsi
movl %r15d, %edx
movl %r14d, %ecx
movq %rax, %r14
movq %rax, %r9
callq 0x21343
movss %xmm0, 0x20(%rsp)
movss 0x8(%r12,%rbx), %xmm0
mulss 0xc(%rsp), %xmm0
addss 0x8(%rsp), %xmm0
leaq 0x18(%rsp), %rax
movq %rax, (%rsp)
movq %r13, %rdi
movq %rbp, %rsi
movl %r15d, %edx
movq 0x38(%rsp), %rcx
leaq 0x1c(%rsp), %r8
movq %r14, %r9
callq 0x21343
movl 0x2032f(%rip), %ecx     # 0x42110
movss 0xc(%rsp), %xmm0
mulss 0x8(%r12,%rbx), %xmm0
addss 0x8(%rsp), %xmm0
leaq 0x18(%rsp), %rax
movq %rax, (%rsp)
movq %r13, %rdi
movq %rbp, %rsi
movl %r15d, %edx
leaq 0x1c(%rsp), %r8
movq %r14, %r9
callq 0x21343
movss 0x20(%rsp), %xmm1
ucomiss %xmm0, %xmm1
jbe 0x21e4f
movss 0x9556(%rip), %xmm2     # 0x2b37c
minss %xmm1, %xmm2
movss 0x18(%rsp), %xmm1
ucomiss %xmm1, %xmm2
movq 0x30(%rsp), %r12
movss 0x10(%rsp), %xmm4
movq 0x28(%rsp), %rax
jbe 0x21e62
addss %xmm2, %xmm0
subss %xmm1, %xmm0
jmp 0x21e62
movaps %xmm1, %xmm2
movq 0x30(%rsp), %r12
movss 0x10(%rsp), %xmm4
movq 0x28(%rsp), %rax
movss (%r12), %xmm1
ucomiss %xmm0, %xmm1
ja 0x21eeb
movl 0x48(%rsp), %ecx
cmpl 0x24(%rsp), %ecx
jne 0x21e7e
maxss %xmm2, %xmm0
movaps %xmm0, %xmm2
movss 0x94f6(%rip), %xmm0     # 0x2b37c
subss %xmm4, %xmm0
minss %xmm2, %xmm0
cvtss2sd %xmm0, %xmm2
cvtss2sd %xmm1, %xmm3
addsd 0x9372(%rip), %xmm3     # 0x2b210
ucomisd %xmm3, %xmm2
jbe 0x21eeb
movaps %xmm0, %xmm2
subss %xmm1, %xmm2
cmpl $0x0, 0x24(%rsp)
je 0x21ec3
cvtsi2ssl 0x24(%rsp), %xmm3
mulss 0x50(%rsp), %xmm3
ucomiss %xmm3, %xmm2
jbe 0x21eeb
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
pushq $0x2
jmp 0x21c0c
addss %xmm1, %xmm4
addss 0x14(%rsp), %xmm4
movss %xmm4, (%r12)
movss (%rax), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jbe 0x21f12
addss %xmm0, %xmm4
xorl %eax, %eax
jmp 0x21c0d
xorl %eax, %eax
jmp 0x21c13