/*******************************************************************************
 * 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.typeinference;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.net.URL;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Enumeration;
import java.util.HashSet;
import java.util.Set;
import java.util.StringTokenizer;

import org.eclipse.core.runtime.Assert;
import org.eclipse.dltk.ast.ASTNode;
import org.eclipse.dltk.ast.ASTVisitor;
import org.eclipse.dltk.ast.declarations.ModuleDeclaration;
import org.eclipse.dltk.ast.references.VariableReference;
import org.eclipse.dltk.core.ISourceModule;
import org.eclipse.dltk.evaluation.types.AmbiguousType;
import org.eclipse.dltk.evaluation.types.SimpleType;
import org.eclipse.dltk.evaluation.types.UnknownType;
import org.eclipse.dltk.ruby.core.tests.Activator;
import org.eclipse.dltk.ruby.typeinference.OffsetTargetedASTVisitor;
import org.eclipse.dltk.ruby.typeinference.RubyClassType;
import org.eclipse.dltk.ti.BasicContext;
import org.eclipse.dltk.ti.DLTKTypeInferenceEngine;
import org.eclipse.dltk.ti.ITypeInferencer;
import org.eclipse.dltk.ti.goals.ExpressionTypeGoal;
import org.eclipse.dltk.ti.types.IEvaluatedType;
import org.eclipse.dltk.ti.types.RecursionTypeCall;
import org.osgi.framework.Bundle;

import junit.framework.AssertionFailedError;
import junit.framework.TestCase;
import junit.framework.TestResult;
import junit.framework.TestSuite;

public class TypeInferenceSuite extends TestSuite {

	@Override
	public void run(TestResult result) {
		TypeInferenceTest tests = new TypeInferenceTest("ruby selection tests");
		try {
			tests.setUpSuite();
		} catch (Throwable t) {
			result.addError(this, t);
			return;
		}
		try {
			super.run(result);
		} finally {
			try {
				tests.tearDownSuite();
			} catch (Throwable t) {
				t.printStackTrace();
			}
		}
	}

	public TypeInferenceSuite(Class<?> clazz, String testsDirectory) {
		super(clazz.getName());
		final Bundle bundle = Activator.getDefault().getBundle();
		Enumeration<String> entryPaths = bundle.getEntryPaths(testsDirectory);
		while (entryPaths.hasMoreElements()) {
			final String path = entryPaths.nextElement();
			URL entry = bundle.getEntry(path);
			try {
				entry.openStream().close();
			} catch (Exception e) {
				continue;
			}
			int pos = path.lastIndexOf('/');
			final String name = (pos >= 0 ? path.substring(pos + 1) : path);
			String x = path.substring(0, pos);
			pos = x.lastIndexOf('/');
			final String folder = (pos >= 0 ? x.substring(pos + 1) : x);
			addTest(new TestCase(name) {

				private Collection<IAssertion> assertions = new ArrayList<>();

				@Override
				public void setUp() {
				}

				@Override
				protected void runTest() throws Throwable {
					String content = loadContent(path);
					String[] lines = content.split("\n");
					int lineOffset = 0;
					for (int i = 0; i < lines.length; i++) {
						String line = lines[i].trim();
						int pos = line.indexOf("##");
						if (pos >= 0) {
							StringTokenizer tok = new StringTokenizer(line
									.substring(pos + 2));
							String test = tok.nextToken();
							if ("exit".equals(test)) {
								return;
							} else if ("localvar".equals(test)) {
								String varName = tok.nextToken();
								int namePos = lines[i].indexOf(varName);
								Assert.isLegal(namePos >= 0);
								namePos += lineOffset;
								String arrow = tok.nextToken();
								Assert.isLegal(arrow.equals("=>"));
								String correctClassRef = tok.nextToken();
								assertions.add(new VariableReturnTypeAssertion(
										varName, namePos, correctClassRef));
							} else if ("expr".equals(test)) {
								String expr = tok.nextToken();
								int namePos = lines[i].indexOf(expr);
								Assert.isLegal(namePos >= 0);
								namePos += lineOffset;
								String arrow = tok.nextToken();
								Assert.isLegal(arrow.equals("=>"));
								String correctClassRef = tok.nextToken();
								assertions.add(new ExpressionTypeAssertion(
										expr, namePos, correctClassRef));
							} else {
								// Assert.isLegal(false);
							}
						}
						lineOffset += lines[i].length() + 1;
					}

					if (assertions.size() == 0)
						return;

					ITypeInferencer inferencer = new DLTKTypeInferenceEngine();

					TypeInferenceTest tests = new TypeInferenceTest(
							"ruby selection tests");
					tests.executeTest(folder, name, inferencer, assertions);
				}

				class VariableReturnTypeAssertion implements IAssertion {

					private final String correctClassRef;

					// private final String varName;

					private final int namePos;

					public VariableReturnTypeAssertion(String varName,
							int namePos, String correctClassRef) {
						// this.varName = varName;
						this.namePos = namePos;
						this.correctClassRef = correctClassRef;
					}

					@Override
					public void check(ModuleDeclaration rootNode,
							ISourceModule cu, ITypeInferencer inferencer)
							throws Exception {
						final ASTNode[] result = new ASTNode[1];
						ASTVisitor visitor = new OffsetTargetedASTVisitor(
								namePos) {

							@Override
							protected boolean visitGeneralInteresting(ASTNode s) {
								if (s instanceof VariableReference)
									if (s.sourceStart() == namePos
											&& result[0] == null) {
										result[0] = s;
									}
								return true;
							}

						};
						rootNode.traverse(visitor);
						Assert.isLegal(result[0] != null);
						ExpressionTypeGoal goal = new ExpressionTypeGoal(
								new BasicContext(cu, rootNode), result[0]);
						IEvaluatedType type = inferencer.evaluateType(goal, -1);
						assertNotNull(type);

						assertEquals(correctClassRef, ((RubyClassType) type)
								.getModelKey());
					}

				}

				class ExpressionTypeAssertion implements IAssertion {

					private final String correctClassRef;

					// private final String expression;

					private final int namePos;

					public ExpressionTypeAssertion(String expression,
							int namePos, String correctClassRef) {
						// this.expression = expression;
						this.namePos = namePos;
						this.correctClassRef = correctClassRef;
					}

					@Override
					public void check(ModuleDeclaration rootNode,
							ISourceModule cu, ITypeInferencer inferencer)
							throws Exception {
						final ASTNode[] result = new ASTNode[1];
						ASTVisitor visitor = new OffsetTargetedASTVisitor(
								namePos) {

							@Override
							protected boolean visitGeneralInteresting(ASTNode s) {
								if (s != null && result[0] == null)
									if (s.sourceStart() == namePos) {
										result[0] = s;
									}
								return true;
							}

						};
						rootNode.traverse(visitor);
						if (result[0] == null)
							System.out
									.println("ExpressionTypeAssertion.check()");
						Assert.isLegal(result[0] != null);
						ExpressionTypeGoal goal = new ExpressionTypeGoal(
								new BasicContext(cu, rootNode), result[0]);
						IEvaluatedType type = inferencer.evaluateType(goal, -1);
						if (!correctClassRef.equals("recursion")) {
							if (type == null)
								throw new AssertionFailedError(
										"null type fetched, but "
												+ correctClassRef + " expected");
							assertNotNull(type);
							if (type instanceof SimpleType) {
								IEvaluatedType intrinsicType = getIntrinsicType(correctClassRef);
								assertEquals(intrinsicType, type);
							} else if (type instanceof RubyClassType) {
								RubyClassType rubyType = (RubyClassType) type;
								assertEquals(correctClassRef, rubyType
										.getModelKey());
							} else if (type instanceof AmbiguousType) {
								AmbiguousType ambiType = (AmbiguousType) type;
								Set<String> modelKeySet = new HashSet<>();
								IEvaluatedType[] possibleTypes = ambiType
										.getPossibleTypes();
								for (int cnt = 0, max = possibleTypes.length; cnt < max; cnt++) {
									if (possibleTypes[cnt] instanceof RubyClassType) {
										modelKeySet
												.add(((RubyClassType) possibleTypes[cnt])
														.getModelKey());
									}
								}
								assertTrue(modelKeySet
										.contains(correctClassRef));
							} else {
								fail("Unrecognized IEvaluatedType was inferred: "
										+ type.getClass().getName());
							}
						}
					}

				}

			});
		}
	}

	private String loadContent(String path) throws IOException {
		StringBuffer buffer = new StringBuffer();
		try (InputStream input = Activator.openResource(path);) {
			InputStreamReader reader = new InputStreamReader(input);
			BufferedReader br = new BufferedReader(reader);
			char[] data = new char[100 * 1024]; // tests shouldnt be more that
			// 100 kb
			int size = br.read(data);
			buffer.append(data, 0, size);
		}
		String content = buffer.toString();
		return content;
	}

	private static IEvaluatedType getIntrinsicType(String correctClassRef) {
		IEvaluatedType correctType;
		if ("recursion".equals(correctClassRef))
			correctType = RecursionTypeCall.INSTANCE;
		else if ("any".equals(correctClassRef))
			correctType = UnknownType.INSTANCE;
		// else if ("Fixnum".equals(correctClassRef))
		// correctType = new SimpleType(SimpleType.TYPE_NUMBER);
		// else if ("Str".equals(correctClassRef))
		// correctType = new SimpleType(SimpleType.TYPE_STRING);
		else
			correctType = null;
		return correctType;
	}
}