/*

 * Copyright (C) 2007-2010 Júlio Vilmar Gesser.

 * Copyright (C) 2011, 2013-2021 The JavaParser Team.

 *

 * This file is part of JavaParser.

 *

 * JavaParser can be used either under the terms of

 * a) the GNU Lesser General Public License as published by

 *     the Free Software Foundation, either version 3 of the License, or

 *     (at your option) any later version.

 * b) the terms of the Apache License

 *

 * You should have received a copy of both licenses in LICENCE.LGPL and

 * LICENCE.APACHE. Please refer to those files for details.

 *

 * JavaParser is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU Lesser General Public License for more details.

 */

package com.github.javaparser;

import com.github.javaparser.ast.CompilationUnit;

import com.github.javaparser.ast.Modifier;

import com.github.javaparser.ast.Node;

import com.github.javaparser.ast.comments.Comment;

import com.github.javaparser.ast.comments.LineComment;

import com.github.javaparser.utils.PositionUtils;

import java.util.Collections;

import java.util.LinkedList;

import java.util.List;

import java.util.TreeSet;

import static com.github.javaparser.ast.Node.NODE_BY_BEGIN_POSITION;

import static java.util.stream.Collectors.toList;

/**

 * Assigns comments to nodes of the AST.

 *

 * @author Sebastian Kuerten

 * @author Júlio Vilmar Gesser

 */

class CommentsInserter {

    private final ParserConfiguration configuration;

    CommentsInserter(ParserConfiguration configuration) {

        this.configuration = configuration;

    }

    /**

     * Comments are attributed to the thing they comment and are removed from

     * the comments.

     */

    private void insertComments(CompilationUnit cu, TreeSet<Comment> comments) {

        if (comments.isEmpty())

            return;

        /* I should sort all the direct children and the comments, if a comment

         is the first thing then it is a comment to the CompilationUnit */

        // FIXME if there is no package it could be also a comment to the following class...

        // so I could use some heuristics in these cases to distinguish the two

        // cases

        List<Node> children = cu.getChildNodes();

        Comment firstComment = comments.iterator().next();

        if (cu.getPackageDeclaration().isPresent()

                && (children.isEmpty() || PositionUtils.areInOrder(

                firstComment, cu.getPackageDeclaration().get()))) {

            cu.setComment(firstComment);

            comments.remove(firstComment);

        }

    }

    /**

     * This method try to attributes the nodes received to child of the node. It

     * returns the node that were not attributed.

     */

    void insertComments(Node node, TreeSet<Comment> commentsToAttribute) {

        if (commentsToAttribute.isEmpty())

            return;

        if (node instanceof CompilationUnit) {

            insertComments((CompilationUnit) node, commentsToAttribute);

        }

        /* the comment can...

         1) be inside one of the children, then the comment should be associated to this child

         2) be outside all children. They could be preceding nothing, a comment or a child.

            If they preceed a child they are assigned to it, otherwise they remain "orphans"

         */

        List<Node> children = node.getChildNodes().stream()

                // Never attribute comments to modifiers.

                .filter(n -> !(n instanceof Modifier))

                .collect(toList());

        boolean attributeToAnnotation = !(configuration.isIgnoreAnnotationsWhenAttributingComments());

        for (Node child : children) {

            TreeSet<Comment> commentsInsideChild = new TreeSet<>(NODE_BY_BEGIN_POSITION);

            commentsInsideChild.addAll(

                    commentsToAttribute.stream()

                            .filter(comment -> comment.getRange().isPresent())

                            .filter(comment -> PositionUtils.nodeContains(child, comment, !attributeToAnnotation))

                            .collect(toList())

            );

            commentsToAttribute.removeAll(commentsInsideChild);

            insertComments(child, commentsInsideChild);

        }

        attributeLineCommentsOnSameLine(commentsToAttribute, children);

        /* if a comment is on the line right before a node it should belong

        to that node*/

        if (!commentsToAttribute.isEmpty()) {

            if (commentIsOnNextLine(node, commentsToAttribute.first())) {

                node.setComment(commentsToAttribute.first());

                commentsToAttribute.remove(commentsToAttribute.first());

            }

        }

        /* at this point I create an ordered list of all remaining comments and

         children */

        Comment previousComment = null;

        final List<Comment> attributedComments = new LinkedList<>();

        List<Node> childrenAndComments = new LinkedList<>();

        // Avoid attributing comments to a meaningless container.

        childrenAndComments.addAll(children);

        commentsToAttribute.removeAll(attributedComments);

        childrenAndComments.addAll(commentsToAttribute);

        PositionUtils.sortByBeginPosition(childrenAndComments,

                configuration.isIgnoreAnnotationsWhenAttributingComments());

        for (Node thing : childrenAndComments) {

            if (thing instanceof Comment) {

                previousComment = (Comment) thing;

                if (!previousComment.isOrphan()) {

                    previousComment = null;

                }

            } else {

                if (previousComment != null && !thing.getComment().isPresent()) {

                    if (!configuration.isDoNotAssignCommentsPrecedingEmptyLines()

                            || !thereAreLinesBetween(previousComment, thing)) {

                        thing.setComment(previousComment);

                        attributedComments.add(previousComment);

                        previousComment = null;

                    }

                }

            }

        }

        commentsToAttribute.removeAll(attributedComments);

        // all the remaining are orphan nodes

        for (Comment c : commentsToAttribute) {

            if (c.isOrphan()) {

                node.addOrphanComment(c);

            }

        }

    }

    private void attributeLineCommentsOnSameLine(TreeSet<Comment> commentsToAttribute, List<Node> children) {

        /* I can attribute in line comments to elements preceeding them, if

         there is something contained in their line */

        List<Comment> attributedComments = new LinkedList<>();

        commentsToAttribute.stream()

                .filter(comment -> comment.getRange().isPresent())

                .filter(Comment::isLineComment)

                .forEach(comment -> children.stream()

                        .filter(child -> child.getRange().isPresent())

                        .forEach(child -> {

                            Range commentRange = comment.getRange().get();

                            Range childRange = child.getRange().get();

                            if (childRange.end.line == commentRange.begin.line

                                    && attributeLineCommentToNodeOrChild(child,

                                    comment.asLineComment())) {

                                attributedComments.add(comment);

                            }

                        }));

        commentsToAttribute.removeAll(attributedComments);

    }

    private boolean attributeLineCommentToNodeOrChild(Node node, LineComment lineComment) {

        if (!node.getRange().isPresent() || !lineComment.getRange().isPresent()) {

            return false;

        }

        // The node start and end at the same line as the comment,

        // let's give to it the comment

        if (node.getBegin().get().line == lineComment.getBegin().get().line

                && !node.getComment().isPresent()) {

            if (!(node instanceof Comment)) {

                node.setComment(lineComment);

            }

            return true;

        } else {

            // try with all the children, sorted by reverse position (so the

            // first one is the nearest to the comment

            List<Node> children = new LinkedList<>();

            children.addAll(node.getChildNodes());

            PositionUtils.sortByBeginPosition(children);

            Collections.reverse(children);

            for (Node child : children) {

                if (attributeLineCommentToNodeOrChild(child, lineComment)) {

                    return true;

                }

            }

            return false;

        }

    }

    private boolean thereAreLinesBetween(Node a, Node b) {

        if (!a.getRange().isPresent() || !b.getRange().isPresent()) {

            return true;

        }

        if (!PositionUtils.areInOrder(a, b)) {

            return thereAreLinesBetween(b, a);

        }

        int endOfA = a.getEnd().get().line;

        return b.getBegin().get().line > endOfA + 1;

    }

    private boolean commentIsOnNextLine(Node a, Comment c) {

        if (!c.getRange().isPresent() || !a.getRange().isPresent()) return false;

        return c.getRange().get().end.line + 1 == a.getRange().get().begin.line;

    }

}