/*
 *  Copyright 2010 Anyware Services
 *
 *  Licensed under the Apache License, Version 2.0 (the "License");
 *  you may not use this file except in compliance with the License.
 *  You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 *  Unless required by applicable law or agreed to in writing, software
 *  distributed under the License is distributed on an "AS IS" BASIS,
 *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *  See the License for the specific language governing permissions and
 *  limitations under the License.
 */
package org.ametys.cms.content.consistency;

import java.time.ZonedDateTime;
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Optional;
import java.util.concurrent.Callable;
import java.util.concurrent.CancellationException;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Executor;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
import java.util.concurrent.ThreadFactory;
import java.util.concurrent.atomic.AtomicLong;
import java.util.stream.Collectors;

import javax.jcr.RepositoryException;

import org.apache.avalon.framework.activity.Initializable;
import org.apache.avalon.framework.component.Component;
import org.apache.avalon.framework.context.ContextException;
import org.apache.avalon.framework.context.Contextualizable;
import org.apache.avalon.framework.logger.Logger;
import org.apache.avalon.framework.service.ServiceException;
import org.apache.avalon.framework.service.ServiceManager;
import org.apache.avalon.framework.service.Serviceable;
import org.apache.cocoon.Constants;
import org.apache.cocoon.environment.Context;
import org.apache.cocoon.util.log.SLF4JLoggerAdapter;

import org.ametys.cms.content.references.OutgoingReferences;
import org.ametys.cms.contenttype.ContentType;
import org.ametys.cms.contenttype.ContentTypeExtensionPoint;
import org.ametys.cms.repository.Content;
import org.ametys.cms.repository.ContentQueryHelper;
import org.ametys.cms.repository.DefaultContent;
import org.ametys.cms.repository.WorkflowAwareContent;
import org.ametys.cms.transformation.ConsistencyChecker;
import org.ametys.cms.transformation.ConsistencyChecker.CHECK;
import org.ametys.core.engine.BackgroundEngineHelper;
import org.ametys.core.schedule.progression.ContainerProgressionTracker;
import org.ametys.core.schedule.progression.SimpleProgressionTracker;
import org.ametys.core.util.DateUtils;
import org.ametys.plugins.repository.AmetysObjectIterable;
import org.ametys.plugins.repository.AmetysObjectResolver;
import org.ametys.plugins.repository.AmetysRepositoryException;
import org.ametys.plugins.repository.ModifiableAmetysObject;
import org.ametys.plugins.repository.ModifiableTraversableAmetysObject;
import org.ametys.plugins.repository.RepositoryConstants;
import org.ametys.plugins.repository.UnknownAmetysObjectException;
import org.ametys.plugins.repository.collection.AmetysObjectCollectionFactory;
import org.ametys.plugins.repository.jcr.NameHelper;
import org.ametys.plugins.repository.jcr.NameHelper.NameComputationMode;
import org.ametys.plugins.repository.query.QueryHelper;
import org.ametys.plugins.repository.query.expression.AndExpression;
import org.ametys.plugins.repository.query.expression.Expression;
import org.ametys.plugins.repository.query.expression.Expression.Operator;
import org.ametys.plugins.repository.query.expression.StringExpression;
import org.ametys.plugins.repositoryapp.RepositoryProvider;
import org.ametys.plugins.workflow.support.WorkflowHelper;
import org.ametys.runtime.model.Model;
import org.ametys.runtime.model.ModelHelper;
import org.ametys.runtime.model.View;
import org.ametys.runtime.model.ViewHelper;
import org.ametys.runtime.plugin.component.AbstractLogEnabled;

import com.opensymphony.workflow.loader.StepDescriptor;

/**
 * Manage all operation related to checking the consistency of a content
 */
public class ContentConsistencyManager extends AbstractLogEnabled implements Initializable, Contextualizable, Serviceable, Component
{
    /** The avalon role */
    public static final String ROLE = ContentConsistencyManager.class.getName();
    
    private static final String __CONSISTENCY_RESULTS_ROOT_NODE_NAME = "consistencyResults";
    
    private static ExecutorService __PARALLEL_THREAD_EXECUTOR;
    private static final int __THREAD_POOL_SIZE_MULTIPLIER = 4;
    
    /** The ametys object resolver. */
    protected AmetysObjectResolver _resolver;
    
    /** The consistency checker */
    protected ConsistencyChecker _consistencyChecker;
    
    private Context _cocoonContext;
    private RepositoryProvider _repositoryProvider;
    private ServiceManager _manager;

    private ContentTypeExtensionPoint _cTypeEP;

    private WorkflowHelper _workflowHelper;

    public void contextualize(org.apache.avalon.framework.context.Context context) throws ContextException
    {
        _cocoonContext = (Context) context.get(Constants.CONTEXT_ENVIRONMENT_CONTEXT);
    }
    
    public void service(ServiceManager manager) throws ServiceException
    {
        _manager = manager;
        _consistencyChecker = (ConsistencyChecker) manager.lookup(ConsistencyChecker.ROLE);
        _resolver = (AmetysObjectResolver) manager.lookup(AmetysObjectResolver.ROLE);
        _repositoryProvider = (RepositoryProvider) manager.lookup(RepositoryProvider.ROLE);
        _workflowHelper = (WorkflowHelper) manager.lookup(WorkflowHelper.ROLE);
        _cTypeEP = (ContentTypeExtensionPoint) manager.lookup(ContentTypeExtensionPoint.ROLE);
    }

    public void initialize() throws Exception
    {
        AsyncConsistencyCheckerThreadFactory threadFactory = new AsyncConsistencyCheckerThreadFactory();
        // The thread are doing a lot of heavy IO operations, it's worth going over the number of available processors
        __PARALLEL_THREAD_EXECUTOR = Executors.newFixedThreadPool(Runtime.getRuntime().availableProcessors() * __THREAD_POOL_SIZE_MULTIPLIER, threadFactory);
    }
    
    /**
     * Thread factory for async checker.
     * Set the thread name format and marks the thread as daemon.
     */
    static class AsyncConsistencyCheckerThreadFactory implements ThreadFactory
    {
        private static ThreadFactory _defaultThreadFactory;
        private static String _nameFormat;
        private static AtomicLong _count;
        
        public AsyncConsistencyCheckerThreadFactory()
        {
            _defaultThreadFactory = Executors.defaultThreadFactory();
            _nameFormat = "ametys-async-consistency-checker-%d";
            _count = new AtomicLong(0);
        }
        
        public Thread newThread(Runnable r)
        {
            Thread thread = _defaultThreadFactory.newThread(r);
            thread.setName(String.format(_nameFormat, _count.getAndIncrement()));
            // make the threads low priority daemon to avoid slowing user thread
            thread.setDaemon(true);
            thread.setPriority(3);
            
            return thread;
        }
    }
    
    /**
     * Getter to provide synthetic access to the manager
     */
    private ServiceManager getManager()
    {
        return _manager;
    }
    
    /**
     * Runnable to be used for asynchronous calls
     */
    class AsyncConsistencyChecker implements Callable<String>
    {
        /** event to observe */
        protected final Logger _logger;
        private final Content _content;
        private SimpleProgressionTracker _tracker;
        
        public AsyncConsistencyChecker(Content content, SimpleProgressionTracker progressionTracker, org.slf4j.Logger logger)
        {
            this._logger = new SLF4JLoggerAdapter(logger);
            this._content = content;
            this._tracker = progressionTracker;
        }
        
        @Override
        public String call()
        {
            Map<String, Object> environmentInformation = null;
            try
            {
                // Create the environment.
                environmentInformation = BackgroundEngineHelper.createAndEnterEngineEnvironment(getManager(), _cocoonContext, _logger);
                
                return _checkConsistency(_content);
            }
            catch (Exception e)
            {
                throw new RuntimeException("Content consistency check for content " + _content.getId() + " failed", e);
            }
            finally
            {
                BackgroundEngineHelper.leaveEngineEnvironment(environmentInformation);
                this._tracker.increment();
            }
        }
    }
    
    /**
     * Check all contents to see if there references are consistent.
     * All result will also be stored in the consistency result database table for later access.
     * @param progressionTracker the progression tracker for consistensy check
     * @return record describing the results of the checks
     */
    public ConsistenciesReport checkAllContents(ContainerProgressionTracker progressionTracker)
    {
        // Get the start date to remove outdated results later
        ZonedDateTime startDate = ZonedDateTime.now();
        try (AmetysObjectIterable<Content> contents = _getContents(null))
        {
            ConsistenciesReport checkReport = _checkContents(contents, progressionTracker.getStep(CheckContentConsistencySchedulable.CHECK_CONTENTS));
            // the checkContents only remove possible outdated results for the set of content provided as arguments.
            // We need to remove all the other result : deleted content, deleted link, etc…
            removeOutdatedResult(startDate, null, progressionTracker.getStep(CheckContentConsistencySchedulable.REMOVE_OUTDATED_RESULT));
            return checkReport;
        }
    }
    
    /**
     * Remove results older than a given date
     * @param date the threshold
     * @param filterExpression an expression to filter the content to consider, null to consider all contents
     * @param progressionTracker the progression tracker for the task
     */
    protected void removeOutdatedResult(ZonedDateTime date, Expression filterExpression, SimpleProgressionTracker progressionTracker)
    {
        String xPathQuery = QueryHelper.getXPathQuery(null, ContentConsistencyResult.CONTENT_CONSISTENCY_RESULT_NODETYPE, filterExpression);
        xPathQuery += "[@ametys:" + ContentConsistencyModel.DATE + " < xs:dateTime('" + DateUtils.zonedDateTimeToString(date) + "')]";
        try (AmetysObjectIterable<ContentConsistencyResult> outdatedResults = _resolver.query(xPathQuery))
        {
            progressionTracker.setSize(outdatedResults.getSize());
            for (ContentConsistencyResult outdatedResult : outdatedResults)
            {
                try
                {
                    outdatedResult.remove();
                    outdatedResult.saveChanges();
                }
                catch (AmetysRepositoryException e)
                {
                    getLogger().warn("Failed to remove outdated result '{}' due to repository error", outdatedResult.getId(), e);
                }
                progressionTracker.increment();
            }
        }
    }

    /**
     * Record holding the results of a consistency checks on multiple contents
     * @param results a list of {@link ContentConsistencyResult} for every contents that were checked
     * @param unchecked a list of content id for every content check that were interrupted, cancelled or failed during execution
     */
    public record ConsistenciesReport(List<String> results, List<String> unchecked) {
        /**
         * Returns true if this report contains no elements
         * @return true if this report contains no elements
         */
        public boolean isEmpty()
        {
            return (results == null || results.isEmpty())
                && (unchecked == null || unchecked.isEmpty());
        }
    }

    /**
     * Check all the content provided by the iterable for broken links.
     * This method will actually provide {@link Callable} to an {@link Executor} that parallelize the checks.
     * @param contents an iterable of contents to check
     * @param progressionTracker progression tracker for ckecking conistency in contents
     * @return record describing the results of the checks
     */
    protected ConsistenciesReport _checkContents(AmetysObjectIterable<Content> contents, SimpleProgressionTracker progressionTracker)
    {
        try
        {
            progressionTracker.setSize(contents.getSize());
            
            List<String> done = new ArrayList<>();
            List<String> failed = new ArrayList<>();
            
            // submit all the content for checking
            // No parallel stream to avoid spawning thread to spawn thread
            // This means that we can't process the result in the same stream
            // or the submission of thread will be block until the previous one is finished
            Map<String, Future<String>> results = contents.stream()
                .collect(Collectors.toMap(Content::getId, content -> {
                    AsyncConsistencyChecker checker = new AsyncConsistencyChecker(content, progressionTracker, getLogger());
                    return __PARALLEL_THREAD_EXECUTOR.submit(checker);
                }));
            
            // Now that everything is submitted, we can iterate and wait for result
            for (Entry<String, Future<String>> entry : results.entrySet())
            {
                try
                {
                    // block until thread result is available
                    String contentId = entry.getValue().get();
                    if (contentId != null)
                    {
                        done.add(contentId);
                    }
                }
                catch (CancellationException | InterruptedException | ExecutionException e)
                {
                    String contentId = entry.getKey();
                    getLogger().error("Failed to retrieve result from content consistency checker thread for content {}", contentId, e);
                    failed.add(contentId);
                }
            }
            
            // Refresh the session to retrieve the repository modification from the threads
            _repositoryProvider.getSession("default").refresh(true);
            return new ConsistenciesReport(done, failed);
        }
        catch (RepositoryException e)
        {
            getLogger().error("Failed to refresh the session");
            return null;
        }
    }
    
    private String _checkConsistency(Content content)
    {
        int successCount = 0;
        int unknownCount = 0;
        int unauthorizedCount = 0;
        int notFoundCount = 0;
        int serverErrorCount = 0;
        
        Map<String, OutgoingReferences> referencesByPath = content.getOutgoingReferences();
        
        for (String dataPath : referencesByPath.keySet())
        {
            OutgoingReferences references = referencesByPath.get(dataPath);
            for (String referenceType : references.keySet())
            {
                for (String referenceValue : references.get(referenceType))
                {
                    CHECK check;
                    try
                    {
                        check = _consistencyChecker.checkConsistency(referenceType, referenceValue, content.getId(), dataPath, false).status();
                    }
                    catch (Exception e)
                    {
                        check = CHECK.SERVER_ERROR;
                        getLogger().debug("An exception occurred while checking reference value {} at dataPath {} for content {}", referenceType + "#" + referenceValue, dataPath, content.getId(), e);
                    }
                    
                    switch (check)
                    {
                        case SUCCESS:
                            successCount++;
                            break;
                        case UNKNOWN:
                            unknownCount++;
                            break;
                        case UNAUTHORIZED:
                            unauthorizedCount++;
                            break;
                        case NOT_FOUND:
                            notFoundCount++;
                            break;
                        case SERVER_ERROR:
                        default:
                            serverErrorCount++;
                            break;
                    }
                }
            }
        }
        
        // Store the result
        ContentConsistencyResult result = storeResult((WorkflowAwareContent) content, successCount, unknownCount, unauthorizedCount, notFoundCount, serverErrorCount);
        
        return result != null ? result.getId() : null;
    }

    /**
     * Store the result of the consistency check done on the content
     * @param content the content checked
     * @param successCount the number of success
     * @param unknownCount the number of unknown
     * @param unauthorizedCount the number of unauthorized
     * @param notFoundCount the number of not found
     * @param serverErrorCount the number of server error
     * @return the result
     */
    protected ContentConsistencyResult storeResult(WorkflowAwareContent content, int successCount, int unknownCount, int unauthorizedCount, int notFoundCount, int serverErrorCount)
    {
        // Retrieve a pre existing result for the content or create an new one
        Optional<ContentConsistencyResult> previousResult = _getExistingResultForContent(content.getId());
        if (unknownCount > 0 || unauthorizedCount > 0 || serverErrorCount > 0 || notFoundCount > 0)
        {
            ContentConsistencyResult result = previousResult.orElseGet(() ->
                {
                    ModifiableTraversableAmetysObject root = _getOrCreateRootCollection();
                    String nodeName = NameHelper.getUniqueAmetysObjectName(root, "consistency-result", NameComputationMode.GENERATED_KEY, false);
                    return root.createChild(nodeName, ContentConsistencyResult.CONTENT_CONSISTENCY_RESULT_NODETYPE);
                }
            );
            
            Map<String, Object> values = new HashMap<>();
            values.put(ContentConsistencyModel.CONTENT_ID, content.getId());
            values.put(ContentConsistencyModel.TITLE, content.getTitle());
            values.put(ContentConsistencyModel.CONTENT_TYPES, content.getTypes());
            values.put(ContentConsistencyModel.CREATION_DATE, content.getCreationDate());
            values.put(ContentConsistencyModel.CREATOR, content.getCreator());
            Optional.ofNullable(content.getLastMajorValidationDate()).ifPresent(date -> values.put(ContentConsistencyModel.LAST_MAJOR_VALIDATION_DATE, date));
            content.getLastMajorValidator().ifPresent(user -> values.put(ContentConsistencyModel.LAST_MAJOR_VALIDATOR, user));
            Optional.ofNullable(content.getLastValidationDate()).ifPresent(date -> values.put(ContentConsistencyModel.LAST_VALIDATION_DATE, date));
            content.getLastValidator().ifPresent(user -> values.put(ContentConsistencyModel.LAST_VALIDATOR, user));
            values.put(ContentConsistencyModel.LAST_CONTRIBUTOR, content.getLastContributor());
            values.put(ContentConsistencyModel.LAST_MODIFICATION_DATE, content.getLastModified());
            values.put(ContentConsistencyModel.WORKFLOW_STEP, content.getCurrentStepId());
            values.put(ContentConsistencyModel.DATE, ZonedDateTime.now());
            values.put(ContentConsistencyModel.NOT_FOUND, notFoundCount);
            values.put(ContentConsistencyModel.SERVER_ERROR, serverErrorCount);
            values.put(ContentConsistencyModel.SUCCESS, successCount);
            values.put(ContentConsistencyModel.UNAUTHORIZED, unauthorizedCount);
            values.put(ContentConsistencyModel.UNKNOWN, unknownCount);
            
            result.synchronizeValues(values);
            
            result.saveChanges();
            return result;
        }
        // Remove old result if there is no error any more
        else if (previousResult.isPresent())
        {
            ContentConsistencyResult result = previousResult.get();
            ModifiableAmetysObject parent = result.getParent();
            result.remove();
            parent.saveChanges();
        }
        return null;
    }

    private Optional<ContentConsistencyResult> _getExistingResultForContent(String id)
    {
        String xPathQuery = QueryHelper.getXPathQuery(null, ContentConsistencyResult.CONTENT_CONSISTENCY_RESULT_NODETYPE, new StringExpression(ContentConsistencyModel.CONTENT_ID, Operator.EQ, id));
        try (AmetysObjectIterable<ContentConsistencyResult> query = _resolver.query(xPathQuery))
        {
            return query.stream().findFirst();
        }
    }
    
    // Synchronized to avoid creation of multiple root
    private synchronized ModifiableTraversableAmetysObject _getOrCreateRootCollection()
    {
        ModifiableTraversableAmetysObject pluginsRoot = _resolver.resolveByPath("/ametys:plugins");
        
        ModifiableTraversableAmetysObject cmsNode = null;
        if (pluginsRoot.hasChild("cms"))
        {
            cmsNode = (ModifiableTraversableAmetysObject) pluginsRoot.getChild("cms");
        }
        else
        {
            cmsNode = (ModifiableTraversableAmetysObject) pluginsRoot.createChild("cms", "ametys:unstructured");
        }
        
        ModifiableTraversableAmetysObject resultsCollection = null;
        if (cmsNode.hasChild(__CONSISTENCY_RESULTS_ROOT_NODE_NAME))
        {
            resultsCollection = (ModifiableTraversableAmetysObject) cmsNode.getChild(__CONSISTENCY_RESULTS_ROOT_NODE_NAME);
        }
        else
        {
            resultsCollection = (ModifiableTraversableAmetysObject) cmsNode.createChild(__CONSISTENCY_RESULTS_ROOT_NODE_NAME, AmetysObjectCollectionFactory.COLLECTION_NODETYPE);
            // Save the new node instantly to allow other thread to retrieve the newly created node.
            cmsNode.saveChanges();
        }
        
        return resultsCollection;
    }
    
    /**
     * Get the contents with inconsistency information.
     * @param filterExpression an expression to filter content to check, or null to check all contents
     * @return an iterator on contents.
     */
    protected AmetysObjectIterable<Content> _getContents(Expression filterExpression)
    {
        String query = ContentQueryHelper.getContentXPathQuery(filterExpression != null ? new AndExpression(new ConsistencyExpression(), filterExpression) : new ConsistencyExpression());
        return _resolver.query(query);
    }

    /**
     * Expression which tests if contents have consistency informations.
     */
    public static class ConsistencyExpression implements Expression
    {
        public String build()
        {
            return new StringBuilder()
            .append(RepositoryConstants.NAMESPACE_PREFIX_INTERNAL).append(':').append(DefaultContent.METADATA_ROOT_OUTGOING_REFERENCES)
            .append('/').append(RepositoryConstants.NAMESPACE_PREFIX_INTERNAL).append(':').append(DefaultContent.METADATA_OUTGOING_REFERENCES)
            .append("/*")
            .append("/@").append(RepositoryConstants.NAMESPACE_PREFIX).append(':').append(DefaultContent.METADATA_OUTGOING_REFERENCE_PROPERTY)
            .toString();
        }
    }

    /**
     * Serialize a content consistency result as JSON
     * @param result the results to serialize
     * @param columns the list of columns to use as "view"
     * @return a JSON representation of the result
     */
    public Map<String, Object> resultToJSON(ContentConsistencyResult result, List<Map<String, Object>> columns)
    {
        // Column can point either to the result object or the linked content.
        // We need to separate them before serializing
        
        Collection< ? extends Model> resultModel = result.getModel();
        Model[] resultModelArray = resultModel.toArray(size -> new Model[size]);
        // initialize the view with the content id. Its convenient and we should
        // always need this value
        View resultView = View.of(resultModel, ContentConsistencyModel.CONTENT_ID);
        
        // Do not fail if the content is unavailable, simply ignore the content column
        Content content = null;
        Collection<? extends Model> contentModel = null;
        Model[] contentModelArray = null;
        View contentView = null;
        boolean contentViewEmpty = true;
        try
        {
            content = _resolver.resolveById(result.getContentId());
            contentModel = content.getModel();
            contentModelArray = contentModel.toArray(size -> new Model[size]);
            contentView = ViewHelper.createEmptyViewItemAccessor(contentModel);
        }
        catch (UnknownAmetysObjectException e)
        {
            getLogger().warn("Content with id '{}' doesn't exist. Consistency result will be included without content data", result.getContentId(), e);
        }
        
        // Separate column in the result view and content view
        for (Map<String, Object> column : columns)
        {
            // if a column is available in the result, use the result value.
            // else try to use the content
            String columnItemPath = (String) column.get("path");
            if (ModelHelper.hasModelItem(columnItemPath, resultModel))
            {
                ViewHelper.addViewItem(columnItemPath, resultView, resultModelArray);
            }
            else if (content != null)
            {
                if (ModelHelper.hasModelItem(columnItemPath, contentModel))
                {
                    ViewHelper.addViewItem(columnItemPath, contentView, contentModelArray);
                    contentViewEmpty = false;
                }
                else
                {
                    getLogger().info("item path {} is not defined for content {}. It will be ignored in the result.", columnItemPath, content.getId());
                }
            }
        }
        
        Map<String, Object> searchResult = result.dataToJSON(resultView);
        
        // improve serialization for some particular metadata
        if (resultView.hasModelViewItem(ContentConsistencyModel.WORKFLOW_STEP))
        {
            searchResult.put(ContentConsistencyModel.WORKFLOW_STEP, _workflowStepToJSON(result.getWorkflowStep(), content));
        }
        
        if (resultView.hasModelViewItem(ContentConsistencyModel.CONTENT_TYPES))
        {
            searchResult.put(ContentConsistencyModel.CONTENT_TYPES, _contentTypeToJSON(result.getContentTypes()));
        }
        
        if (content != null && !contentViewEmpty)
        {
            searchResult.putAll(content.dataToJSON(contentView));
        }
        
        return searchResult;
    }
    
    
    private Object _contentTypeToJSON(String[] typeIds)
    {
        List<Map<String, Object>> jsonValues = new ArrayList<>(typeIds.length);
        for (String id : typeIds)
        {
            ContentType contentType = _cTypeEP.getExtension(id);
            Map<String, Object> jsonValue = new HashMap<>();
            if (contentType != null)
            {
                jsonValue.put("label", contentType.getLabel());
                jsonValue.put("smallIcon", contentType.getSmallIcon());
                
                String iconGlyph = contentType.getIconGlyph();
                if (iconGlyph != null)
                {
                    jsonValue.put("iconGlyph", iconGlyph);
                    String iconDecorator = contentType.getIconDecorator();
                    if (iconDecorator != null)
                    {
                        jsonValue.put("iconDecorator", iconDecorator);
                    }
                }
            }
            jsonValues.add(jsonValue);
        }
        return jsonValues;
    }

    private Object _workflowStepToJSON(long value, Content content)
    {
        if (content instanceof WorkflowAwareContent)
        {
            WorkflowAwareContent waContent = (WorkflowAwareContent) content;
            int currentStepId = Math.toIntExact(value);
            
            StepDescriptor stepDescriptor = _workflowHelper.getStepDescriptor(waContent, currentStepId);
            
            if (stepDescriptor != null)
            {
                return _workflowHelper.workflowStep2JSON(stepDescriptor);
            }
        }
        
        return Map.of();
    }
}