<?php

declare(strict_types=1);

namespace Belevo\EnelixEMS\Tests;

use Belevo\EnelixEMS\BatterieRegler;
use InvalidArgumentException;
use PHPUnit\Framework\TestCase;

final class BatterieReglerTest extends TestCase
{
    public function testLeistungsbereichBleibtInnerhalbDynamischerGrenzen(): void
    {
        self::assertSame(
            [['Von_W' => -999, 'Bis_W' => 1000]],
            BatterieRegler::leistungsangebot(
                true, true, false, 50.0, 20.0, 10.0, false,
                0.0, 0.0, 1000.9, 999.9
            )
        );
    }

    public function testHystereseSchaltetAnDenBisherigenGrenzen(): void
    {
        self::assertTrue(BatterieRegler::hystereseAktiv(20.0, 20.0, 2.0, false));
        self::assertTrue(BatterieRegler::hystereseAktiv(21.0, 20.0, 2.0, true));
        self::assertFalse(BatterieRegler::hystereseAktiv(22.1, 20.0, 2.0, true));
    }

    public function testPvAngebotVerwendetStufenloseBereicheMitBisherigerSocLogik(): void
    {
        self::assertSame(
            [['Von_W' => -1000, 'Bis_W' => 1000]],
            BatterieRegler::leistungsangebot(
                true, true, false, 50.0, 20.0, 10.0, false,
                0.0, 0.0, 1000.0, 1000.0
            )
        );
        self::assertSame(
            [1000],
            BatterieRegler::leistungsangebot(
                true, true, false, 19.0, 20.0, 10.0, true,
                0.0, 0.0, 1000.0, 1000.0
            )
        );
        self::assertSame(
            [['Von_W' => -1000, 'Bis_W' => 0]],
            BatterieRegler::leistungsangebot(
                true, true, false, 100.0, 20.0, 10.0, false,
                0.0, 0.0, 1000.0, 1000.0
            )
        );
    }

    public function testPeakAngebotBeruecksichtigtNetzUndAktuelleBatterieleistung(): void
    {
        self::assertSame(
            [-500],
            BatterieRegler::leistungsangebot(
                true, true, true, 50.0, 20.0, 10.0, false,
                700.0, 200.0, 1000.0, 1000.0
            )
        );
    }

    public function testPeakEinschraenkungenWerdenAlsBereicheGemeldet(): void
    {
        self::assertSame(
            [['Von_W' => -1000, 'Bis_W' => 0]],
            BatterieRegler::leistungsangebot(
                true, true, true, 21.0, 20.0, 10.0, true,
                0.0, 0.0, 1000.0, 1000.0
            )
        );
        self::assertSame(
            [['Von_W' => 0, 'Bis_W' => 1000]],
            BatterieRegler::leistungsangebot(
                true, true, true, 10.0, 20.0, 10.0, true,
                0.0, 0.0, 1000.0, 1000.0
            )
        );
    }

    public function testNachladeleistungBegrenztNurSchutzbedingtesLaden(): void
    {
        self::assertSame(
            [400],
            BatterieRegler::leistungsangebot(
                true, true, false, 19.0, 20.0, 10.0, true,
                0.0, 0.0, 1000.0, 1000.0, 400.0
            )
        );
        self::assertSame(
            [['Von_W' => 0, 'Bis_W' => 400]],
            BatterieRegler::leistungsangebot(
                true, true, true, 10.0, 20.0, 10.0, true,
                0.0, 0.0, 1000.0, 1000.0, 400.0
            )
        );
        self::assertSame(
            [['Von_W' => -1000, 'Bis_W' => 400]],
            BatterieRegler::leistungsangebot(
                true, true, true, 15.0, 20.0, 10.0, true,
                0.0, 0.0, 1000.0, 1000.0, 400.0
            )
        );
        self::assertSame(
            [['Von_W' => -1000, 'Bis_W' => 1000]],
            BatterieRegler::leistungsangebot(
                true, true, false, 50.0, 20.0, 10.0, false,
                0.0, 0.0, 1000.0, 1000.0, 400.0
            )
        );
    }

    public function testWechselrichtersteuerungBietetNurNull(): void
    {
        self::assertSame(
            [0],
            BatterieRegler::leistungsangebot(
                true, false, false, 50.0, 20.0, 10.0, false,
                0.0, 0.0, 1000.0, 1000.0
            )
        );
    }

    public function testHerstellerunabhaengigeRegisterwerte(): void
    {
        self::assertSame(
            [
                'Ladeleistung' => 1500,
                'Entladeleistung' => 0,
                'Modus' => 0,
                'Management' => 1,
            ],
            BatterieRegler::registerwerte(
                BatterieRegler::TYP_HERSTELLERUNABHAENGIG,
                BatterieRegler::STEUERUNG_ENELIX,
                1500
            )
        );
        self::assertSame(
            [
                'Ladeleistung' => 0,
                'Entladeleistung' => 1500,
                'Modus' => 1,
                'Management' => 1,
            ],
            BatterieRegler::registerwerte(
                BatterieRegler::TYP_HERSTELLERUNABHAENGIG,
                BatterieRegler::STEUERUNG_ENELIX,
                -1500
            )
        );
    }

    public function testGoodweRegisterwerte(): void
    {
        self::assertSame(
            ['Leistung' => 750, 'Modus' => 11, 'Management' => 2],
            BatterieRegler::registerwerte(
                BatterieRegler::TYP_GOODWE,
                BatterieRegler::STEUERUNG_ENELIX,
                750
            )
        );
        self::assertSame(
            ['Leistung' => 750, 'Modus' => 12, 'Management' => 2],
            BatterieRegler::registerwerte(
                BatterieRegler::TYP_GOODWE,
                BatterieRegler::STEUERUNG_ENELIX,
                -750
            )
        );
        self::assertSame(
            ['Leistung' => 0, 'Management' => 1],
            BatterieRegler::registerwerte(
                BatterieRegler::TYP_GOODWE,
                BatterieRegler::STEUERUNG_WECHSELRICHTER,
                -750
            )
        );
    }

    public function testSolarEdgeRegisterwerte(): void
    {
        self::assertSame(
            [
                'Ladeleistung' => 0,
                'Entladeleistung' => 500,
                'Modus' => 4,
                'Management' => 4,
            ],
            BatterieRegler::registerwerte(
                BatterieRegler::TYP_SOLAREDGE,
                BatterieRegler::STEUERUNG_ENELIX,
                -500
            )
        );
    }

    public function testSigenergySkaliertLeistungAufKilowatt(): void
    {
        self::assertSame(
            [
                'Ladeleistung' => 1.5,
                'Entladeleistung' => 0.0,
                'Modus' => 3,
                'Management' => 1,
            ],
            BatterieRegler::registerwerte(
                BatterieRegler::TYP_SIGENERGY,
                BatterieRegler::STEUERUNG_ENELIX,
                1500
            )
        );
        self::assertSame(
            [
                'Ladeleistung' => 0.0,
                'Entladeleistung' => 1.5,
                'Modus' => 6,
                'Management' => 1,
            ],
            BatterieRegler::registerwerte(
                BatterieRegler::TYP_SIGENERGY,
                BatterieRegler::STEUERUNG_ENELIX,
                -1500
            )
        );
    }

    public function testUngueltigeGrenzenWerdenAbgewiesen(): void
    {
        $this->expectException(InvalidArgumentException::class);

        BatterieRegler::leistungsangebot(
            true, true, false, 50.0, 20.0, 10.0, false,
            0.0, 0.0, -1.0, 1000.0
        );
    }
}