package com.airlock.iam.flow.infrastructure.serialization;

import com.airlock.iam.flow.domain.model.session.InternalFlowSession;
import com.airlock.iam.flow.domain.model.statemachine.FlowStateMachine;
import com.airlock.iam.flow.domain.model.statemachine.FlowStateMachineFactory;
import com.airlock.iam.flow.domain.service.MultiFlowManager;
import jakarta.inject.Inject;
import jakarta.inject.Provider;

public final class StateMachineSerializerImpl implements StateMachineSerializer {
   private final Provider<StateMachineRestore> stateMachineRestore;
   private final Provider<FlowStateMachineFactory> stateMachineFactory;
   private final Provider<MultiFlowManager> multiFlowManager;

   @Inject
   public StateMachineSerializerImpl(
      Provider<StateMachineRestore> stateMachineRestore, Provider<FlowStateMachineFactory> stateMachineFactory, Provider<MultiFlowManager> multiFlowManager
   ) {
      this.stateMachineRestore = stateMachineRestore;
      this.stateMachineFactory = stateMachineFactory;
      this.multiFlowManager = multiFlowManager;
   }

   @Override
   public String serializeStateMachine(FlowStateMachine stateMachine) {
      return ((StateMachineRestore)this.stateMachineRestore.get()).serializedStateMachineContext(stateMachine).getEncoded();
   }

   @Override
   public FlowStateMachine deserializeStateMachine(String serialized, InternalFlowSession flowSession) {
      FlowStateMachine stateMachine = ((FlowStateMachineFactory)this.stateMachineFactory.get())
         .createEmptyStateMachine(flowSession, (MultiFlowManager)this.multiFlowManager.get());
      ((StateMachineRestore)this.stateMachineRestore.get())
         .initializeStateMachineFromContext(stateMachine, SerializedStateMachineContext.fromEncoded(serialized));
      return stateMachine;
   }
}