/*******************************************************************************
 * Copyright (c) 2021 Red Hat Inc. and others.
 *
 * This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License 2.0
 * which accompanies this distribution, and is available at
 * https://www.eclipse.org/legal/epl-2.0/
 *
 * SPDX-License-Identifier: EPL-2.0
 *
 * Contributors:
 *     Red Hat Inc. - initial API and implementation
 *******************************************************************************/
package org.eclipse.jdt.internal.corext.fix;

import java.util.ArrayList;
import java.util.List;
import java.util.function.Consumer;
import java.util.stream.Stream;

import org.eclipse.core.runtime.CoreException;

import org.eclipse.text.edits.TextEditGroup;

import org.eclipse.jdt.core.dom.ASTNode;
import org.eclipse.jdt.core.dom.ASTVisitor;
import org.eclipse.jdt.core.dom.ArrayType;
import org.eclipse.jdt.core.dom.Assignment;
import org.eclipse.jdt.core.dom.CompilationUnit;
import org.eclipse.jdt.core.dom.Expression;
import org.eclipse.jdt.core.dom.FieldDeclaration;
import org.eclipse.jdt.core.dom.ITypeBinding;
import org.eclipse.jdt.core.dom.InfixExpression;
import org.eclipse.jdt.core.dom.StringLiteral;
import org.eclipse.jdt.core.dom.TextBlock;
import org.eclipse.jdt.core.dom.Type;
import org.eclipse.jdt.core.dom.VariableDeclarationStatement;
import org.eclipse.jdt.core.dom.rewrite.ASTRewrite;
import org.eclipse.jdt.core.dom.rewrite.TargetSourceRangeComputer;
import org.eclipse.jdt.core.manipulation.ICleanUpFixCore;

import org.eclipse.jdt.internal.corext.dom.ASTNodes;
import org.eclipse.jdt.internal.corext.refactoring.structure.CompilationUnitRewrite;
import org.eclipse.jdt.internal.corext.util.JavaModelUtil;

import org.eclipse.jdt.internal.ui.fix.MultiFixMessages;

public class StringConcatToTextBlockFixCore extends CompilationUnitRewriteOperationsFixCore {

	private final static String JAVA_STRING= "java.lang.String"; //$NON-NLS-1$

	public static final class StringConcatFinder extends ASTVisitor {

		private final List<CompilationUnitRewriteOperation> fOperations;
		private final boolean fAllConcats;

		public StringConcatFinder(List<CompilationUnitRewriteOperation> operations, boolean allConcats) {
			super(true);
			fOperations= operations;
			fAllConcats= allConcats;
		}

		private boolean isStringType(Type type) {
			if (type instanceof ArrayType) {
				return false;
			}
			ITypeBinding typeBinding= type.resolveBinding();
			if (typeBinding == null || !typeBinding.getQualifiedName().equals(JAVA_STRING)) {
				return false;
			}
			return true;
		}

		@Override
		public boolean visit(final VariableDeclarationStatement visited) {
			Type type= visited.getType();
			if (!isStringType(type)) {
				return false;
			}
			return true;
		}

		@Override
		public boolean visit(final FieldDeclaration visited) {
			Type type= visited.getType();
			if (!isStringType(type)) {
				return false;
			}
			return true;
		}

		@Override
		public boolean visit(final Assignment visited) {
			ITypeBinding typeBinding= visited.resolveTypeBinding();
			if (!typeBinding.getQualifiedName().equals(JAVA_STRING)) {
				return false;
			}
			return true;
		}

		@Override
		public boolean visit(final InfixExpression visited) {
			if (visited.getOperator() != InfixExpression.Operator.PLUS
					|| visited.extendedOperands().isEmpty()) {
				return false;
			}
			ITypeBinding typeBinding= visited.resolveTypeBinding();
			if (typeBinding == null || !typeBinding.getQualifiedName().equals(JAVA_STRING)) {
				return false;
			}
			Expression leftHand= visited.getLeftOperand();
			if (!(leftHand instanceof StringLiteral)) {
				return false;
			}
			StringLiteral leftLiteral= (StringLiteral)leftHand;
			String literal= leftLiteral.getLiteralValue();
			if (!literal.isEmpty() && !fAllConcats && !literal.endsWith("\n")) { //$NON-NLS-1$
				return false;
			}
			Expression rightHand= visited.getRightOperand();
			if (!(rightHand instanceof StringLiteral)) {
				return false;
			}
			StringLiteral rightLiteral= (StringLiteral)leftHand;
			literal= rightLiteral.getLiteralValue();
			if (!literal.isEmpty() && !fAllConcats && !literal.endsWith("\n")) { //$NON-NLS-1$
				return false;
			}
			List<Expression> extendedOperands= visited.extendedOperands();
			if (extendedOperands.isEmpty()) {
				return false;
			}
			for (int i= 0; i < extendedOperands.size(); ++i) {
				Expression operand= extendedOperands.get(i);
				if (operand instanceof StringLiteral) {
					StringLiteral stringLiteral= (StringLiteral)operand;
					String string= stringLiteral.getLiteralValue();
					if (!string.isEmpty() && (fAllConcats || string.endsWith("\n") || i == extendedOperands.size() - 1)) { //$NON-NLS-1$
						continue;
					}
				}
				return false;
			}
			fOperations.add(new ChangeStringConcatToTextBlock(visited));
			return false;
		}
	}

	public static class ChangeStringConcatToTextBlock extends CompilationUnitRewriteOperation {

		private final InfixExpression fInfix;
		private final String fIndent;

		public ChangeStringConcatToTextBlock(final InfixExpression infix) {
			this.fInfix= infix;
			this.fIndent= "\t"; //$NON-NLS-1$
		}

		@Override
		public void rewriteAST(final CompilationUnitRewrite cuRewrite, final LinkedProposalModelCore linkedModel) throws CoreException {
			ASTRewrite rewrite= cuRewrite.getASTRewrite();
			TextEditGroup group= createTextEditGroup(MultiFixMessages.StringConcatToTextBlockCleanUp_description, cuRewrite);
			rewrite.setTargetSourceRangeComputer(new TargetSourceRangeComputer() {
				@Override
				public SourceRange computeSourceRange(final ASTNode nodeWithComment) {
					if (Boolean.TRUE.equals(nodeWithComment.getProperty(ASTNodes.UNTOUCH_COMMENT))) {
						return new SourceRange(nodeWithComment.getStartPosition(), nodeWithComment.getLength());
					}

					return super.computeSourceRange(nodeWithComment);
				}
			});

			StringBuilder buf= new StringBuilder();

			Stream<Expression> expressions= Stream.concat(Stream.of(fInfix.getLeftOperand(), fInfix.getRightOperand()), ((List<Expression>) fInfix.extendedOperands()).stream());

			List<String> parts= new ArrayList<>();

			expressions.forEach(new Consumer<Expression>() {
				@Override
				public void accept(Expression t) {
					String value= ((StringLiteral) t).getEscapedValue();
					parts.addAll(unescapeBlock(value.substring(1, value.length() - 1)));
				}
			});

			buf.append("\"\"\"\n"); //$NON-NLS-1$
			boolean newLine= false;
			for (String part : parts) {
				if (buf.length() > 4) {// the first part has been added after the text block delimiter and newline
					if (!newLine) {
						// no line terminator in this part: merge the line by emitting a line continuation escape
						buf.append("\\").append(System.lineSeparator()); //$NON-NLS-1$
					}
				}
				newLine= part.endsWith(System.lineSeparator());
				buf.append(fIndent).append(part);
			}

			if (newLine) {
				buf.append(fIndent);
			}
			buf.append("\"\"\""); //$NON-NLS-1$
			TextBlock textBlock= (TextBlock) rewrite.createStringPlaceholder(buf.toString(), ASTNode.TEXT_BLOCK);
			rewrite.replace(fInfix, textBlock, group);
		}

		/*
		 * Split a given string into parts of a text block. Transformations undertaken will be:
		 *
		 * 1. Split the text at newline boundaries. The newline will be replaced at the end
		 * of the first line being split with System.lineTerminator()
		 * 2. Transform any sequence of three or more double quotes in such that it's not interpreted as "end of text block"
		 * 3. Transform any trailing spaces into \s escapes
		 * 4. Transform any non-trailing \t characters into tab characters
		 */
		private List<String> unescapeBlock(String escapedText) {
			StringBuilder transformed= new StringBuilder();
			int readIndex= 0;
			int bsIndex= 0;

			List<String> parts= new ArrayList<>();

			while ((bsIndex= escapedText.indexOf("\\", readIndex)) >= 0) { //$NON-NLS-1$ "\"
				if (escapedText.startsWith("\\n", bsIndex)) { //$NON-NLS-1$ "\n"
					transformed.append(escapedText.substring(readIndex, bsIndex));
					parts.add(escapeTrailingWhitespace(transformed.toString())+ System.lineSeparator());
					transformed= new StringBuilder();
					readIndex= bsIndex + 2;
				} else if (escapedText.startsWith("\\\"", bsIndex)) { //$NON-NLS-1$ "\""
					// if there are more than three quotes in a row, escape the first quote of every triplet to
					// avoid it being interpreted as a text block terminator. This code would be much simpler if
					// we could escape the third quote of each triplet, but the text block spec recommends this way.

					transformed.append(escapedText.substring(readIndex, bsIndex));
					int quoteCount= 1;
					while (escapedText.startsWith("\\\"", bsIndex + 2 * quoteCount)) { //$NON-NLS-1$
						quoteCount++;
					}
					int i= 0;
					while (i < quoteCount / 3) {
						transformed.append("\\\"\"\""); //$NON-NLS-1$
						i++;
					}

					if (i > 0 && quoteCount % 3 != 0) {
						transformed.append("\\"); //$NON-NLS-1$
					}
					for (int j = 0; j < quoteCount % 3; j++) {
						transformed.append("\""); //$NON-NLS-1$
					}

					readIndex= bsIndex + 2 * quoteCount;
				} else if (escapedText.startsWith("\\t", bsIndex)) { //$NON-NLS-1$ "\t"
					transformed.append(escapedText.substring(readIndex, bsIndex));
					transformed.append("\t"); //$NON-NLS-1$
					readIndex= bsIndex+2;
				} else {
					transformed.append(escapedText.substring(readIndex, bsIndex));
					transformed.append("\\").append(escapedText.charAt(bsIndex + 1)); //$NON-NLS-1$
					readIndex= bsIndex + 2;
				}
			}
			if (readIndex < escapedText.length()) {
				// there is text at the end of the string that is not followed by a newline
				transformed.append(escapeTrailingWhitespace(escapedText.substring(readIndex)));
			}
			if (transformed.length() > 0) {
				parts.add(transformed.toString());
			}
			return parts;
		}

		/*
		 * Escape spaces and tabs at the end of a line, because they would be trimmed from a text block
		 */
		private static String escapeTrailingWhitespace(String unescaped) {
			if (unescaped.length() == 0) {
				return ""; //$NON-NLS-1$
			}
			int whitespaceStart= unescaped.length()-1;
			StringBuilder trailingWhitespace= new StringBuilder();
			while (whitespaceStart > 0) {
				if (unescaped.charAt(whitespaceStart) == ' ') {
					whitespaceStart--;
					trailingWhitespace.append("\\s"); //$NON-NLS-1$
				} else if (unescaped.charAt(whitespaceStart) == '\t') {
					whitespaceStart--;
					trailingWhitespace.append("\\t"); //$NON-NLS-1$
				} else {
					break;
				}
			}

			return unescaped.substring(0, whitespaceStart + 1) + trailingWhitespace;
		}
	}

	public static ICleanUpFixCore createCleanUp(final CompilationUnit compilationUnit) {
		if (!JavaModelUtil.is15OrHigher(compilationUnit.getJavaElement().getJavaProject()))
			return null;

		List<CompilationUnitRewriteOperation> operations= new ArrayList<>();

		StringConcatFinder finder= new StringConcatFinder(operations, true);
		compilationUnit.accept(finder);

		if (operations.isEmpty()) {
			return null;
		}

		CompilationUnitRewriteOperationsFixCore.CompilationUnitRewriteOperation[] ops= operations.toArray(new CompilationUnitRewriteOperationsFixCore.CompilationUnitRewriteOperation[0]);
		return new StringBufferToStringBuilderFixCore(FixMessages.StringConcatToTextBlockFix_convert_msg, compilationUnit, ops);
	}

	public static StringConcatToTextBlockFixCore createStringConcatToTextBlockFix(ASTNode exp) {
		CompilationUnit root= (CompilationUnit) exp.getRoot();
		if (!JavaModelUtil.is15OrHigher(root.getJavaElement().getJavaProject()))
			return null;
		List<CompilationUnitRewriteOperationsFixCore.CompilationUnitRewriteOperation> operations= new ArrayList<>();
		StringConcatFinder finder= new StringConcatFinder(operations, true);
		exp.accept(finder);
		if (operations.isEmpty())
			return null;
		return new StringConcatToTextBlockFixCore(FixMessages.StringConcatToTextBlockFix_convert_msg, root, new CompilationUnitRewriteOperationsFixCore.CompilationUnitRewriteOperation[] { operations.get(0) });
	}

	protected StringConcatToTextBlockFixCore(final String name, final CompilationUnit compilationUnit, final CompilationUnitRewriteOperationsFixCore.CompilationUnitRewriteOperation[] fixRewriteOperations) {
		super(name, compilationUnit, fixRewriteOperations);
	}

}