/*
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you under the Apache License, Version 2.0 (the
 * "License"); you may not use this file except in compliance
 * with the License.  You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package org.apache.pig.test;

import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertTrue;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.ByteArrayInputStream;
import java.io.File;
import java.io.FileWriter;
import java.io.InputStreamReader;
import java.io.IOException;
import java.io.Writer;
import java.net.URI;
import java.net.URISyntaxException;
import java.util.Properties;

import org.apache.pig.ExecType;
import org.apache.pig.impl.PigContext;
import org.apache.pig.PigServer;
import org.apache.pig.parser.ParserException;
import org.apache.pig.parser.RegisterResolver;
import org.apache.pig.tools.grunt.Grunt;
import org.junit.After;
import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
import org.mockito.Mockito;
import org.apache.pig.impl.util.PropertiesUtil;
import org.apache.hadoop.fs.LocalFileSystem;


public class TestRegisterParser {
    private PigServer pigServer;
    private static final String TEST_JAR_DIR = "/tmp/";

    @Before
    public void setUp() throws Exception {
        Properties properties = PropertiesUtil.loadDefaultProperties();
        properties.setProperty("fs.s3.impl", LocalFileSystem.class.getName());
        properties.setProperty("fs.s3n.impl", LocalFileSystem.class.getName());
        properties.setProperty("fs.s3a.impl", LocalFileSystem.class.getName());

	pigServer = new PigServer(ExecType.LOCAL, properties);

	// Generate test jar files
	for (int i = 1; i <= 5; i++) {
	    Writer output = null;
	    String dataFile = TEST_JAR_DIR + "testjar-" + i + ".jar";
	    File file = new File(dataFile);
	    output = new BufferedWriter(new FileWriter(file));
	    output.write("sample");
	    output.close();
	}
    }

    // Test to check if registering a jar using a file resolver adds the right jar to the classpath.
    @Test
    public void testRegisterArtifactWithFileResolver() throws Throwable {
	PigContext context = pigServer.getPigContext();

	File confFile = new File("test/org/apache/pig/test/data/testivysettings.xml");
	System.setProperty("grape.config", confFile.toString());

	// 'changing=true' tells Grape to re-fetch the jar rather than picking it from the groovy cache.
	String strCmd = "register ivy://testgroup:testjar:1?changing=true\n";
	ByteArrayInputStream cmd = new ByteArrayInputStream(strCmd.getBytes());
	InputStreamReader reader = new InputStreamReader(cmd);

	Grunt grunt = new Grunt(new BufferedReader(reader), context);
	grunt.exec();

	assertEquals(context.extraJars + " of size 1", 1, context.extraJars.size());
	assertTrue(context.extraJars.get(0) + " ends with /testjar-1.jar",
		context.extraJars.get(0).toString().endsWith("/testjar-1.jar"));
    }

    // Test to check if all dependencies are successfully added to the classpath
    @Test
    public void testRegisterArtifact() throws URISyntaxException, IOException, ParserException {
	URI[] list = new URI[5];
	list[0] = new URI(TEST_JAR_DIR + "testjar-1.jar");
	list[1] = new URI(TEST_JAR_DIR + "testjar-2.jar");
	list[2] = new URI(TEST_JAR_DIR + "testjar-3.jar");
	list[3] = new URI(TEST_JAR_DIR + "testjar-4.jar");
	list[4] = new URI(TEST_JAR_DIR + "testjar-5.jar");

	// Make sure that the jars are not in the classpath
	for (URI dependency : list) {
	    Assert.assertFalse(pigServer.getPigContext().hasJar(dependency.toString()));
	}

	RegisterResolver registerResolver = Mockito.spy(new RegisterResolver(pigServer));
	Mockito.doReturn(list).when(registerResolver).resolve(new URI("ivy://testQuery"));
	registerResolver.parseRegister("ivy://testQuery", null, null);

	for (URI dependency : list) {
	    Assert.assertTrue(pigServer.getPigContext().hasJar(dependency.toString()));
	}
    }

    @Test
    public void testResolveForVariousFileSystemSchemes() throws URISyntaxException, IOException, ParserException {
        URI[] list = new URI[6];
        list[0] = new URI("file://test.jar");
        list[1] = new URI("hdfs://test.jar");
        list[2] = new URI("s3://test.jar");
        list[3] = new URI("s3n://test.jar");
        list[4] = new URI("s3a://test.jar");
        list[5] = new URI("test.jar");

        RegisterResolver registerResolver = new RegisterResolver(pigServer);
        for (URI uri : list) {
            URI[] resolvedUris = registerResolver.resolve(uri);
	    Assert.assertEquals(1, resolvedUris.length);
            Assert.assertEquals(uri, resolvedUris[0]);
        }
    }

    @Test(expected = ParserException.class)
    public void testResolveParseException() throws URISyntaxException, IOException, ParserException {
        new RegisterResolver(pigServer).resolve(new URI("abc://test.jar"));
    }

    @Test(expected = URISyntaxException.class)
    public void testResolveURISyntaxException() throws URISyntaxException, IOException, ParserException {
        new RegisterResolver(pigServer).resolve(new URI("123://test.jar"));
    }

    // Throw error when a scripting language and namespace is specified for a jar
    @Test(expected = ParserException.class)
    public void testRegisterJarException1() throws IOException, ParserException {
	new RegisterResolver(pigServer).parseRegister("test.jar", "jython", "myfunc");
    }

    // Throw error when a scripting language and namespace is specified for an ivy coordinate
    @Test(expected = ParserException.class)
    public void testRegisterJarException2() throws IOException, ParserException {
	new RegisterResolver(pigServer).parseRegister("ivy://org:mod:ver", "jython", "myfunc");
    }

    // Throw error when a scripting language is specified for a jar
    @Test(expected = ParserException.class)
    public void testRegisterJarException3() throws IOException, ParserException {
	new RegisterResolver(pigServer).parseRegister("test.jar", "jython", null);
    }

    // Throw error when an Illegal URI is passed
    @Test(expected = ParserException.class)
    public void testIllegalUriException() throws IOException, ParserException {
	new RegisterResolver(pigServer).parseRegister("ivy:||org:mod:ver", null, null);
    }

    @After
    public void close() {
	// delete sample jars
	for (int i = 1; i <= 5; i++) {
	    String dataFile = TEST_JAR_DIR + "testjar-" + i + ".jar";

	    File f = new File(dataFile);
	    if (!f.delete()) {
		throw new RuntimeException("Could not delete the data file");
	    }
	}
    }
}