/*******************************************************************************
 * Copyright (c) 2008, 2017 xored software, Inc. and others.
 *
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     xored software, Inc. - initial API and Implementation (Alex Panchenko)
 *******************************************************************************/
package org.eclipse.dltk.ruby.formatter.internal;

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.Iterator;
import java.util.List;

import org.eclipse.dltk.formatter.AbstractFormatterNodeBuilder;
import org.eclipse.dltk.formatter.IFormatterContainerNode;
import org.eclipse.dltk.formatter.IFormatterDocument;
import org.eclipse.dltk.formatter.IFormatterTextNode;
import org.eclipse.dltk.ruby.core.RubyConstants;
import org.eclipse.dltk.ruby.formatter.internal.nodes.FormatterArrayNode;
import org.eclipse.dltk.ruby.formatter.internal.nodes.FormatterAtBeginNode;
import org.eclipse.dltk.ruby.formatter.internal.nodes.FormatterAtEndNode;
import org.eclipse.dltk.ruby.formatter.internal.nodes.FormatterBeginNode;
import org.eclipse.dltk.ruby.formatter.internal.nodes.FormatterCaseNode;
import org.eclipse.dltk.ruby.formatter.internal.nodes.FormatterClassNode;
import org.eclipse.dltk.ruby.formatter.internal.nodes.FormatterDoNode;
import org.eclipse.dltk.ruby.formatter.internal.nodes.FormatterElseIfNode;
import org.eclipse.dltk.ruby.formatter.internal.nodes.FormatterEnsureNode;
import org.eclipse.dltk.ruby.formatter.internal.nodes.FormatterForNode;
import org.eclipse.dltk.ruby.formatter.internal.nodes.FormatterHashNode;
import org.eclipse.dltk.ruby.formatter.internal.nodes.FormatterHereDocNode;
import org.eclipse.dltk.ruby.formatter.internal.nodes.FormatterIfElseNode;
import org.eclipse.dltk.ruby.formatter.internal.nodes.FormatterIfEndNode;
import org.eclipse.dltk.ruby.formatter.internal.nodes.FormatterIfNode;
import org.eclipse.dltk.ruby.formatter.internal.nodes.FormatterMethodNode;
import org.eclipse.dltk.ruby.formatter.internal.nodes.FormatterModifierNode;
import org.eclipse.dltk.ruby.formatter.internal.nodes.FormatterModuleNode;
import org.eclipse.dltk.ruby.formatter.internal.nodes.FormatterRDocNode;
import org.eclipse.dltk.ruby.formatter.internal.nodes.FormatterRequireNode;
import org.eclipse.dltk.ruby.formatter.internal.nodes.FormatterRescueElseNode;
import org.eclipse.dltk.ruby.formatter.internal.nodes.FormatterRescueNode;
import org.eclipse.dltk.ruby.formatter.internal.nodes.FormatterRootNode;
import org.eclipse.dltk.ruby.formatter.internal.nodes.FormatterStringNode;
import org.eclipse.dltk.ruby.formatter.internal.nodes.FormatterUntilNode;
import org.eclipse.dltk.ruby.formatter.internal.nodes.FormatterWhenElseNode;
import org.eclipse.dltk.ruby.formatter.internal.nodes.FormatterWhenNode;
import org.eclipse.dltk.ruby.formatter.internal.nodes.FormatterWhileNode;
import org.eclipse.jface.text.IRegion;
import org.eclipse.jface.text.Region;
import org.eclipse.osgi.util.NLS;
import org.jruby.ast.ArgumentNode;
import org.jruby.ast.ArrayNode;
import org.jruby.ast.BeginNode;
import org.jruby.ast.CaseNode;
import org.jruby.ast.ClassNode;
import org.jruby.ast.CommentNode;
import org.jruby.ast.DRegexpNode;
import org.jruby.ast.DStrNode;
import org.jruby.ast.DefnNode;
import org.jruby.ast.DefsNode;
import org.jruby.ast.EnsureNode;
import org.jruby.ast.FCallNode;
import org.jruby.ast.ForNode;
import org.jruby.ast.HashNode;
import org.jruby.ast.IfNode;
import org.jruby.ast.IterNode;
import org.jruby.ast.ListNode;
import org.jruby.ast.MethodDefNode;
import org.jruby.ast.ModuleNode;
import org.jruby.ast.Node;
import org.jruby.ast.PostExeNode;
import org.jruby.ast.RegexpNode;
import org.jruby.ast.RescueBodyNode;
import org.jruby.ast.RescueNode;
import org.jruby.ast.SClassNode;
import org.jruby.ast.StrNode;
import org.jruby.ast.UntilNode;
import org.jruby.ast.WhenNode;
import org.jruby.ast.WhileNode;
import org.jruby.ast.XStrNode;
import org.jruby.ast.ext.ElseNode;
import org.jruby.ast.ext.HeredocNode;
import org.jruby.ast.ext.PreExeNode;
import org.jruby.ast.visitor.AbstractVisitor;
import org.jruby.evaluator.Instruction;
import org.jruby.lexer.yacc.ISourcePosition;
import org.jruby.lexer.yacc.ISourcePositionHolder;
import org.jruby.parser.RubyParserResult;

public class RubyFormatterNodeBuilder extends AbstractFormatterNodeBuilder {

	public IFormatterContainerNode build(RubyParserResult result,
			final IFormatterDocument document) {
		final IFormatterContainerNode root = new FormatterRootNode(document);
		start(root);
		result.getAST().accept(new AbstractVisitor() {

			@Override
			protected Instruction visitNode(Node visited) {
				visitChildren(visited);
				return null;
			}

			@Override
			public Instruction visitClassNode(ClassNode visited) {
				FormatterClassNode classNode = new FormatterClassNode(document);
				classNode.setBegin(createTextNode(document, visited
						.getClassKeyword()));
				push(classNode);
				visitChildren(visited);
				checkedPop(classNode, visited.getEnd().getPosition()
						.getStartOffset());
				classNode.setEnd(createTextNode(document, visited.getEnd()));
				return null;
			}

			@Override
			public Instruction visitSClassNode(SClassNode visited) {
				FormatterClassNode classNode = new FormatterClassNode(document);
				classNode.setBegin(createTextNode(document, visited
						.getClassKeyword()));
				push(classNode);
				visitChildren(visited);
				checkedPop(classNode, visited.getEnd().getPosition()
						.getStartOffset());
				classNode.setEnd(createTextNode(document, visited.getEnd()));
				return null;
			}

			@Override
			public Instruction visitModuleNode(ModuleNode visited) {
				FormatterModuleNode moduleNode = new FormatterModuleNode(
						document);
				moduleNode.setBegin(createTextNode(document, visited
						.getKeyword()));
				push(moduleNode);
				visitChildren(visited);
				checkedPop(moduleNode, visited.getEnd().getPosition()
						.getStartOffset());
				moduleNode.setEnd(createTextNode(document, visited.getEnd()));
				return null;
			}

			@Override
			public Instruction visitDefnNode(DefnNode visited) {
				return visitMethodDefNode(visited);
			}

			@Override
			public Instruction visitDefsNode(DefsNode visited) {
				return visitMethodDefNode(visited);
			}

			private Instruction visitMethodDefNode(MethodDefNode visited) {
				FormatterMethodNode methodNode = new FormatterMethodNode(
						document);
				methodNode
						.setBegin(createTextNode(document, visited
								.getStartOffset(), visited.getNameNode()
								.getEndOffset()));
				push(methodNode);
				visitChildren(visited);
				checkedPop(methodNode, visited.getEnd().getPosition()
						.getStartOffset());
				methodNode.setEnd(createTextNode(document, visited.getEnd()));
				return null;
			}

			@Override
			public Instruction visitWhileNode(WhileNode visited) {
				if (!visited.isBlock()) {
					visitChildren(visited);
					return null;
				}
				FormatterWhileNode whileNode = new FormatterWhileNode(document);
				whileNode.setBegin(createTextNode(document, visited
						.getKeyword()));
				push(whileNode);
				visitChildren(visited);
				checkedPop(whileNode, visited.getEnd().getPosition()
						.getStartOffset());
				whileNode.setEnd(createTextNode(document, visited.getEnd()));
				return null;
			}

			@Override
			public Instruction visitIterNode(IterNode visited) {
				FormatterDoNode forNode = new FormatterDoNode(document);
				forNode.setBegin(createTextNode(document, visited.getBegin()));
				push(forNode);
				visitChildren(visited);
				checkedPop(forNode, visited.getEnd().getPosition()
						.getStartOffset());
				forNode.setEnd(createTextNode(document, visited.getEnd()));
				return null;
			}

			@Override
			public Instruction visitForNode(ForNode visited) {
				FormatterForNode forNode = new FormatterForNode(document);
				forNode.setBegin(createTextNode(document, visited.getBegin()));
				push(forNode);
				visitChildren(visited);
				checkedPop(forNode, visited.getEnd().getPosition()
						.getStartOffset());
				forNode.setEnd(createTextNode(document, visited.getEnd()));
				return null;
			}

			@Override
			public Instruction visitUntilNode(UntilNode visited) {
				if (!visited.isBlock()) {
					visitChild(visited.getBodyNode());
					FormatterModifierNode block = new FormatterModifierNode(
							document);
					block.addChild(createTextNode(document, visited
							.getKeyword()));
					push(block);
					visitChild(visited.getConditionNode());
					checkedPop(block, visited.getConditionNode().getEndOffset());
					return null;
				}
				FormatterUntilNode untilNode = new FormatterUntilNode(document);
				untilNode.setBegin(createTextNode(document, visited
						.getKeyword()));
				push(untilNode);
				visitChildren(visited);
				checkedPop(untilNode, visited.getEnd().getPosition()
						.getStartOffset());
				untilNode.setEnd(createTextNode(document, visited.getEnd()));
				return null;
			}

			@Override
			public Instruction visitCaseNode(CaseNode visited) {
				FormatterCaseNode caseNode = new FormatterCaseNode(document);
				final int caseEnd = visited.getCaseKeyword().getPosition()
						.getEndOffset();
				caseNode.setBegin(createTextNode(document, visited
						.getStartOffset(), caseEnd));
				push(caseNode);
				Node branch = visited.getFirstWhenNode();
				while (branch != null) {
					if (branch instanceof WhenNode) {
						WhenNode whenBranch = (WhenNode) branch;
						FormatterWhenNode whenNode = new FormatterWhenNode(
								document);
						whenNode.setBegin(createTextNode(document, branch
								.getStartOffset(), whenBranch
								.getExpressionNodes().getEndOffset()));
						push(whenNode);
						visitChild(whenBranch.getBodyNode());
						branch = ((WhenNode) branch).getNextCase();
						checkedPop(whenNode, branch != null ? branch
								.getStartOffset() : visited.getEnd()
								.getPosition().getStartOffset());
					} else if (branch instanceof ElseNode) {
						ElseNode elseBranch = (ElseNode) branch;
						FormatterWhenElseNode whenElseNode = new FormatterWhenElseNode(
								document);
						whenElseNode.setBegin(createTextNode(document,
								elseBranch.getStartOffset(), elseBranch
										.getElseKeyword().getPosition()
										.getEndOffset()));
						push(whenElseNode);
						visitChild(elseBranch.getStatement());
						checkedPop(whenElseNode, visited.getEnd().getPosition()
								.getStartOffset());
						branch = null;
					} else {
						RubyFormatterPlugin.warn(NLS.bind(
								Messages.RubyFormatterNodeBuilder_unexpectedClassInCaseWhenExpression,
								branch.getClass().getName()),
								new DumpStackOnly());
						break;
					}
				}
				checkedPop(caseNode, visited.getEnd().getPosition()
						.getStartOffset());
				caseNode.setEnd(createTextNode(document, visited.getEnd()));
				return null;
			}

			@Override
			public Instruction visitCommentNode(CommentNode visited) {
				FormatterRDocNode commentNode = new FormatterRDocNode(document,
						visited.getStartOffset(), visited.getEndOffset());
				addChild(commentNode);
				return null;
			}

			@Override
			public Instruction visitIfNode(IfNode visited) {
				if (visited.isInline()) {
					List<Node> children = new ArrayList<Node>(3);
					if (visited.getThenBody() != null) {
						children.add(visited.getThenBody());
					}
					if (visited.getElseBody() != null) {
						children.add(visited.getElseBody());
					}
					if (visited.getCondition() != null) {
						children.add(visited.getCondition());
					}
					if (!children.isEmpty()) {
						Collections.sort(children, POSITION_COMPARATOR);
						visitChildren(children);
					}
					return null;
				}
				FormatterIfNode ifNode = new FormatterIfNode(document);
				ifNode.setBegin(createTextNode(document, visited
						.getStartOffset(), visited.getCondition()
						.getEndOffset()));
				push(ifNode);
				visitChild(visited.getFirstBody());
				checkedPop(ifNode, visited.getSecondBody() != null ? visited
						.getSecondBody().getStartOffset() : visited
						.getEndKeyword().getPosition().getStartOffset());
				Node branch = visited.getSecondBody();
				while (branch != null) {
					if (branch instanceof IfNode.ElseIf) {
						final IfNode.ElseIf elseIfBranch = (IfNode.ElseIf) branch;
						FormatterElseIfNode elseIfNode = new FormatterElseIfNode(
								document);
						elseIfNode.setBegin(createTextNode(document,
								elseIfBranch.getStartOffset(), elseIfBranch
										.getCondition().getEndOffset()));
						push(elseIfNode);
						visitChild(elseIfBranch.getFirstBody());
						branch = ((IfNode.ElseIf) branch).getSecondBody();
						checkedPop(elseIfNode, branch != null ? branch
								.getStartOffset() : visited.getEndKeyword()
								.getPosition().getStartOffset());
					} else if (branch instanceof ElseNode) {
						final ElseNode elseBranch = (ElseNode) branch;
						FormatterIfElseNode elseNode = new FormatterIfElseNode(
								document);
						elseNode.setBegin(createTextNode(document, elseBranch
								.getElseKeyword()));
						push(elseNode);
						visitChild(elseBranch.getStatement());
						checkedPop(elseNode, visited.getEndKeyword()
								.getPosition().getStartOffset());
						branch = null;
					} else {
						RubyFormatterPlugin.warn(NLS.bind(
								Messages.RubyFormatterNodeBuilder_unexpectedClassInIfExpression, branch
										.getClass().getName()),
								new DumpStackOnly());
						break;
					}
				}
				addChild(new FormatterIfEndNode(document, visited
						.getEndKeyword().getPosition()));
				return null;
			}

			@Override
			public Instruction visitBeginNode(BeginNode visited) {
				FormatterBeginNode beginNode = new FormatterBeginNode(document);
				beginNode.setBegin(createTextNode(document, visited
						.getBeginKeyword()));
				push(beginNode);
				visitChild(visited.getBodyNode());
				checkedPop(beginNode, visited.getEndKeyword().getPosition()
						.getStartOffset());
				beginNode.setEnd(createTextNode(document, visited
						.getEndKeyword()));
				return null;
			}

			@Override
			public Instruction visitRescueNode(RescueNode visited) {
				if (visited.isInline()) {
					return null;
				}
				visitChild(visited.getBodyNode());
				RescueBodyNode node = visited.getRescueNode();
				while (node != null) {
					FormatterRescueNode rescueNode = new FormatterRescueNode(
							document);
					rescueNode.setBegin(createTextNode(document, node
							.getRescueKeyword().getPosition().getStartOffset(),
							node.getExceptionNodes() != null ? node
									.getExceptionNodes().getEndOffset() : node
									.getRescueKeyword().getPosition()
									.getEndOffset()));
					push(rescueNode);
					visitChild(node.getBodyNode());
					node = node.getOptRescueNode();
					final int rescueEnd;
					if (node != null) {
						rescueEnd = node.getStartOffset();
					} else if (visited.getElseNode() != null) {
						rescueEnd = visited.getElseNode().getStartOffset();
					} else {
						rescueEnd = -1;
					}
					checkedPop(rescueNode, rescueEnd);
				}
				if (visited.getElseNode() != null) {
					final ElseNode elseBranch = (ElseNode) visited
							.getElseNode();
					FormatterRescueElseNode elseNode = new FormatterRescueElseNode(
							document);
					elseNode.setBegin(createTextNode(document, elseBranch
							.getElseKeyword()));
					push(elseNode);
					visitChild(elseBranch.getStatement());
					checkedPop(elseNode, -1);
				}
				return null;
			}

			@Override
			public Instruction visitEnsureNode(EnsureNode visited) {
				visitChild(visited.getBodyNode());
				FormatterEnsureNode ensureNode = new FormatterEnsureNode(
						document);
				ensureNode.setBegin(createTextNode(document, visited
						.getEnsureNode().getKeyword()));
				push(ensureNode);
				visitChild(visited.getEnsureNode().getStatement());
				checkedPop(ensureNode, -1);
				return null;
			}

			@Override
			public Instruction visitPreExeNode(PreExeNode visited) {
				FormatterAtBeginNode endNode = new FormatterAtBeginNode(
						document);
				endNode.setBegin(createTextNode(document, visited.getKeyword()
						.getPosition().getStartOffset(), visited.getLeftBrace()
						.getPosition().getEndOffset()));
				push(endNode);
				visitChildren(visited);
				checkedPop(endNode, visited.getRightBrace().getPosition()
						.getStartOffset());
				endNode
						.setEnd(createTextNode(document, visited
								.getRightBrace()));
				return null;
			}

			@Override
			public Instruction visitPostExeNode(PostExeNode visited) {
				FormatterAtEndNode endNode = new FormatterAtEndNode(document);
				endNode.setBegin(createTextNode(document, visited
						.getEndKeyword().getPosition().getStartOffset(),
						visited.getLeftBrace().getPosition().getEndOffset()));
				push(endNode);
				visitChildren(visited);
				checkedPop(endNode, visited.getRightBrace().getPosition()
						.getStartOffset());
				endNode
						.setEnd(createTextNode(document, visited
								.getRightBrace()));
				return null;
			}

			@Override
			public Instruction visitStrNode(StrNode visited) {
				FormatterStringNode strNode = new FormatterStringNode(document,
						visited.getStartOffset(), visited.getEndOffset());
				addChild(strNode);
				return null;
			}

			@Override
			public Instruction visitDStrNode(DStrNode visited) {
				FormatterStringNode strNode = new FormatterStringNode(document,
						visited.getStartOffset(), visited.getEndOffset());
				addChild(strNode);
				return null;
			}

			@Override
			public Instruction visitRegexpNode(RegexpNode visited) {
				FormatterStringNode strNode = new FormatterStringNode(document,
						visited.getStartOffset(), visited.getEndOffset());
				addChild(strNode);
				return null;
			}

			@Override
			public Instruction visitDRegxNode(DRegexpNode visited) {
				FormatterStringNode strNode = new FormatterStringNode(document,
						visited.getStartOffset(), visited.getEndOffset());
				addChild(strNode);
				return null;
			}

			@Override
			public Instruction visitXStrNode(XStrNode visited) {
				FormatterStringNode strNode = new FormatterStringNode(document,
						visited.getStartOffset(), visited.getEndOffset());
				addChild(strNode);
				return null;
			}

			@Override
			public Instruction visitHeredocNode(HeredocNode visited) {
				FormatterHereDocNode heredocNode = new FormatterHereDocNode(
						document, visited.getStartOffset(), visited
								.getEndOffset(), visited.isIndent());
				addChild(heredocNode);
				heredocNode.setContentRegion(createRegion(visited.getContent()
						.getPosition()));
				heredocNode.setEndMarkerRegion(createRegion(visited
						.getEndMarker().getPosition()));
				return null;
			}

			@Override
			public Instruction visitFCallNode(FCallNode visited) {
				if (isRequireMethod(visited)) {
					FormatterRequireNode requireNode = new FormatterRequireNode(
							document, visited.getStartOffset(), visited
									.getEndOffset());
					addChild(requireNode);
					return null;
				} else {
					return super.visitFCallNode(visited);
				}
			}

			@Override
			public Instruction visitArrayNode(ArrayNode visited) {
				if (visited.getLeftBracketPosition() != null
						&& visited.getRightBracketPosition() != null) {
					final FormatterArrayNode arrayNode = new FormatterArrayNode(
							document);
					arrayNode.setBegin(createTextNode(document, visited
							.getLeftBracketPosition()));
					push(arrayNode);
					final ISourcePosition right = visited
							.getRightBracketPosition().getPosition();
					checkedPop(arrayNode, right.getStartOffset());
					arrayNode.setEnd(createTextNode(document, right));
					return null;
				} else {
					return super.visitArrayNode(visited);
				}
			}

			@Override
			public Instruction visitHashNode(HashNode visited) {
				if (visited.getLeftBrace() != null
						&& visited.getRightBrace() != null) {
					final FormatterHashNode hashNode = new FormatterHashNode(
							document);
					hashNode.setBegin(createTextNode(document, visited
							.getLeftBrace()));
					push(hashNode);
					final ISourcePosition right = visited.getRightBrace()
							.getPosition();
					checkedPop(hashNode, right.getStartOffset());
					hashNode.setEnd(createTextNode(document, right));
					return null;
				} else {
					return super.visitHashNode(visited);
				}
			}

			private boolean isRequireMethod(FCallNode call) {
				if (RubyConstants.REQUIRE.equals(call.getName())) {
					if (call.getArgsNode() instanceof ArrayNode) {
						return true;
					}
				}
				return false;
			}

			private void visitChildren(Node visited) {
				final List<Node> children = visited.childNodes();
				if (!children.isEmpty()) {
					visitChildren(children);
				}
			}

			private void visitChildren(List<Node> children) {
				for (Iterator<Node> i = children.iterator(); i.hasNext();) {
					final Node child = i.next();
					visitChild(child);
				}
			}

			private void visitChild(final Node child) {
				if (child != null && isVisitable(child)) {
					child.accept(this);
				}
			}

			private boolean isVisitable(Node node) {
				return !(node instanceof ArgumentNode)
						&& node.getClass() != ListNode.class;
			}

		});
		checkedPop(root, document.getLength());
		return root;
	}

	/**
	 * @param holder
	 * @return
	 */
	private IFormatterTextNode createTextNode(IFormatterDocument document,
			ISourcePositionHolder holder) {
		return createTextNode(document, holder.getPosition());
	}

	/**
	 * @param position
	 * @return
	 */
	private IFormatterTextNode createTextNode(IFormatterDocument document,
			ISourcePosition position) {
		return createTextNode(document, position.getStartOffset(), position
				.getEndOffset());
	}

	private static IRegion createRegion(ISourcePosition position) {
		return new Region(position.getStartOffset(), position.getEndOffset()
				- position.getStartOffset());
	}

	protected static final Comparator<Node> POSITION_COMPARATOR = (node1, node2) -> node1.getStartOffset()
			- node2.getStartOffset();

}