package no.uio.ifi.refaktor.utils;

import static no.uio.ifi.refaktor.assertion.RefaktorAssert.assertThat;

import java.util.Arrays;
import java.util.LinkedList;
import java.util.List;

import no.uio.ifi.refaktor.exceptions.RefaktorException;

import org.eclipse.core.resources.IFile;
import org.eclipse.core.resources.IProject;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.jdt.core.ICompilationUnit;
import org.eclipse.jdt.core.IJavaProject;
import org.eclipse.jdt.core.IMethod;
import org.eclipse.jdt.core.IPackageFragment;
import org.eclipse.jdt.core.IPackageFragmentRoot;
import org.eclipse.jdt.core.IType;
import org.eclipse.jdt.core.JavaCore;
import org.eclipse.jdt.core.JavaModelException;
import org.eclipse.ui.IEditorPart;

// TODO: clean up
public class RefaktorHandleUtils {

	public static ICompilationUnit getCompilationUnitFromEditor(IEditorPart editor) {
		return findCompilationUnitFromFile(DocumentUtils.getFileFromEditor(editor));
	}

	public static ICompilationUnit findCompilationUnitFromFile(IFile file) {
		return JavaCore.createCompilationUnitFrom(file);
	}

	public static ICompilationUnit findCompilationUnitFromProjectPackageAndTypeName(IProject project, String packageName, String simpleTypeName) {
		try {
			return findType(project, packageName, simpleTypeName).getCompilationUnit();
		} catch (JavaModelException e) {
			throw new RuntimeException(e);
		}
	}

	public static IType findType(IProject project, String packageName, String simpleTypeName) throws JavaModelException {
		return findType(project, packageName + "." + simpleTypeName);
	}

	private static IType findType(IProject project, String fullyQualifiedTypeName) throws JavaModelException {
		return createJavaProjectFrom(project).findType(fullyQualifiedTypeName);
	}

	public static IMethod findMethodHandleChecked(IProject project, String packageName, String simpleTypeName, 
			String methodName, String... methodSignature) {
		try {
			IMethod method = findMethodHandle(project, packageName, simpleTypeName, methodName, methodSignature);
			assertThat("method.exists()", method.exists());
			return method;
		} catch (JavaModelException e) {
			throw new RefaktorException("The requested method handle could not be found");
		}
	}

	public static IMethod findMethodHandle(IProject project, String packageName, String simpleTypeName, 
			String methodName, String[] methodSignature) throws JavaModelException {
		return findType(project, packageName, simpleTypeName).getMethod(methodName, methodSignature);
	}

	public static IMethod findMethodHandle(IProject project, String fullyQualifiedTypeName, String simpleSignature) throws JavaModelException {
		IType type = findType(project, fullyQualifiedTypeName);
		MethodSignature methodSignature = MethodSignature.parseSignature(simpleSignature);
		return type.getMethod(methodSignature.getName(), methodSignature.getParameterSignaturesArray());
	}

	public static IJavaProject createJavaProjectFrom(IProject project) {
		assertThat(project.exists());
		assertThat(project.isOpen());
		try {
			assertThat(project.hasNature(JavaCore.NATURE_ID));
		} catch (CoreException e) {
			// Project does not exist or is not open
		}
		return JavaCore.create(project);
	}

	public static IPackageFragment findPackageChecked(String packageName, IProject project) {
		try {
			return findPackage(packageName, project);
		} catch (JavaModelException e) {
			RefaktorDebug.log(e);
			return new NullPackageFragmentHandle();
		}
	}

	private static IPackageFragment findPackage(String packageName, IProject project) throws JavaModelException {
		IJavaProject javaProject = createJavaProjectFrom(project);
		for (IPackageFragment packageFragment: javaProject.getPackageFragments()) {
			if (packageFragment.getElementName().equals(packageName))
				return packageFragment;
		}
		return new NullPackageFragmentHandle();
	}

	public static List<IPackageFragment> getPackagesFromProject(IProject project) throws JavaModelException {
		IPackageFragment[] packageFragments = createJavaProjectFrom(project).getPackageFragments();
		return findPackagesAmongPackageFragments(Arrays.asList(packageFragments));
	}

	public static List<IPackageFragment> findPackagesAmongPackageFragments(List<IPackageFragment> packageFragments) throws JavaModelException {
		List<IPackageFragment> packages = new LinkedList<IPackageFragment>();
		for (IPackageFragment packageFragment: packageFragments) {
			if (containsSourceCode(packageFragment))
				packages.add(packageFragment);
		}
		return packages;
	}

	private static boolean containsSourceCode(IPackageFragment packageFragment) throws JavaModelException {
		return packageFragment.getKind() == IPackageFragmentRoot.K_SOURCE && packageFragment.hasChildren();
	}
}