/**********************************************************************
 * This file is part of "Object Teams Development Tooling"-Software
 *
 * Copyright 2004, 2013 Fraunhofer Gesellschaft, Munich, Germany,
 * for its Fraunhofer Institute and Computer Architecture and Software
 * Technology (FIRST), Berlin, Germany and Technical University Berlin,
 * Germany.
 *
 * 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
 *
 * Please visit http://www.eclipse.org/objectteams for updates and contact.
 *
 * Contributors:
 * 	  Fraunhofer FIRST - Initial API and implementation
 * 	  Technical University Berlin - Initial API and implementation
 **********************************************************************/
package org.eclipse.objectteams.otdt.ui.tests.refactoring;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.StringBufferInputStream;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
import java.util.Set;

import junit.framework.TestCase;

import org.eclipse.core.resources.IFile;
import org.eclipse.core.resources.IResource;
import org.eclipse.core.resources.ResourcesPlugin;
import org.eclipse.core.runtime.Assert;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.NullProgressMonitor;
import org.eclipse.jdt.core.ICompilationUnit;
import org.eclipse.jdt.core.IField;
import org.eclipse.jdt.core.IJavaElement;
import org.eclipse.jdt.core.IJavaProject;
import org.eclipse.jdt.core.IMember;
import org.eclipse.jdt.core.IMethod;
import org.eclipse.jdt.core.IPackageFragment;
import org.eclipse.jdt.core.IPackageFragmentRoot;
import org.eclipse.jdt.core.ISourceManipulation;
import org.eclipse.jdt.core.IType;
import org.eclipse.jdt.core.JavaModelException;
import org.eclipse.jdt.core.search.IJavaSearchConstants;
import org.eclipse.jdt.core.search.ITypeNameRequestor;
import org.eclipse.jdt.core.search.SearchEngine;
import org.eclipse.jdt.core.search.SearchPattern;
import org.eclipse.jdt.internal.corext.refactoring.util.JavaElementUtil;
import org.eclipse.jdt.internal.corext.util.Strings;
import org.eclipse.ltk.core.refactoring.Change;
import org.eclipse.ltk.core.refactoring.CheckConditionsOperation;
import org.eclipse.ltk.core.refactoring.CreateChangeOperation;
import org.eclipse.ltk.core.refactoring.IUndoManager;
import org.eclipse.ltk.core.refactoring.PerformChangeOperation;
import org.eclipse.ltk.core.refactoring.Refactoring;
import org.eclipse.ltk.core.refactoring.RefactoringCore;
import org.eclipse.ltk.core.refactoring.RefactoringDescriptor;
import org.eclipse.ltk.core.refactoring.RefactoringStatus;
import org.eclipse.objectteams.otdt.core.IOTJavaElement;
import org.eclipse.objectteams.otdt.internal.core.AbstractCalloutMapping;

@SuppressWarnings("restriction")
public abstract class RefactoringTest extends TestCase
{
    private IPackageFragmentRoot _root;
    private IPackageFragment _packageP;

    public boolean _isVerbose = false;

    public static final String TEST_PATH_PREFIX = "";

    protected static final String TEST_INPUT_INFIX = "/in/";
    protected static final String TEST_OUTPUT_INFIX = "/out/";
    protected static final String CONTAINER = "src";

    public RefactoringTest(String name)
    {
        super(name);
    }

    protected void setUp() throws Exception
    {
        _root = MySetup.getDefaultSourceFolder();
        _packageP = MySetup.getPackageP();

        if (_isVerbose)
        {
            System.out
                    .println("\n---------------------------------------------");
            System.out.println("\nTest:" + getClass() + "." + getName());
        }
        RefactoringCore.getUndoManager().flush();
    }

    protected void tearDown() throws Exception
    {
        refreshFromLocal();
        performDummySearch();

        if (getPackageP().exists())
        {
            tryDeletingAllJavaChildren(getPackageP());
            tryDeletingAllNonJavaChildResources(getPackageP());
        }

        if (getRoot().exists())
        {
            IJavaElement[] packages = getRoot().getChildren();
            for (int i = 0; i < packages.length; i++)
            {
                try
                {
                    IPackageFragment pack = (IPackageFragment)packages[i];
                    if (!pack.equals(getPackageP()) && pack.exists()
                            && !pack.isReadOnly())
                        pack.delete(true, null);
                }
                catch (JavaModelException ex)
                {
                    //try to delete'em all
                    ex.printStackTrace();
                }
            }
        }
    }

    private void refreshFromLocal() throws CoreException
    {
        if (getRoot().exists())
        {
            getRoot().getResource().
            		  refreshLocal(IResource.DEPTH_INFINITE, null);
        }
        else if (getPackageP().exists())//don't refresh package if root already refreshed
        {
            getPackageP().getResource().
            			  refreshLocal(IResource.DEPTH_INFINITE, null);
        }
    }

    private static void tryDeletingAllNonJavaChildResources(
            IPackageFragment pack) throws JavaModelException
    {
        Object[] nonJavaKids = pack.getNonJavaResources();
        for (int i = 0; i < nonJavaKids.length; i++)
        {
            if (nonJavaKids[i] instanceof IResource)
            {
                IResource resource = (IResource)nonJavaKids[i];
                try
                {
                    resource.delete(true, null);
                }
                catch (CoreException ex)
                {
                    //try to delete'em all
                    ex.printStackTrace();
                }
            }
        }
    }

    private static void tryDeletingAllJavaChildren(IPackageFragment pack)
            throws JavaModelException
    {
        IJavaElement[] kids = pack.getChildren();
        for (int i = 0; i < kids.length; i++)
        {
            if (kids[i] instanceof ISourceManipulation)
            {
                try
                {
                    if (kids[i].exists() && !kids[i].isReadOnly())
                        ((ISourceManipulation)kids[i]).delete(true, null);
                }
                catch (JavaModelException ex)
                {
                    //try to delete'em all
                    ex.printStackTrace();
                }
            }
        }
    }

    protected IPackageFragmentRoot getRoot()
    {
        return _root;
    }

    protected IPackageFragment getPackageP()
    {
        return _packageP;
    }

    protected final Refactoring createRefactoring(RefactoringDescriptor descriptor) throws CoreException {
	    RefactoringStatus status= new RefactoringStatus();
		Refactoring refactoring= descriptor.createRefactoring(status);
		assertNotNull("refactoring should not be null", refactoring);
		assertTrue("status should be ok", status.isOK());
	    return refactoring;
    }

	protected final RefactoringStatus performRefactoring(RefactoringDescriptor descriptor) throws Exception {
		return performRefactoring(descriptor, true);
	}

	protected final RefactoringStatus performRefactoring(RefactoringDescriptor descriptor, boolean providesUndo) throws Exception {
		Refactoring refactoring= createRefactoring(descriptor);
		return performRefactoring(refactoring, providesUndo);
	}

    protected final RefactoringStatus performRefactoring(Refactoring ref)
            throws Exception
    {
        return performRefactoring(ref, true);
    }

    protected final RefactoringStatus performRefactoring(Refactoring ref,
            boolean providesUndo) throws Exception
    {
        performDummySearch();
        IUndoManager undoManager = getUndoManager();
        CreateChangeOperation create = new CreateChangeOperation(
                new CheckConditionsOperation(ref,
                        CheckConditionsOperation.ALL_CONDITIONS),
                RefactoringStatus.FATAL);
        PerformChangeOperation perform = new PerformChangeOperation(create);
        perform.setUndoManager(undoManager, ref.getName());
        ResourcesPlugin.getWorkspace().run(perform, new NullProgressMonitor());
        RefactoringStatus status = create.getConditionCheckingStatus();
        if (!status.isOK())
        {
            return status;
        }
        assertTrue("Change wasn't executed", perform.changeExecuted());
        Change undo = perform.getUndoChange();
        if (providesUndo)
        {
            assertNotNull("Undo doesn't exist", undo);
            assertTrue("Undo manager is empty", undoManager.anythingToUndo());
        }
        else
        {
            assertNull("Undo manager contains undo but shouldn't", undo);
        }
        return null;
    }

    protected final RefactoringStatus performRefactoringWithStatus(
            Refactoring ref) throws Exception
    {
        performDummySearch();
        CreateChangeOperation create = new CreateChangeOperation(
                new CheckConditionsOperation(ref,
                        CheckConditionsOperation.ALL_CONDITIONS),
                RefactoringStatus.FATAL);
        PerformChangeOperation perform = new PerformChangeOperation(create);
        perform.setUndoManager(RefactoringCore.getUndoManager(), ref.getName());
        ResourcesPlugin.getWorkspace().run(perform, new NullProgressMonitor());
        RefactoringStatus status = create.getConditionCheckingStatus();
        if (status.hasFatalError())
        {
            return status;
        }
        assertTrue("Change wasn't executed", perform.changeExecuted());
        return status;
    }

    protected void performDummySearch() throws Exception
    {
        performDummySearch(getPackageP());
    }

    protected final Change performChange(final Refactoring refactoring,
            boolean storeUndo) throws Exception
    {
        CreateChangeOperation create = new CreateChangeOperation(refactoring);
        PerformChangeOperation perform = new PerformChangeOperation(create);
        if (storeUndo)
        {
            perform.setUndoManager(getUndoManager(), refactoring.getName());
        }
        ResourcesPlugin.getWorkspace().run(perform, new NullProgressMonitor());
        assertTrue("Change wasn't executed", perform.changeExecuted());
        return perform.getUndoChange();
    }

    protected final Change performChange(final Change change) throws Exception
    {
        PerformChangeOperation perform = new PerformChangeOperation(change);
        ResourcesPlugin.getWorkspace().run(perform, new NullProgressMonitor());
        assertTrue("Change wasn't executed", perform.changeExecuted());
        return perform.getUndoChange();
    }

    protected IUndoManager getUndoManager()
    {
        IUndoManager undoManager = RefactoringCore.getUndoManager();
        undoManager.flush();
        return undoManager;
    }

    /** ************** helpers ***************** */
    /** ** mostly not general, just shortcuts **** */

    protected IType getType(ICompilationUnit cu, String name)
            throws JavaModelException
    {
        IType[] types = cu.getAllTypes();
        for (int i = 0; i < types.length; i++)
        {
            if (types[i].getFullyQualifiedName().equals(name)
                    || types[i].getElementName().equals(name))
            {
                return types[i];
            }
        }
        return null;
    }

    /**
     * subclasses override to inform about the location of their test cases
     */
    protected String getRefactoringPath()
    {
        return "";
    }

    /**
     * example "RenameType/"
     */
    protected String getTestPath()
    {
        return TEST_PATH_PREFIX + getRefactoringPath();
    }

    /**
     * @param cuName
     * @param infix
     *            example "RenameTest/test0 + infix + cuName.java"
     */
    protected String createTestFileName(String cuName, String infix)
    {
        return getTestPath() + getName() + infix + cuName + ".java";
    }

    protected String getInputTestFileName(String cuName)
    {
        return createTestFileName(cuName, TEST_INPUT_INFIX);
    }

    /**
     * @param subDirName
     *            example "p/" or "org/eclipse/jdt/"
     */
    protected String getInputTestFileName(String cuName, String subDirName)
    {
        return createTestFileName(cuName, TEST_INPUT_INFIX + subDirName);
    }

    protected String getOutputTestFileName(String cuName)
    {
        return createTestFileName(cuName, TEST_OUTPUT_INFIX);
    }

    /**
     * @param subDirName
     *            example "p/" or "org/eclipse/jdt/"
     */
    protected String getOutputTestFileName(String cuName, String subDirName)
    {
        return createTestFileName(cuName, TEST_OUTPUT_INFIX + subDirName);
    }

    protected ICompilationUnit createCUfromTestFile(IPackageFragment pack,
            String cuName) throws Exception
    {
        return createCUfromTestFile(pack, cuName, true);
    }

    protected ICompilationUnit createCUfromTestFile(IPackageFragment pack,
            String cuName, String subDirName) throws Exception
    {
        return createCUfromTestFile(pack, cuName, subDirName, true);
    }

    protected ICompilationUnit createCUfromTestFile(IPackageFragment pack,
            String cuName, boolean input) throws Exception
    {
        String contents = input ? getFileContents(getInputTestFileName(cuName))
                : getFileContents(getOutputTestFileName(cuName));
        return createCU(pack, cuName + ".java", contents);
    }

    protected ICompilationUnit createCUfromTestFile(IPackageFragment pack,
            String cuName, String subDirName, boolean input) throws Exception
    {
        String contents = input ? getFileContents(getInputTestFileName(cuName,
                subDirName)) : getFileContents(getOutputTestFileName(cuName,
                subDirName));

        return createCU(pack, cuName + ".java", contents);
    }

    protected void printTestDisabledMessage(String explanation)
    {
        System.out.println("\n" + getClass().getName() + "::" + getName()
                + " disabled (" + explanation + ")");
    }

    protected ICompilationUnit[] createCUs(String[] cuNames) throws Exception {
		ICompilationUnit[] cus = new ICompilationUnit[cuNames.length];

		for (int idx = 0; idx < cuNames.length; idx++) {
			Assert.isNotNull(cuNames[idx]);
			cus[idx] = createCUfromTestFile(getPackageP(), cuNames[idx]);
		}
		return cus;
	}

	protected String createInputTestFileName(ICompilationUnit[] cus, int idx) {
		return getInputTestFileName(getSimpleNameOfCu(cus[idx].getElementName()));
	}

	protected String createOutputTestFileName(ICompilationUnit[] cus, int idx) {
		return getOutputTestFileName(getSimpleNameOfCu(cus[idx].getElementName()));
	}

	private String getSimpleNameOfCu(String compUnit) {
		int dot = compUnit.lastIndexOf('.');
		return compUnit.substring(0, dot);
	}

	//-----------------------
    public static InputStream getStream(String content)
    {
        return new StringBufferInputStream(content);
    }

    public static IPackageFragmentRoot getSourceFolder(
            IJavaProject javaProject, String name) throws JavaModelException
    {
        IPackageFragmentRoot[] roots = javaProject.getPackageFragmentRoots();
        for (int i = 0; i < roots.length; i++)
        {
            if (!roots[i].isArchive() && roots[i].getElementName().equals(name))
                return roots[i];
        }
        return null;
    }

    public static String getFileContents(String fileName) throws IOException
    {
        return getContents(getFileInputStream(fileName));
    }

    public static String getContents(IFile file) throws IOException,
            CoreException
    {
        return getContents(file.getContents());
    }

    public static ICompilationUnit createCU(IPackageFragment pack, String name,
            String contents) throws Exception
    {
        if (pack.getCompilationUnit(name).exists())
        {
            return pack.getCompilationUnit(name);
        }
        ICompilationUnit cu = pack.createCompilationUnit(name, contents, true,
                null);
        cu.save(null, true);
        return cu;
    }

    public static String getContents(InputStream in) throws IOException
    {
        BufferedReader br = new BufferedReader(new InputStreamReader(in));
        StringBuffer sb = new StringBuffer(300);
        try
        {
            int read = 0;
            while ((read = br.read()) != -1)
            {
                sb.append((char)read);
            }
        }
        finally
        {
            br.close();
        }
        return sb.toString();
    }

    public static InputStream getFileInputStream(String fileName)
            throws IOException
    {
        return OTRefactoringTestPlugin.getDefault().getTestResourceStream(
                fileName);
    }

    public static String removeExtension(String fileName)
    {
        return fileName.substring(0, fileName.lastIndexOf('.'));
    }

    public static void performDummySearch(IJavaElement element)
            throws Exception
    {
        new SearchEngine().searchAllTypeNames(ResourcesPlugin.getWorkspace(),
                null, null, SearchPattern.R_EXACT_MATCH, true,
                IJavaSearchConstants.CLASS, SearchEngine
                        .createJavaSearchScope(new IJavaElement[] { element }),
                new Requestor(),
                IJavaSearchConstants.WAIT_UNTIL_READY_TO_SEARCH, null);
    }

    public static IMember[] merge(IMember[] a1, IMember[] a2, IMember[] a3)
    {
        return JavaElementUtil.merge(JavaElementUtil.merge(a1, a2), a3);
    }

    public static IMember[] merge(IMember[] a1, IMember[] a2)
    {
        return JavaElementUtil.merge(a1, a2);
    }

    public static IField[] getFields(IType type, String[] names)
            throws JavaModelException
    {
        if (names == null)
        {
            return new IField[0];
        }
        Set<IField> fields = new HashSet<IField>();
        for (int i = 0; i < names.length; i++)
        {
            IField field = type.getField(names[i]);
            assertTrue("field " + field.getElementName() + " does not exist",
                    field.exists());
            fields.add(field);
        }
        return fields.toArray(new IField[fields.size()]);
    }

    public static IType[] getMemberTypes(IType type, String[] names)
            throws JavaModelException
    {
        if (names == null)
        {
            return new IType[0];
        }
        Set<IType> memberTypes = new HashSet<IType>();
        for (int i = 0; i < names.length; i++)
        {
            IType memberType = type.getType(names[i]);
            assertTrue("member type " + memberType.getElementName()
                    + " does not exist", memberType.exists());
            memberTypes.add(memberType);
        }
        return memberTypes.toArray(new IType[memberTypes.size()]);
    }

    public static IMethod[] getMethods(IType type, String[] names,
            String[][] signatures) throws JavaModelException
    {
    	return getMethods(type, names, signatures, null, false);
    }
    public static IMethod[] getMethods(IType type, String[] names, String[][] signatures,
    									boolean[] flags, boolean flag)
            		throws JavaModelException
    {
        if (names == null || signatures == null)
        {
            return new IMethod[0];
        }
        List<IMethod> methods = new ArrayList<IMethod>(names.length);
        for (int i = 0; i < names.length; i++)
        {
        	// use flags to filter sub-set of names/signatures:
        	if (flags != null && flags[i] != flag) continue;

            IMethod method = type.getMethod(names[i], signatures[i]);
            if (!method.exists()) {
            	// search a callout mapping that might be "equal" to this method:
            	for (IJavaElement child : type.getChildren()) {
            		int elementType = child.getElementType();
					if (elementType == IOTJavaElement.CALLOUT_MAPPING || elementType == IOTJavaElement.CALLOUT_TO_FIELD_MAPPING) {
						AbstractCalloutMapping map = (AbstractCalloutMapping) child;
						if (method.equals(map.getCorrespondingJavaElement())) {
							method = map;
							break;
						}
					}
            	}
            }
            assertTrue("method " + method.getElementName() + " does not exist",
                    method.exists());
            if (!methods.contains(method))
            {
                methods.add(method);
            }
        }
        return methods.toArray(new IMethod[methods.size()]);
    }

    public static IType[] findTypes(IType[] types, String[] namesOfTypesToPullUp)
    {
        List<IType> found = new ArrayList<IType>(types.length);
        for (int i = 0; i < types.length; i++)
        {
            IType type = types[i];
            for (int j = 0; j < namesOfTypesToPullUp.length; j++)
            {
                String name = namesOfTypesToPullUp[j];
                if (type.getElementName().equals(name))
                {
                    found.add(type);
                }
            }
        }
        return found.toArray(new IType[found.size()]);
    }

    public static IField[] findFields(IField[] fields,
            String[] namesOfFieldsToPullUp)
    {
        List<IField> found = new ArrayList<IField>(fields.length);
        for (int i = 0; i < fields.length; i++)
        {
            IField field = fields[i];
            for (int j = 0; j < namesOfFieldsToPullUp.length; j++)
            {
                String name = namesOfFieldsToPullUp[j];
                if (field.getElementName().equals(name))
                {
                    found.add(field);
                }
            }
        }
        return found.toArray(new IField[found.size()]);
    }

    public static IMethod[] findMethods(IMethod[] selectedMethods,
            String[] namesOfMethods, String[][] signaturesOfMethods)
    {
        List<IMethod> found = new ArrayList<IMethod>(selectedMethods.length);
        for (int i = 0; i < selectedMethods.length; i++)
        {
            IMethod method = selectedMethods[i];
            String[] paramTypes = method.getParameterTypes();
            for (int j = 0; j < namesOfMethods.length; j++)
            {
                String methodName = namesOfMethods[j];
                if (!methodName.equals(method.getElementName()))
                {
                    continue;
                }
                String[] methodSig = signaturesOfMethods[j];
                if (!areSameSignatures(paramTypes, methodSig))
                {
                    continue;
                }
                found.add(method);
            }
        }
        return found.toArray(new IMethod[found.size()]);
    }

    private static boolean areSameSignatures(String[] s1, String[] s2)
    {
        if (s1.length != s2.length)
        {
            return false;
        }
        for (int i = 0; i < s1.length; i++)
        {
            if (!s1[i].equals(s2[i]))
            {
                return false;
            }
        }
        return true;
    }

    /**
     * Line-based version of junit.framework.Assert.assertEquals(String, String)
     * without considering line delimiters.
     */
    public static void assertEqualLines(String expected, String actual)
    {
        assertEqualLines("", expected, actual);
    }

    /**
     * Line-based version of junit.framework.Assert.assertEquals(String, String, String)
     * without considering line delimiters.
     */
    public static void assertEqualLines(String message, String expected,
            String actual)
    {
        String[] expectedLines = Strings.convertIntoLines(expected);
        String[] actualLines = Strings.convertIntoLines(actual);

        String expected2 = (expectedLines == null ? null : Strings.concatenate(
                expectedLines, "\n"));
        String actual2 = (actualLines == null ? null : Strings.concatenate(
                actualLines, "\n"));
        assertEquals(message, expected2, actual2);
    }

    private static class Requestor implements ITypeNameRequestor
    {

        public void acceptClass(char[] packageName, char[] simpleTypeName,
                char[][] enclosingTypeNames, String path)
        {
        }

        public void acceptInterface(char[] packageName, char[] simpleTypeName,
                char[][] enclosingTypeNames, String path)
        {
        }
    }
}