/*******************************************************************************
 * Copyright (c) 2005, 2016 IBM Corporation 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
 *
 *******************************************************************************/
package org.eclipse.dltk.ruby.core.tests.rewriter;

import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;

import org.eclipse.core.resources.IncrementalProjectBuilder;
import org.eclipse.core.resources.ResourcesPlugin;
import org.eclipse.core.runtime.NullProgressMonitor;
import org.eclipse.dltk.ast.declarations.ModuleDeclaration;
import org.eclipse.dltk.core.tests.model.AbstractModelTests;
import org.eclipse.dltk.ruby.core.tests.Activator;
import org.eclipse.dltk.ruby.internal.parsers.jruby.ASTUtils;

/**
 * @author mhowe
 * 
 * The tests in this test case are intended to test class def's, type ref's, method def's, method ref's, block's, variable def's, variable ref's, hash
 * expressions (very common in Ruby), expressions or statement. The tests don't go into detail for specific AST's, such as for, if etc. The intent here is to
 * define the common top level AST's required for a majority of work with a rewriter, such as fix ups, re-factorings, renames, insertions/removal of high level
 * elements at various points etc.
 * 
 * The tests are intended to exercise the ability to locate a specific AST (such as a block, method def, statement etc) and then modify that AST or insert a new
 * AST before or after the discovered AST. These are common use cases for modifying code from an AST perspective.
 * 
 * The first pass of this test case uses ModuleDeclaration as a starting point but this is for demonstration only, no restriction on the API is suggested by
 * this. ModuleDeclaration should be replaced with whatever is appropriate from the real API once created. These tests are fairly simple either using ruby files
 * defined in the associated workspace or if the test is simple enough from strings in the test itself. Also many of tests so far are just method stubs with
 * descriptive names to be filled in as the rewriter evolves. All tests require the rewriter API to be filled in. The checkResults method always fails, this
 * requires converting an AST to a string and then comparing with the expected result.
 * 
 * Once this stage of the rewriter is complete more test cases should be written which test the specific detailed AST's not covered by the tests in this test
 * case.
 */
public class RewriterTests extends AbstractModelTests {

	private static final String PATH_PREFIX = "/workspace/rewriter/";
	private static final String SRC_PROJECT = "rewriter";

	public RewriterTests(String name) {
		super(Activator.PLUGIN_ID, name);
	}

	@Override
	public void setUpSuite() throws Exception {
		setUpScriptProject(SRC_PROJECT);
		super.setUpSuite();
		waitUntilIndexesReady();
		ResourcesPlugin.getWorkspace().build(IncrementalProjectBuilder.FULL_BUILD, new NullProgressMonitor());
	}

	@Override
	public void tearDownSuite() throws Exception {
		deleteProject(SRC_PROJECT);
		super.tearDownSuite();
	}

	///////////////////////////////////////////////////////
	//Series of tests for adding various types of AST's
	///////////////////////////////////////////////////////

	/**
	 * Start with empty file and a header comment
	 * 
	 */
	public void testAddCommentToEmptyScript() throws IOException {
		String content = loadContent(PATH_PREFIX + "empty_script.rb");
		ModuleDeclaration ast = ASTUtils.getAST(content.toCharArray());

		//add header to to ast

		checkResults(ast, loadContent(PATH_PREFIX + "empty_script_with_header.rb"));
	}

	/**
	 * Start with empty file and add class declaration
	 * 
	 */
	public void testAddSimpleClassToEmptyScript() throws IOException {
		String content = loadContent(PATH_PREFIX + "empty_script.rb");
		ModuleDeclaration ast = ASTUtils.getAST(content.toCharArray());
		//modify ast
		//add class "Simple" after comment
		checkResults(ast, loadContent(PATH_PREFIX + "simple_class.rb"));
	}

	/**
	 * Start with empty file and add class declaration
	 * 
	 */
	public void testAddClassAfterHeader() throws IOException {
		String content = loadContent(PATH_PREFIX + "empty_script_with_header.rb");
		ModuleDeclaration ast = ASTUtils.getAST(content.toCharArray());
		//modify ast
		//add class "Simple" after comment
		checkResults(ast, loadContent(PATH_PREFIX + "simple_class_with_header.rb"));
	}

	/**
	 */
	public void testAddInnerClass() throws IOException {
		String content = loadContent(PATH_PREFIX + "simple_class.rb");
		ModuleDeclaration ast = ASTUtils.getAST(content.toCharArray());
		//modify ast
		//classAst.newClass("Inner");
		checkResults(ast, loadContent(PATH_PREFIX + "simple_nested_class.rb"));
	}

	/**
	 * Insert new method before first method
	 * 
	 * @throws IOException
	 */
	public void testInsertMethodBeforeFirstMethod() throws IOException {
		String content = loadContent(PATH_PREFIX + "simple1.rb");
		ModuleDeclaration ast = ASTUtils.getAST(content.toCharArray());
		//modify ast
		//insert new_method as first method
		checkResults(ast, loadContent(PATH_PREFIX + "simple1a.result"));
	}

	/**
	 * Insert method after specific method
	 * 
	 * @throws IOException
	 */
	public void testInsertMethodAfterMethod() throws IOException {
		String content = loadContent(PATH_PREFIX + "simple1.rb");
		ModuleDeclaration ast = ASTUtils.getAST(content.toCharArray());
		//modify ast
		//insert new_method after method m1
		checkResults(ast, loadContent(PATH_PREFIX + "simple1b.result"));
	}

	/**
	 * Insert method before specific method
	 * 
	 * @throws IOException
	 */
	public void testInsertMethodBeforeMethod() throws IOException {
		String content = loadContent(PATH_PREFIX + "simple1.rb");
		ModuleDeclaration ast = ASTUtils.getAST(content.toCharArray());
		//modify ast
		//insert new_method before method m2
		checkResults(ast, loadContent(PATH_PREFIX + "simple1b.result"));
	}

	/**
	 * Append method after last method
	 * 
	 * @throws IOException
	 */
	public void testAppendMethod() throws IOException {
		String content = loadContent(PATH_PREFIX + "simple1.rb");
		ModuleDeclaration ast = ASTUtils.getAST(content.toCharArray());
		//modify ast
		//append new_method after last method
		checkResults(ast, loadContent(PATH_PREFIX + "simple1c.result"));
	}

	/**
	 * Tests discovering a block and then inserting a method call as the first call in that block
	 */
	public void testInsertAsFirstMethodCallInBlock() {
		assertTrue(false);
	}

	/**
	 * Tests discovering a block and then inserting a method call as the last call in that block
	 */
	public void testInsertAsLastMethodCallInBlock() {
		assertTrue(false);
	}

	/**
	 * Tests discovering a method definition and then inserting a method call as the first call in that block
	 */
	public void testInsertAsFirstMethodCallInMethodDef() {
		assertTrue(false);
	}

	/**
	 * Tests discovering a method definition and then inserting a method call as the last call in that block
	 */
	public void testInsertAsLastMethodCallInMetohdDef() {
		assertTrue(false);
	}

	/**
	 * Tests discovering a specific statement and then inserting a method call before that statement
	 */
	public void testMethodCallBeforeStatement() {
		assertTrue(false);
	}

	/**
	 * Tests discovering a specific statement and then inserting a method call after that statement
	 */
	public void testMethodCallAfterStatement() {
		assertTrue(false);
	}

	/**
	 * Tests adding a key/value pair to a hash expression
	 */
	public void testAddKeyValuePairToHash() {
		assertTrue(false);
	}

	/**
	 * Tests inserting a new parameter as the first parameter to a method def
	 */
	public void testInsertFirstParameterToMethodDef() {
		assertTrue(false);
	}

	/**
	 * Tests inserting a new parameter as the last parameter to a method def
	 */
	public void testInsertLastParameterToMethodDef() {
		assertTrue(false);
	}

	/**
	 * Tests inserting a before a block in a method def
	 */
	public void testInsertBeforeBlockInMethodDef() {
		assertTrue(false);
	}

	/**
	 * Tests inserting a parameter as a specific parameter in a method def, i.e. test adding a parameter between parameter 0 and parameter 1
	 */
	public void testInsertParameterInSpecificPosInMethodDef() {
		assertTrue(false);
	}

	/**
	 * Tests inserting a parameter as the first parameter in a method call
	 */
	public void testInsertFirstParameterToMethodCall() {
		assertTrue(false);
	}

	/**
	 * Tests inserting a parameter as the last parameter in a method call
	 */
	public void testInsertLastParameterToMethodCall() {
		assertTrue(false);
	}

	/**
	 * Tests inserting a parameter before the block in a method call (similar to appending a parameter as the last parameter but specifically tests the case where
	 * a block is used)
	 */
	public void testInsertBeforeBlockInMethodCall() {
		assertTrue(false);
	}

	/**
	 * Tests inserting a parameter as a specific parameter in a method call, i.e. test adding a parameter between parameter 0 and parameter 1
	 */
	public void testInsertParameterInSpecificPosInMethodCall() {
		assertTrue(false);
	}

	///////////////////////////////////////////////////////
	//Series of tests for modifying references
	///////////////////////////////////////////////////////
	/**
	 * Change variable reference
	 */
	public void testChangeClassVariableReference() {
		String content = "@@class_var = 'hello'";
		ModuleDeclaration ast = ASTUtils.getAST(content.toCharArray());
		//change @var to @new_var
		checkResults(ast, "@@new_class_var = 'hello')");
	}

	/**
	 * Change variable reference
	 */
	public void testChangeInstanceVariableReference() {
		String content = "puts(@instance_var = 'hello')";
		ModuleDeclaration ast = ASTUtils.getAST(content.toCharArray());
		//change @var to @new_var
		checkResults(ast, "puts(@new_instance_var = 'hello')");
	}

	/**
	 * Change variable reference
	 */
	public void testChangeVariableReference() {
		String content = "puts(var = 'hello')";
		ModuleDeclaration ast = ASTUtils.getAST(content.toCharArray());
		//change @var to @new_var
		checkResults(ast, "puts(new_var = 'hello')");
	}

	/**
	 * Change type reference
	 */
	public void testChangeTypeReference() {
		String content = "@var = Stringx.new";
		ModuleDeclaration ast = ASTUtils.getAST(content.toCharArray());
		//change type reference Stringx to String 
		checkResults(ast, "@var = String.new");
	}

	/**
	 * Change method reference
	 */
	public void testChangeMethodReference() {
		String content = "@var = String.newx";
		ModuleDeclaration ast = ASTUtils.getAST(content.toCharArray());
		//change method reference newx to new
		checkResults(ast, "@var = String.new");
	}

	/**
	 * Tests changing a symbol reference
	 */
	public void testChangeSymbolReference() {
		String content = "var = :my_symbol";
		ModuleDeclaration ast = ASTUtils.getAST(content.toCharArray());
		//change symbol ref from :my_symbol to :your_symbol
		checkResults(ast, "var = :your_symbol");
	}

	/**
	 * Tests changing a string literal reference
	 */
	public void testChangeStringLiteral() {
		String content = "var = 'my_string'";
		ModuleDeclaration ast = ASTUtils.getAST(content.toCharArray());
		//modify ast
		checkResults(ast, "var = 'your_string'");
	}

	//TODO
	public void testChangeNumericLiteral() {
		String content = "var = 123";
		ModuleDeclaration ast = ASTUtils.getAST(content.toCharArray());
		//modify ast
		checkResults(ast, "var = 4567");
	}

	/**
	 * Test adding parenthesis around a method call (tests finding all the parameters to a call)
	 */
	public void testAddParenthesisAroundMethodCall() {
		assertTrue(false);
	}

	///////////////////////////////////////////////////////
	//Series of tests for modifying whitespace and delimeters
	///////////////////////////////////////////////////////
	public void testRemoveLeadingWhiteSpace() {
		assertTrue(false);
	}

	public void testRemoveTrailingWhiteSpace() {
		assertTrue(false);
	}

	public void testModifyLeadingWhiteSpace() {
		assertTrue(false);
	}

	public void testModifyTrailingWhiteSpace() {
		assertTrue(false);
	}

	public void testCovertBlockFromBraceToDoEnd() {
		assertTrue(false);
	}

	public void testConvertBlockFromDoEndToBrace() {
		assertTrue(false);
	}

	///////////////////////////////////////////////////////
	//Series of tests for removing various types of AST's
	///////////////////////////////////////////////////////

	/**
	 * Tests discovering and removing a class
	 */
	public void testRemoveClass() {
		assertTrue(false);
	}

	/**
	 * Tests discovering and removing a method def
	 */
	public void testRemoveMethodDef() {
		assertTrue(false);
	}

	/**
	 * Tests discovering and removing a block
	 */
	public void testRemoveBlock() {
		assertTrue(false);
	}

	/**
	 * Tests discovering and removing a statement
	 */
	public void testRemoveStatement() {
		assertTrue(false);
	}

	/**
	 * Tests discovering and removing a parameter from a method call
	 */
	public void testRemoveParameterFromMethodCall() {
		assertTrue(false);
	}

	/**
	 * Tests discovering and removing a parameter from a method def
	 */
	public void testRemoveParameterFromMethodDef() {
		assertTrue(false);
	}

	/**
	 * Tests discovering and removing a hash parameter from a method call
	 */
	public void testRemoveHashParameterFromMethodCall() {
		assertTrue(false);
	}

	//This assumes some way of resolving the formatted text from an AST
	private void checkResults(ModuleDeclaration ast, String contents) {
		assertTrue(false);
	}

	private String loadContent(String path) throws IOException {
		StringBuffer buffer = new StringBuffer();
		try (InputStream input = Activator.openResource(path);) {
			InputStreamReader reader = new InputStreamReader(input);

			char[] cbuf = new char[1024 * 16];
			while (reader.ready() == true) {
				int read = reader.read(cbuf);
				buffer.append(cbuf, 0, read);
			}
		}
		String content = buffer.toString();
		return content;
	}

}