package com.example;

/*
Martrikelnummer der Gruppenmitglieder: Olha Grubryn (235122), Egor Rutkowski(225064), Nikola Kramaric (238498), Dennis Ruppel (238503)
*/

import akka.actor.typed.ActorRef;
import akka.actor.typed.Behavior;
import akka.actor.typed.javadsl.AbstractBehavior;
import akka.actor.typed.javadsl.ActorContext;
import akka.actor.typed.javadsl.Behaviors;
import akka.actor.typed.javadsl.Receive;

import java.time.Duration;
import java.time.Instant;

public class PrintAndEvaluate extends AbstractBehavior<PrintAndEvaluate.Message> {

    String name;
    Instant startTime; // Startzeit für die Zeitmessung der Berechnung

    public interface Message{}

    public record StringResponse(String string) implements Message{}

    public record StartMessage(Expression expression) implements Message{}

    public record IntResponse(int wert) implements Message{}

    private PrintAndEvaluate(ActorContext<PrintAndEvaluate.Message> context, String name){
        super(context);
        this.name = name;
    }

    public static Behavior<PrintAndEvaluate.Message> create(String name){
        return Behaviors.setup(context -> new PrintAndEvaluate(context, name));
    }

    @Override
    public Receive<PrintAndEvaluate.Message> createReceive(){
        return newReceiveBuilder()
                .onMessage(StartMessage.class, this::onStartMessage)
                .onMessage(StringResponse.class, this::onStringResponse)
                .onMessage(IntResponse.class, this::onIntResponse)
                .build();
    }

    // Mit dieser Message wird der PrintAndEvaluate Aktor in Gang gesetzt
    private Behavior<Message> onStartMessage(StartMessage message){
        // Startzeit für die Zeitmessung setzen
        this.startTime = Instant.now();

        // Starten des Formatierungsvorganges
        this.getContext().getLog().info("\n Beginn der Ausdrucksformatierung");

        ActorRef<Actor.Message> printActor = getContext().spawnAnonymous(Actor.create());
        printActor.tell(new Actor.PrintMessage(getContext().getSelf(), message.expression));

        // Starten des Berechnungsvorganges
        this.getContext().getLog().info("\n Beginn der Berechnung");
        ActorRef<Actor.Message> computeActor = getContext().spawnAnonymous(Actor.create());
        computeActor.tell(new Actor.EvaluateMessage(getContext().getSelf(), message.expression));
        return this;
    }

    // Ausgeben des Ausdruckes als String
    private Behavior<Message> onStringResponse(StringResponse response){
        this.getContext().getLog().info("\n Formatierter Ausdruck: " + response.string);
        return this;
    }

    // Ausgeben des berechneten Wertes von dem Ausdruck und der Berechnungsdauer
    private Behavior<Message> onIntResponse(IntResponse response){
        Duration duration = Duration.between(startTime, Instant.now());
        this.getContext().getLog().info("\n Ausgerechneter Wert: " + response.wert);
        this.getContext().getLog().info("\n Berechnungsdauer: " + duration.toSeconds() + " Sekunden");
        return this;
    }
}