/*-------------------------------------------------------------------------+
|                                                                          |
| Copyright (c) 2009-2018 CQSE GmbH                                        |
|                                                                          |
+-------------------------------------------------------------------------*/
package eu.cqse.check.framework.util.clike;

import java.util.ArrayList;
import java.util.List;

import eu.cqse.check.framework.core.CheckException;
import eu.cqse.check.framework.shallowparser.framework.EShallowEntityType;
import eu.cqse.check.framework.shallowparser.framework.ShallowEntity;

/**
 * This class provides various helper methods to extract conditional block
 * groups out of the abstract syntax tree or Lists of ShallowEntities.
 */
public class ConditionalBlockGroupExtractor {

        /**
         * Recursively checks the entity and its children for corresponding statements
         * in conditional expressions. Use this for example on the Document Root coming
         * from the AST to find all {@link ConditionalBlockGroupBase} in the Document.
         *
         * @param entity
         *            the entity whose children are checked for if/else/else if or
         *            switch/case statements
         * @throws CheckException
         */
        public static List<ConditionalBlockGroupBase> findCorrespondingBlockGroups(ShallowEntity entity)
                        throws CheckException {
                List<ConditionalBlockGroupBase> groupedBlocks = new ArrayList<>();
                EConditionalType blockType = ConditionalBlockUtils.getBlockTypeFromEntity(entity);

                if (blockType != null) {
                        switch (blockType) {
                        case IF:
                                groupedBlocks.add(createIfBlockGroup(entity));
                                break;
                        case SWITCH:
                                groupedBlocks.add(createSwitchBlockGroup(entity));
                                break;
                        default:
                                break;
                        }
                }

                groupedBlocks.addAll(findCorrespondingBlockGroups(entity.getChildren()));

                return groupedBlocks;
        }

        /**
         * Recursively checks the given entities and their children for corresponding
         * statements in conditional expressions.
         * 
         * @param entities
         *            the entities whose children are checked for if/else/else if or
         *            switch/case statements
         * @throws CheckException
         */
        public static List<ConditionalBlockGroupBase> findCorrespondingBlockGroups(List<ShallowEntity> entities)
                        throws CheckException {
                List<ConditionalBlockGroupBase> groupedBlocks = new ArrayList<>();
                if (entities.size() == 0) {
                        return groupedBlocks;
                }

                ShallowEntity parent = entities.get(0).getParent();
                for (ShallowEntity entity : entities) {
                        ShallowEntity actualParent = entity.getParent();
                        if (actualParent != parent) {
                                String message = "The ShallowEntity: [" + entity.getSubtype().toUpperCase() + "] spanning lines ";
                                message += entity.getStartLine() + " through " + entity.getEndLine();
                                message += " has a different parent from its siblings";
                                message += " .Expected parent: [" + parent.getSubtype() + "] spanning lines " + parent.getStartLine()
                                                + " through " + parent.getEndLine();
                                message += " .Actual parent: [" + actualParent.getSubtype() + "] spanning lines "
                                                + actualParent.getStartLine() + " through " + actualParent.getEndLine();
                                message += " File: " + entity.getAllTokens().get(0).getOriginId();
                                throw new IllegalArgumentException(message);
                        }

                        List<ConditionalBlockGroupBase> childrenBlockGroups = findCorrespondingBlockGroups(entity);
                        if (childrenBlockGroups.size() > 0) {
                                groupedBlocks.addAll(childrenBlockGroups);
                        }
                }

                return groupedBlocks;
        }

        /**
         * Finds all corresponding else/ else if blocks for the given if statement
         *
         * @param ifEntity
         *            the if statement for which the else/ else if blocks are searched
         */
        private static IfBlockGroup createIfBlockGroup(ShallowEntity ifEntity) {
                List<ShallowEntity> neighboringEntities = ifEntity.getParent().getChildren();
                int ifIndex = neighboringEntities.indexOf(ifEntity);

                IfBlockGroup ifblockGroup = new IfBlockGroup();

                ConditionalBlock ifBlock = new ConditionalBlock(ConditionalBlockUtils.getBlockTypeFromEntity(ifEntity),
                                ConditionalBlockUtils.extractCondition(ifEntity), ifEntity.getChildren());
                ifblockGroup.getCorrespondingBlocks().add(ifBlock);

                for (int nextIndex = ifIndex + 1; nextIndex < neighboringEntities.size(); nextIndex++) {
                        ShallowEntity nextEntity = neighboringEntities.get(nextIndex);
                        EConditionalType blockType = ConditionalBlockUtils.getBlockTypeFromEntity(nextEntity);
                        if (ConditionalBlockUtils.BLOCKS_CORRESPONDING_TO_IF.contains(blockType)) {
                                if (blockType == EConditionalType.ELSE_IF) {
                                        ifblockGroup.getCorrespondingBlocks().add(new ConditionalBlock(blockType,
                                                        ConditionalBlockUtils.extractCondition(nextEntity), nextEntity.getChildren()));
                                } else if (blockType == EConditionalType.ELSE) {
                                        ifblockGroup.getCorrespondingBlocks()
                                                        .add(new ConditionalBlock(blockType, nextEntity.getChildren()));
                                        break;
                                }
                        } else {
                                break;
                        }
                }

                return ifblockGroup;
        }

        /**
         * Finds all corresponding case blocks for the given switch statement
         *
         * @param switchEntity
         *            the switch statement for which the cases are searched
         */
        private static SwitchBlockGroup createSwitchBlockGroup(ShallowEntity switchEntity) {
                List<ShallowEntity> metas = findMetaStatements(switchEntity);
                List<ShallowEntity> innerStatements = switchEntity.getChildren();

                SwitchBlockGroup switchBlockGroup = new SwitchBlockGroup();
                switchBlockGroup.setSurroundingEntity(switchEntity);

                for (int i = 0; i < metas.size(); i++) {
                        ShallowEntity currentMeta = metas.get(i);

                        int currentMetaParentIndex = innerStatements.indexOf(currentMeta);
                        int nextMetaParentIndex;
                        if (i + 1 < metas.size()) {
                                nextMetaParentIndex = innerStatements.indexOf(metas.get(i + 1));
                        } else {
                                nextMetaParentIndex = innerStatements.size();
                        }

                        List<ShallowEntity> metaStatements = innerStatements.subList(currentMetaParentIndex + 1,
                                        nextMetaParentIndex);

                        if (metaStatements.isEmpty()) {
                                // empty statements are not relevant for this check (e.g. fallthrough case
                                // statement)
                                continue;
                        }

                        EConditionalType blockType = ConditionalBlockUtils.getBlockTypeFromEntity(currentMeta);

                        if (blockType == EConditionalType.CASE) {
                                switchBlockGroup.getCorrespondingBlocks().add(new ConditionalBlock(blockType,
                                                ConditionalBlockUtils.extractCondition(currentMeta), metaStatements));
                        } else {
                                switchBlockGroup.getCorrespondingBlocks().add(new ConditionalBlock(blockType, metaStatements));
                        }
                }

                return switchBlockGroup;
        }

        /**
         * Searches for the meta statements inside the switch case construct. Meta
         * statements are case and default statements.
         */
        private static List<ShallowEntity> findMetaStatements(ShallowEntity entity) {
                List<ShallowEntity> metas = new ArrayList<>();
                for (ShallowEntity innerStatement : entity.getChildren()) {
                        if (innerStatement.getType() == EShallowEntityType.META) {
                                metas.add(innerStatement);
                        }
                }
                return metas;
        }
}