package com.airlock.iam.flow.application.configuration.validation;

import com.airlock.iam.flow.api.application.configuration.step.AbstractInteractiveFlowStepConfig;
import com.airlock.iam.flow.api.application.configuration.step.FlowStepConfig;
import com.airlock.iam.plugin.api.config.ConfigurationContext;
import com.airlock.iam.plugin.api.config.ConfigurationEnvironment;
import com.airlock.iam.plugin.api.config.PluginConfiguration;
import com.airlock.iam.plugin.api.exception.ConfigurationException;
import com.airlock.iam.plugin.api.exception.PropertyConstraintViolationException;
import com.airlock.iam.plugin.api.exception.PropertyTypeMismatchException;
import com.airlock.iam.plugin.api.valuereader.BooleanPropertyValueReader;
import com.airlock.iam.plugin.api.valuereader.PluginListPropertyValueReader;
import com.airlock.iam.plugin.api.valuereader.PluginMapPropertyValueReader;
import com.airlock.iam.plugin.api.valuereader.PluginPropertyValueReader;
import com.airlock.iam.plugin.api.valuereader.StringPropertyValueReader;
import com.airlock.iam.plugin.framework.application.configuration.PluginConfigurationWrapper;
import java.util.Collections;
import java.util.List;
import java.util.Map;
import java.util.Optional;

public final class FlowStepPluginConfiguration extends PluginConfigurationWrapper<FlowStepConfig> {
   private FlowStepPluginConfiguration(PluginConfiguration flowStepConfig) {
      super(flowStepConfig);
   }

   public static FlowStepPluginConfiguration wrapFlowStepPluginConfiguration(PluginConfiguration flowStepConfig) {
      return new FlowStepPluginConfiguration(flowStepConfig);
   }

   public Optional<String> getStepId(ConfigurationEnvironment environment, ConfigurationContext context) throws PropertyTypeMismatchException {
      PluginConfiguration stepIdConfig = PluginPropertyValueReader.effectivePluginPropertyValue(this.getPluginConfiguration(), "stepId", environment, context);
      if (stepIdConfig == null) {
         return Optional.empty();
      }

      String stepId = StringPropertyValueReader.effectiveStringConfigValue(stepIdConfig, "id", environment, context);
      return Optional.ofNullable(stepId);
   }

   public boolean isInteractiveStep() throws ConfigurationException {
      return this.getPluginConfiguration().isOfPluginClass(AbstractInteractiveFlowStepConfig.class);
   }

   public List<PluginConfiguration> getInteractiveGotoTargets(ConfigurationEnvironment environment, ConfigurationContext context) throws PropertyTypeMismatchException {
      return PluginListPropertyValueReader.effectivePluginListPropertyValue(this.getPluginConfiguration(), "interactiveGotoTargets", environment, context);
   }

   public Map<String, PluginConfiguration> getOnFailureGotos(ConfigurationEnvironment environment, ConfigurationContext context) {
      try {
         return PluginMapPropertyValueReader.effectivePluginMapPropertyValue(this.getPluginConfiguration(), "onFailureGotos", environment, context);
      } catch (PropertyTypeMismatchException e) {
         return Collections.emptyMap();
      }
   }

   public List<PluginConfiguration> getDynamicStepActivations(ConfigurationEnvironment environment, ConfigurationContext context) throws PropertyTypeMismatchException {
      return PluginListPropertyValueReader.effectivePluginListPropertyValue(this.getPluginConfiguration(), "dynamicStepActivations", environment, context);
   }

   public boolean requiresActivation(ConfigurationEnvironment environment, ConfigurationContext context) throws PropertyConstraintViolationException {
      try {
         return BooleanPropertyValueReader.effectiveBooleanPropertyValue(this.getPluginConfiguration(), "requiresActivation", environment, context);
      } catch (PropertyTypeMismatchException e) {
         return false;
      }
   }
}