/*-------------------------------------------------------------------------+
|                                                                          |
| Copyright (c) 2005-2017 The ConQAT Project                               |
|                                                                          |
| 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 eu.cqse.check.framework.postprocessor.cobol;

import static eu.cqse.check.framework.shallowparser.SubTypeNames.ANONYMOUS_METHOD;
import static eu.cqse.check.framework.shallowparser.framework.EShallowEntityType.META;
import static eu.cqse.check.framework.shallowparser.framework.EShallowEntityType.METHOD;
import static eu.cqse.check.framework.shallowparser.framework.EShallowEntityType.MODULE;
import static eu.cqse.check.framework.shallowparser.framework.EShallowEntityType.STATEMENT;
import static eu.cqse.check.framework.shallowparser.framework.EShallowEntityType.TYPE;
import static eu.cqse.check.framework.shallowparser.languages.cobol.CobolShallowParser.PARAGRAPH_SUBTYPE_NAME;
import static eu.cqse.check.framework.shallowparser.languages.cobol.CobolShallowParser.SECTION_SUBTYPE_NAME;

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

import org.conqat.lib.commons.collections.CollectionUtils;

import eu.cqse.check.framework.scanner.IToken;
import eu.cqse.check.framework.shallowparser.framework.EShallowEntityType;
import eu.cqse.check.framework.shallowparser.framework.ShallowEntity;
import eu.cqse.check.framework.util.tokens.TokenUtils;

/**
 * A Cobol post processor that transforms sections and paragraph statements into
 * methods. Sections are checked first as priority before paragraphs.
 */
public class SectionParagraphToMethodProcessor {

        /** List of non-comment tokens as seen by the Cobol Shallow Parser */
        private final List<IToken> tokens;

        /** Constructor. */
        public SectionParagraphToMethodProcessor(List<IToken> tokens) {
                this.tokens = CollectionUtils.filter(tokens, token -> !TokenUtils.isCommentToken(token));
        }

        /**
         * Transforms a list of shallow entities from a parsing phase, post-processing
         * them.
         */
        public List<ShallowEntity> postProcess(List<ShallowEntity> entities) {
                List<ShallowEntity> result = new ArrayList<ShallowEntity>();
                // Enterprise COBOL now supports method definition in the ID
                // division so we do not include it here
                EnumSet<EShallowEntityType> cobolProgramTypes = EnumSet.of(MODULE, TYPE);
                for (ShallowEntity entity : entities) {
                        ShallowEntity child;
                        if (cobolProgramTypes.contains(entity.getType())) {
                                child = processProgramTypeAndChildren(entity);
                        } else {
                                child = SectionParagraphToMethodProcessor.createCopy(entity, tokens);
                        }

                        child.setComplete();
                        result.add(child);
                }

                fixEndTokenIndex(result);

                return result;
        }

        /** Recursively fixes the end token index to include all children. */
        private void fixEndTokenIndex(List<ShallowEntity> entities) {
                for (ShallowEntity entity : entities) {
                        if (entity.hasChildren()) {
                                List<ShallowEntity> children = entity.getChildren();
                                fixEndTokenIndex(children);
                                entity.setEndTokenIndex(
                                                Math.max(entity.getEndTokenIndex(), CollectionUtils.getLast(children).getEndTokenIndex()));
                        }
                }
        }

        /**
         * Processes Cobol program types i.e. programs, classes, factories or objects
         * and their children, depending on the presence or absence of section or
         * paragraph statements.
         */
        private ShallowEntity processProgramTypeAndChildren(ShallowEntity programTypeEntity) {
                List<ShallowEntity> children = programTypeEntity.getChildren();
                List<Integer> indices = getIndicesForEntitiesToBecomeMethods(children, SECTION_SUBTYPE_NAME);
                if (!indices.isEmpty()) {
                        return makeSectionsParagraphsIntoMethods(programTypeEntity, indices);
                }

                indices = getIndicesForEntitiesToBecomeMethods(children, PARAGRAPH_SUBTYPE_NAME);
                if (!indices.isEmpty()) {
                        return makeSectionsParagraphsIntoMethods(programTypeEntity, indices);
                }

                return makeProgramTypeIntoMethod(programTypeEntity);
        }

        /**
         * Retrieve the indices for sections or paragraphs as indicated in the sub-type
         * parameter.
         */
        private static List<Integer> getIndicesForEntitiesToBecomeMethods(List<ShallowEntity> entities, String subType) {
                List<Integer> indices = new ArrayList<Integer>();
                for (int i = 0; i < entities.size(); ++i) {
                        if (isStatementWithSubTypeAs(entities.get(i), subType)) {
                                indices.add(i);
                        }
                }

                return indices;
        }

        /**
         * Transform the entities of a Cobol program, converting section or paragraph
         * statements into methods and reorganizing other statements as children of the
         * methods.
         */
        private ShallowEntity makeSectionsParagraphsIntoMethods(ShallowEntity programTypeEntity, List<Integer> indices) {
                List<ShallowEntity> children = programTypeEntity.getChildren();
                int entityToBecomeMethodIndex = 0;
                int firstChildIndex = 0;
                int lastChildIndex = indices.get(0) - 1;
                ShallowEntity newModuleOrTypeEntity = transformProgramType(programTypeEntity, children, firstChildIndex,
                                lastChildIndex);
                while (entityToBecomeMethodIndex <= indices.size() - 1) {
                        int index = indices.get(entityToBecomeMethodIndex);
                        ShallowEntity entityToBecomeMethod = children.get(index);
                        firstChildIndex = index + 1;
                        entityToBecomeMethodIndex += 1;
                        if (entityToBecomeMethodIndex == indices.size()) {
                                // We have reached the last entity to become method
                                lastChildIndex = children.size() - 1;
                        } else {
                                lastChildIndex = indices.get(entityToBecomeMethodIndex) - 1;
                        }

                        ShallowEntity transformedEntity = transformEntityAndAddChildren(entityToBecomeMethod, children,
                                        firstChildIndex, lastChildIndex, true);
                        transformedEntity.setComplete();
                        newModuleOrTypeEntity.addChild(transformedEntity);
                }

                newModuleOrTypeEntity.setComplete();
                return newModuleOrTypeEntity;
        }

        /**
         * For a case where there are no sections and paragraphs, we transform the Cobol
         * program, factory, object or class statement into a method block.
         */
        private ShallowEntity makeProgramTypeIntoMethod(ShallowEntity programTypeEntity) {
                ShallowEntity changedProgramTypeEntity = SectionParagraphToMethodProcessor.createCopy(programTypeEntity,
                                tokens);
                if (programTypeEntity.getType() != METHOD) {
                        // Enterprise Cobol method files will not come in here
                        changedProgramTypeEntity = SectionParagraphToMethodProcessor.changeToMethodEntity(programTypeEntity,
                                        tokens);
                }

                for (ShallowEntity entity : programTypeEntity.getChildren()) {
                        changedProgramTypeEntity.addChild(transformChild(entity));
                }

                return changedProgramTypeEntity;
        }

        /**
         * Recursively transform an entity and its children.
         */
        private ShallowEntity transformChild(ShallowEntity parent) {
                ShallowEntity newParent = SectionParagraphToMethodProcessor.createCopy(parent, tokens);
                newParent.setComplete();
                parent.getChildren().forEach(child -> newParent.addChild(transformChild(child)));
                return newParent;
        }

        /**
         * Transform a Cobol program type and its children. If there are statements
         * between the procedure division entity and first entity to be transformed to a
         * method, they are made into an artificial method.
         */
        private ShallowEntity transformProgramType(ShallowEntity parent, List<ShallowEntity> programTypeChildren,
                        int firstChildIndex, int lastChildIndex) {
                ShallowEntity newParent = SectionParagraphToMethodProcessor.createCopy(parent, tokens);
                int i;
                for (i = firstChildIndex; i <= lastChildIndex; ++i) {
                        ShallowEntity entity = programTypeChildren.get(i);
                        newParent.addChild(transformChild(entity));
                        if (isProcedureDivisionEntity(entity)) {
                                // break out to decide if we create an artificial method for
                                // subsequent entities before the first method in the procedure
                                // division
                                break;
                        }
                }

                if (i == lastChildIndex) {
                        return newParent;
                }

                i += 1;
                ShallowEntity result = new ShallowEntity(METHOD, ANONYMOUS_METHOD, "#artificial#", tokens,
                                programTypeChildren.get(i).getStartTokenIndex());
                result.setEndTokenIndex(programTypeChildren.get(lastChildIndex).getEndTokenIndex());
                ShallowEntity artificialMethod = result;
                while (i <= lastChildIndex) {
                        artificialMethod.addChild(transformChild(programTypeChildren.get(i)));
                        i += 1;
                }

                artificialMethod.setComplete();
                newParent.addChild(artificialMethod);
                return newParent;
        }

        /**
         * Returns true if an entity is a procedure division otherwise false.
         */
        private static boolean isProcedureDivisionEntity(ShallowEntity entity) {
                return entity.getType() == META && entity.getSubtype().equals("division")
                                && entity.getName().equals("procedure");
        }

        /**
         * Transforms a given entity into a Cobol Shallow Entity and/or changing its
         * shallow entity type into a method. For a collection of shallow entities under
         * a Cobol program type, given entities A, B and C that will be transformed into
         * methods, this procedure adds all entities between A and B as children of A
         * while entities between B and C as children of B.
         */
        private ShallowEntity transformEntityAndAddChildren(ShallowEntity parent, List<ShallowEntity> programTypeChildren,
                        int firstChildIndex, int lastChildIndex, boolean transformParentToMethod) {
                ShallowEntity newParent = SectionParagraphToMethodProcessor.createCopy(parent, tokens);
                if (transformParentToMethod) {
                        newParent = SectionParagraphToMethodProcessor.changeToMethodEntity(parent, tokens);
                }

                for (int i = firstChildIndex; i <= lastChildIndex; ++i) {
                        newParent.addChild(transformChild(programTypeChildren.get(i)));
                }

                if (transformParentToMethod) {
                        newParent.setComplete();
                }

                return newParent;
        }

        /** Creates a copy of a shallow entity. */
        private static ShallowEntity createCopy(ShallowEntity entity, List<IToken> tokens) {
                ShallowEntity result = new ShallowEntity(entity.getType(), entity.getSubtype(), entity.getName(), tokens,
                                entity.getStartTokenIndex());
                result.setEndTokenIndex(entity.getEndTokenIndex());
                return result;
        }

        /** Creates copy of a shallow entity with changed type "method". */
        private static ShallowEntity changeToMethodEntity(ShallowEntity entity, List<IToken> tokens) {
                ShallowEntity result = new ShallowEntity(METHOD, entity.getSubtype(), entity.getName(), tokens,
                                entity.getStartTokenIndex());
                result.setEndTokenIndex(entity.getEndTokenIndex());
                return result;
        }

        /**
         * Returns true if a given entity is a statement and has a sub-type as indicated
         * in the parameter otherwise false.
         */
        private static boolean isStatementWithSubTypeAs(ShallowEntity entity, String subType) {
                return entity.getSubtype() != null && entity.getSubtype().equals(subType) && entity.getType() == STATEMENT;
        }
}