package io.guixer.tools;
   
   import static com.google.common.base.Preconditions.checkNotNull;
   import static com.google.common.base.Preconditions.checkState;
   import static com.google.common.collect.Lists.newArrayList;
   import static com.google.common.collect.Maps.newHashMap;
   import static io.guixer.tools.TestUtils.getTestProperties;
   import static io.guixer.tools.TestUtils.getTestProperty;
   import static io.guixer.tools.TestUtils.getTestPropertyOrNull;
  import static java.nio.charset.StandardCharsets.UTF_8;
  import static org.apache.commons.lang3.StringUtils.join;
  import static org.apache.commons.lang3.StringUtils.split;
  import static org.apache.commons.lang3.StringUtils.substringBeforeLast;
  
  import java.io.File;
  import java.io.FileNotFoundException;
  import java.io.IOException;
  import java.lang.reflect.Method;
  import java.net.MalformedURLException;
  import java.net.URL;
  import java.net.URLDecoder;
  import java.util.Arrays;
  import java.util.List;
  import java.util.Map;
  import java.util.Map.Entry;
  import java.util.Properties;
  import java.util.concurrent.Callable;
  import java.util.function.Function;
  import java.util.stream.Collectors;
  
  import javax.annotation.Nullable;
  
  import org.apache.commons.lang3.NotImplementedException;
  import org.junit.jupiter.api.AfterEach;
  import org.junit.jupiter.api.BeforeEach;
  import org.junit.jupiter.api.Test;
  import org.openqa.selenium.Capabilities;
  import org.openqa.selenium.WebDriver;
  import org.openqa.selenium.WebDriverException;
  import org.openqa.selenium.chrome.ChromeOptions;
  import org.openqa.selenium.firefox.FirefoxOptions;
  import org.openqa.selenium.remote.RemoteWebDriver;
  
  import com.google.common.collect.ImmutableList;
  
  import io.guixer.lang.GuixerScenario;
  import io.guixer.lang.GuixerScenarioLoader2;
  import io.guixer.lang.GuixerSyntaxException;
  
  public abstract class GuixerTest {
  
  	@BeforeEach
  	public final void setUpGuixerContext() throws Exception {
  
  		@Nullable
  		final WebDriver defaultDriver = drivers.get("");
  
  		if (defaultDriver == null) {
  
  			// e.g. "http://192.168.0.19:4444/wd/hub";
  			//
  			final String seleniumServerUrl = getTestProperty("seleniumServer.url");
  			final String seleniumDesiredCapabilities = getTestProperty("selenium.desiredCapabilities", "firefox");
  			final List<String> seleniumOptions = parseOptions(getTestPropertyOrNull("selenium.options"));
  
  			System.out.println("seleniumServer.url: " + seleniumServerUrl);
  			System.out.println("selenium.desiredCapabilities: " + seleniumDesiredCapabilities);
  			System.out.println("selenium.options: " + seleniumOptions);
  
  			final Capabilities capabilities = getCapabilities( //
  					seleniumDesiredCapabilities, //
  					seleniumOptions);
  
  			driver = new RemoteWebDriver(new URL(seleniumServerUrl), capabilities);
  
  			injectDriver("", driver);
  
  		} else {
  
  			driver = defaultDriver;
  		}
  	}
  
  	private static List<String> parseOptions(
  		@Nullable final String optionsProperty
  	) {
  
  		if (optionsProperty == null) {
  
  			return ImmutableList.of();
  		}
  
  		return ImmutableList.copyOf(split(optionsProperty, " "));
  	}
  
  	@AfterEach
  	public final void tearDownGuixerContext() throws Exception {
  
  		try {
 
 			for (final WebDriver driver : drivers.values()) {
 
 				try {
 
 					driver.quit();
 
 				} catch (final WebDriverException e) {
 
 					// Sometimes, "driver.quit()" just crashes.
 
 					e.printStackTrace(); // log the error, and do nothing
 				}
 			}
 
 		} finally {
 
 			driver = null;
 		}
 	}
 
 	public static void isolatedRun() throws Exception {
 
 		final GuixerTest test = new GuixerTest() {
 
 		};
 
 		test.setUpGuixerContext();
 
 		try {
 
 			test.run();
 
 		} finally {
 
 			test.tearDownGuixerContext();
 		}
 	}
 
 	private WebDriver driver = null;
 
 	protected final WebDriver getDriver() {
 
 		// We use an intermediate variable, so the variable we check as non null,
 		// is still non null at the end of the method.
 		//
 		final WebDriver driver = this.driver;
 
 		if (driver == null) {
 
 			throw new IllegalStateException("Current driver should not be null.");
 		}
 
 		return driver;
 	}
 
 	private WebDriver switchToDriver(
 		final String driverName
 	) {
 
 		final WebDriver cached = drivers.get(driverName);
 
 		if (cached != null) {
 
 			driver = cached;
 
 			return cached;
 		}
 
 		final String laneId = driverName;
 
 		final String seleniumServerUrl;
 
 		try {
 
 			seleniumServerUrl = getTestProperty("seleniumServer.url." + laneId);
 
 		} catch (final IOException e) {
 
 			throw new RuntimeException(e);
 		}
 
 		final String seleniumDesiredCapabilities;
 
 		try {
 
 			seleniumDesiredCapabilities = getTestProperty("selenium.desiredCapabilities." + laneId, "firefox");
 
 		} catch (final IOException e) {
 
 			throw new RuntimeException(e);
 		}
 
 		final List<String> seleniumOptions;
 
 		try {
 
 			seleniumOptions = parseOptions(getTestPropertyOrNull("selenium.options." + laneId));
 
 		} catch (final IOException e) {
 
 			throw new RuntimeException(e);
 		}
 
 		System.out.println("seleniumServer.url." + laneId + ": " + seleniumServerUrl);
 		System.out.println("selenium.desiredCapabilities." + laneId + ": " + seleniumDesiredCapabilities);
 		System.out.println("selenium.options." + laneId + ": " + seleniumOptions);
 
 		final Capabilities capabilities = getCapabilities( //
 				seleniumDesiredCapabilities, //
 				seleniumOptions);
 
 		final URL url;
 
 		try {
 
 			url = new URL(seleniumServerUrl);
 
 		} catch (final MalformedURLException e) {
 
 			throw new RuntimeException(e);
 		}
 
 		final WebDriver newDriver = new RemoteWebDriver(url, capabilities);
 
 		injectDriver(driverName, newDriver);
 
 		driver = newDriver;
 
 		return newDriver;
 	}
 
 	private RunnerContext runnerContext = null;
 
 	protected final RunnerContext getRunnerContext() {
 
 		// We use an intermediate variable, so the variable we check as non null,
 		// is still non null at the end of the method.
 		//
 		final RunnerContext runnerContext = this.runnerContext;
 
 		if (runnerContext == null) {
 
 			throw new IllegalStateException("Current runnerContext should not be null.");
 		}
 
 		return runnerContext;
 	}
 
 	private static Capabilities getCapabilities(
 		final String seleniumDesiredCapabilities,
 		final List<String> seleniumOptions
 	) {
 
 		if ("firefox".equals(seleniumDesiredCapabilities)) {
 
 			final FirefoxOptions options = new FirefoxOptions();
 
 			return options;
 
 		} else if ("chrome".equals(seleniumDesiredCapabilities)) {
 
 			final ChromeOptions options = new ChromeOptions();
 
 			// e.g. options.addArguments("--window-size=1920,1080");
 			//
 			options.addArguments(seleniumOptions);
 
 			// options.EnableMobileEmulation(deviceName);
 			// options.AddArgument("no-sandbox");
 			// ChromeDriver drv = new
 			// ChromeDriver(ChromeDriverService.CreateDefaultService(), options,
 			// TimeSpan.FromMinutes(3));
 			// drv.Manage().Timeouts().PageLoad.Add(System.TimeSpan.FromSeconds(30));
 
 			return options;
 
 		} else {
 
 			throw new NotImplementedException("seleniumDesiredCapabilities: " + seleniumDesiredCapabilities
 					+ " (should be one of: firefox, chrome)");
 		}
 	}
 
 	protected final void run() throws IOException, GuixerSyntaxException {
 
 		System.out.println("Incoming call: run()... Looking for yamlFileName...");
 
 		final String yamlFileName = extractScenarioFileNameFromCurrentThread();
 
 		System.out.println("Found yamlFileName: " + yamlFileName);
 
 		run(yamlFileName);
 	}
 
 	protected final void run(
 		final String yamlFileName
 	) throws IOException, GuixerSyntaxException {
 
 		checkNotNull(yamlFileName, "yamlFileName");
 
 		System.out.println("Incoming call: run(\"" + yamlFileName + "\")... Looking for corresponding file...");
 
 		final File yamlFile;
 
 		final URL yamlUrl = Thread.currentThread().getContextClassLoader().getResource(yamlFileName);
 
 		if (yamlUrl != null) {
 
 			final String protocol = yamlUrl.getProtocol();
 
 			checkState("file".equals(protocol), "Protocol should be \"file:\", but was: " + yamlUrl);
 
 			final String path = yamlUrl.getPath();
 
 			final String decoded = URLDecoder.decode(path, UTF_8);
 
 			yamlFile = new File(decoded);
 
 			if (!yamlFile.isFile()) {
 
 				throw new FileNotFoundException(decoded);
 			}
 
 		} else {
 
 			yamlFile = findSomeYamlFileIn(yamlFileName, new File[] { //
 					new File("target/classes"), //
 					new File("target/test-classes"), //
 					new File("src/main/yaml"), //
 					new File("src/test/yaml"), //
 					new File("src/main/resources"), //
 					new File("src/test/resources"), //
 			});
 		}
 
 		System.out.println("Using: " + yamlFile.getCanonicalPath());
 
 		run(yamlFile);
 	}
 
 	private static File findSomeYamlFileIn(
 		final String fileName,
 		final File[] dirs
 	) throws IOException {
 
 		final List<String> yamlFileNames = newArrayList();
 
 		if (fileName.endsWith(".yaml")) {
 
 			yamlFileNames.add(fileName);
 
 		} else {
 
 			yamlFileNames.add(fileName + ".yaml");
 			yamlFileNames.add(fileName + ".yml");
 
 			if (fileName.endsWith("Test")) {
 
 				final String prefix = substringBeforeLast(fileName, "Test");
 
 				yamlFileNames.add(prefix + ".yaml");
 				yamlFileNames.add(prefix + ".yml");
 			}
 		}
 
 		for (final File dir : dirs) {
 
 			for (final String yamlFileName : yamlFileNames) {
 
 				final File yamlFile = new File(dir, yamlFileName);
 
 				if (yamlFile.isFile()) {
 
 					return yamlFile;
 				}
 			}
 		}
 
 		throw new FileNotFoundException("Could not find: " + fileName //
 				+ " and alternates, in: " + join(Arrays.asList(dirs).stream() //
 						.map(dir -> dir.getName()) //
 						.collect(Collectors.toList()), ", "));
 	}
 
 	protected final void run(
 		final File yamlFile
 	) throws IOException, GuixerSyntaxException {
 
 		System.out.println("Incoming call: run(File:" + yamlFile.getName() + ")...");
 
 		checkNotNull(yamlFile, "yamlFile");
 
 		if (!yamlFile.isFile()) {
 
 			throw new FileNotFoundException("yamlFile: " + yamlFile.getCanonicalPath());
 		}
 
 		final GuixerScenario scenario = GuixerScenarioLoader2.load(yamlFile);
 
 		run(scenario);
 	}
 
 	protected final void run(
 		final GuixerScenario scenario
 	) throws IOException {
 
 		checkNotNull(scenario, "scenario");
 
 		final ExecutionContext context = new AbstractExecutionContext(new Functions() {
 
 			@Override
 			public String executeFunction(
 				final String functionName
 			) {
 
 				return GuixerTest.this.executeFunction(functionName);
 			}
 
 		}) {
 
 			@Override
 			public WebDriver getDriver() {
 
 				return GuixerTest.this.getDriver();
 			}
 
 			@Override
 			public void switchToDriver(
 				final String driverName
 			) {
 
 				GuixerTest.this.switchToDriver(driverName);
 			}
 		};
 
 		final Properties properties = getTestProperties();
 
 		for (final Entry<Object, Object> entry : properties.entrySet()) {
 
 			final String propertyName = entry.getKey().toString();
 			final String propertyValue = entry.getValue().toString();
 
 			context.setVariable(propertyName, propertyValue);
 		}
 
 		for (final Map.Entry<String, String> entry : scenario.getEnvironmentVariables().entrySet()) {
 
 			context.setVariable(entry.getKey(), entry.getValue());
 		}
 
 		new ScenarioRunner(context, new Callables() {
 
 			@Override
 			public void call(
 				final String callableName
 			) throws IOException {
 
 				GuixerTest.this.call(callableName);
 			}
 
 			@Override
 			public void execute(
 				final GuixerConsumer consumer
 			) throws IOException {
 
 				consumer.accept(GuixerTest.this.getRunnerContext());
 			}
 
 		}, scenario).run(runnerContext -> {
 
 			this.runnerContext = runnerContext;
 		});
 
 		runnerContext = null;
 	}
 
 	private static String extractScenarioFileNameFromCurrentThread() {
 
 		String yamlFileName = null;
 		String testClassSimpleName = null;
 
 		for (final StackTraceElement ste : Thread.currentThread().getStackTrace()) {
 
 			final String className = ste.getClassName();
 			final String methodName = ste.getMethodName();
 
 			final Class<?> clazz;
 
 			try {
 
 				clazz = Class.forName(className);
 
 			} catch (final ClassNotFoundException e) {
 
 				continue;
 			}
 
 			final Method method;
 
 			try {
 
 				method = clazz.getMethod(methodName);
 
 			} catch (final NoSuchMethodException e) {
 
 				continue;
 			}
 
 			if (method.isAnnotationPresent(Test.class)) {
 
 				testClassSimpleName = clazz.getSimpleName();
 
 				@Nullable
 				final Scenario scenarioMethodAnnotation = method.getAnnotation(Scenario.class);
 
 				if (scenarioMethodAnnotation != null) {
 
 					yamlFileName = scenarioMethodAnnotation.value();
 
 				} else {
 
 					@Nullable
 					final Scenario scenarioClassAnnotation = clazz.getAnnotation(Scenario.class);
 
 					if (scenarioClassAnnotation != null) {
 
 						yamlFileName = scenarioClassAnnotation.value();
 
 					} else {
 
 						@Nullable
 						final String superClassYamlFileName = extractScenarioFileNameFromSuperClasses(clazz);
 
 						if (superClassYamlFileName != null) {
 
 							yamlFileName = superClassYamlFileName;
 						}
 					}
 				}
 			}
 		}
 
 		if (yamlFileName != null) {
 
 			return yamlFileName;
 
 		} else if (testClassSimpleName != null) {
 
 			return testClassSimpleName;
 		}
 
 		throw new IllegalStateException("We should be within a call to a @Scenario-annotated method.");
 	}
 
 	@Nullable
 	private static String extractScenarioFileNameFromSuperClasses(
 		final Class<?> clazz
 	) {
 
 		@Nullable
 		final Class<?> superClass = clazz.getSuperclass();
 
 		if (superClass != null) {
 
 			@Nullable
 			final Scenario scenarioAnnotation = clazz.getAnnotation(Scenario.class);
 
 			if (scenarioAnnotation != null) {
 
 				return scenarioAnnotation.value();
 			}
 
 			@Nullable
 			final String superClassYamlFileName = extractScenarioFileNameFromSuperClasses(superClass);
 
 			if (superClassYamlFileName != null) {
 
 				return superClassYamlFileName;
 			}
 		}
 
 		for (final Class<?> implementedInterface : clazz.getInterfaces()) {
 
 			@Nullable
 			final Scenario scenarioAnnotation = clazz.getAnnotation(Scenario.class);
 
 			if (scenarioAnnotation != null) {
 
 				return scenarioAnnotation.value();
 			}
 
 			@Nullable
 			final String interfaceYamlFileName = extractScenarioFileNameFromSuperClasses(implementedInterface);
 
 			if (interfaceYamlFileName != null) {
 
 				return interfaceYamlFileName;
 			}
 		}
 
 		return null;
 	}
 
 	/**
 	 * Values are either instances of <code>GuixerConsumer</code>, or of
 	 * <code>GuixerRunnable</code>
 	 */
 	private final Map<String, Object> callables = newHashMap();
 
 	protected final void registerCallable(
 		final String callableName,
 		final GuixerConsumer callable
 	) {
 
 		checkNotNull(callableName, "callableName");
 		checkNotNull(callable, "callable");
 
 		callables.put(callableName, callable);
 	}
 
 	protected final void registerCallable(
 		final String callableName,
 		final GuixerRunnable callable
 	) {
 
 		checkNotNull(callableName, "callableName");
 		checkNotNull(callable, "callable");
 
 		callables.put(callableName, callable);
 	}
 
 	private void call(
 		final String callableName
 	) throws IOException {
 
 		@Nullable
 		final Object callable = callables.get(callableName);
 
 		if (callable == null) {
 			throw new IllegalStateException("Unknown callable: " + callableName //
 					+ "\nYou should call registerCallable() prior to using \"call\" in a scenario.");
 		}
 
 		if (callable instanceof GuixerConsumer) {
 
 			final GuixerConsumer consumer = (GuixerConsumer) callable;
 
 			consumer.accept(getRunnerContext());
 
 		} else if (callable instanceof GuixerRunnable) {
 
 			final GuixerRunnable runnable = (GuixerRunnable) callable;
 
 			runnable.run();
 
 		} else {
 
 			throw new IllegalStateException(
 					"callable should be either an instance of Consumer<RunnerContext>, or of Runnable, but was: "
 							+ callable.getClass().getName());
 		}
 	}
 
 	/**
 	 * Values are either instances of
 	 * <code>Function&lt;RunnerContext, String&gt;</code>, or of
 	 * <code>Callable&lt;String&gt;</code>,
 	 */
 	private final Map<String, Object> functions = newHashMap();
 
 	protected final void registerFunction(
 		final String functionName,
 		final Function<RunnerContext, String> function
 	) {
 
 		checkNotNull(functionName, "functionName");
 		checkNotNull(function, "function");
 
 		functions.put(functionName, function);
 	}
 
 	protected final void registerFunction(
 		final String functionName,
 		final Callable<String> function
 	) {
 
 		checkNotNull(functionName, "functionName");
 		checkNotNull(function, "function");
 
 		functions.put(functionName, function);
 	}
 
 	private String executeFunction(
 		final String functionName
 	) {
 
 		@Nullable
 		final Object function = functions.get(functionName);
 
 		if (function == null) {
 			throw new IllegalStateException("Unknown function: " + functionName //
 					+ "\nYou should call registerFunction() prior to using a function in a filtered value.");
 		}
 
 		if (function instanceof Function) {
 
 			@SuppressWarnings("unchecked")
 			final Function<RunnerContext, String> f = (Function<RunnerContext, String>) function;
 
 			return f.apply(getRunnerContext());
 
 		} else if (function instanceof Callable) {
 
 			@SuppressWarnings("unchecked")
 			final Callable<String> callable = (Callable<String>) function;
 
 			try {
 
 				return callable.call();
 
 			} catch (final Exception e) {
 
 				throw new RuntimeException("While calling function: " + functionName, e);
 			}
 
 		} else {
 
 			throw new IllegalStateException(
 					"function should be either an instance of Function<RunnerContext, String>, or of Callable<String>, but was: "
 							+ function.getClass().getName());
 		}
 	}
 
 	private final Map<String, WebDriver> drivers = newHashMap();
 
 	final void injectDriver(
 		final WebDriver driver
 	) {
 
 		injectDriver("", driver);
 	}
 
 	final void injectDriver(
 		final String name,
 		final WebDriver driver
 	) {
 
 		checkNotNull(name, "name");
 		checkNotNull(driver, "driver");
 
 		drivers.put(name, driver);
 	}
 }