/*******************************************************************************
 * Copyright (c) 2007, 2017 IBM Corporation and others.
 *
 * 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
 *
 * Contributors:
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/
package org.eclipse.core.tests.net;

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

import java.net.URI;
import java.net.URISyntaxException;
import java.util.*;

import org.eclipse.core.internal.net.ProxyData;
import org.eclipse.core.internal.net.ProxyType;
import org.eclipse.core.net.proxy.IProxyData;
import org.eclipse.core.net.proxy.IProxyService;
import org.eclipse.core.runtime.CoreException;
import org.junit.*;

public class NetTest {

	private static final boolean BUG_338097 = true;

	private boolean isSetEnabled;
	private boolean isProxiesDefault;
	private boolean isSystemProxiesDefault;
	private final Map<String, IProxyData> dataCache = new HashMap<>();

	@Before
	public void setUp() throws Exception {
		isSystemProxiesDefault = isSystemProxiesEnabled();
		setSystemProxiesEnabled(false);
		isProxiesDefault = isProxiesEnabled();
		setProxiesEnabled(true);
		isSetEnabled = true;
		dataCache.clear();
		ProxyType.socksSystemPropertySetting = ProxyType.ALWAYS_SET;
	}

	@After
	public void tearDown() throws Exception {
		setProxiesEnabled(isProxiesDefault);
		setSystemProxiesEnabled(isSystemProxiesDefault);
		IProxyData[] data = getProxyManager().getProxyData();
		for (IProxyData proxyData : data) {
			proxyData.disable();
		}
		getProxyManager().setProxyData(data);
	}

	private IProxyService getProxyManager() {
		return Activator.getProxyService();
	}

	private void assertProxyDataEqual(IProxyData expected) {
		ProxyData expectedData = (ProxyData) expected;
		ProxyData data = (ProxyData) getProxyManager().getProxyData(expectedData.getType());
		assertEquals(expectedData.getType(), data.getType());
		assertEquals(expectedData.getHost(), data.getHost());
		assertEquals(expectedData.getPort(), data.getPort());
		assertEquals(expectedData.getUserId(), data.getUserId());
		assertEquals(expectedData.getPassword(), data.getPassword());
		assertEquals(expectedData.isRequiresAuthentication(), data.isRequiresAuthentication());
		assertEquals(expectedData.getSource(), data.getSource());
		assertSystemPropertiesMatch(data);
	}

	public void assertSystemPropertiesMatch(IProxyData proxyData) {
		if (proxyData.getType().equals(IProxyData.HTTP_PROXY_TYPE)) {
			assertHttpSystemProperties(proxyData, "http");
		} else if (proxyData.getType().equals(IProxyData.HTTPS_PROXY_TYPE)) {
			assertHttpSystemProperties(proxyData, "https");
		} else if (proxyData.getType().equals(IProxyData.SOCKS_PROXY_TYPE)) {
			assertSocksSystemProperties(proxyData);
		}
	}

	private void assertHttpSystemProperties(IProxyData proxyData, String keyPrefix) {
		Properties sysProps = System.getProperties();

		if (this.getProxyManager().isProxiesEnabled()) {
			boolean isSet = Boolean.getBoolean(keyPrefix + ".proxySet");
			assertEquals(proxyData.getHost() != null, isSet); // $NON-NLS-1$
			assertEquals(proxyData.getHost(), sysProps.get(keyPrefix + ".proxyHost")); //$NON-NLS-1$
			String portString = (String) sysProps.get(keyPrefix + ".proxyPort"); //$NON-NLS-1$
			int port = -1;
			if (portString != null)
				port = Integer.parseInt(portString);
			assertEquals(proxyData.getPort(), port);
			if (isSet)
				assertEquals(ProxyType.convertHostsToPropertyString(this.getProxyManager().getNonProxiedHosts()),
						sysProps.get(keyPrefix + ".nonProxyHosts")); //$NON-NLS-1$
			else
				assertNull(sysProps.get(keyPrefix + ".nonProxyHosts"));
			assertEquals(proxyData.getUserId(), sysProps.get(keyPrefix + ".proxyUser")); //$NON-NLS-1$
			assertEquals(proxyData.getUserId(), sysProps.get(keyPrefix + ".proxyUserName")); //$NON-NLS-1$
			assertEquals(proxyData.getPassword(), sysProps.get(keyPrefix + ".proxyPassword")); //$NON-NLS-1$
		} else {
			assertNull(sysProps.get(keyPrefix + ".proxySet"));
			assertNull(sysProps.get(keyPrefix + ".proxyHost"));
			assertNull(sysProps.get(keyPrefix + ".proxyPort"));
			assertNull(sysProps.get(keyPrefix + ".nonProxyHosts"));
			assertNull(sysProps.get(keyPrefix + ".proxyUser"));
			assertNull(sysProps.get(keyPrefix + ".proxyUserName"));
			assertNull(sysProps.get(keyPrefix + ".proxyPassword"));
		}
	}

	private void assertSocksSystemProperties(IProxyData proxyData) {
		Properties sysProps = System.getProperties();
		if (this.getProxyManager().isProxiesEnabled()) {
			assertEquals(proxyData.getHost(), sysProps.get("socksProxyHost")); //$NON-NLS-1$
			String portString = (String) sysProps.get("socksProxyPort"); //$NON-NLS-1$
			int port = -1;
			if (portString != null)
				port = Integer.parseInt(portString);
			assertEquals(proxyData.getPort(), port);
		} else {
			assertNull(sysProps.get("socksProxyHost"));
			assertNull(sysProps.get("socksProxyPort"));
		}
	}

	private IProxyData getProxyData(String type) {
		IProxyData data = (IProxyData) dataCache.get(type);
		if (data == null) {
			data = this.getProxyManager().getProxyData(type);
			assertProxyDataEqual(data);
		}
		return data;
	}

	private void setProxyData(IProxyData data) throws CoreException {
		if (isSetEnabled) {
			this.getProxyManager().setProxyData(new IProxyData[] { data });
			assertProxyDataEqual(data);
		} else {
			dataCache.put(data.getType(), data);
		}
	}

	private void disableProxy(IProxyData proxyData) throws CoreException {
		proxyData.disable();
		setProxyData(proxyData);
	}

	private void changeProxyData(IProxyData oldData, IProxyData data) throws CoreException {
		// Make sure that setting the host doesn't change the persisted settings
		if (isSetEnabled)
			assertProxyDataEqual(oldData);
		// Now set it in the manager and assert that it is set
		setProxyData(data);
	}

	private void setHost(String type) throws CoreException {
		String host = "www.eclipse.org";
		setHost(type, host);
	}

	private void setHost(String type, String host) throws CoreException {
		IProxyData data = getProxyData(type);
		IProxyData oldData = getProxyData(type);
		data.setHost(host);
		changeProxyData(oldData, data);
	}

	private void setPort(String type, int port) throws CoreException {
		IProxyData data = getProxyData(type);
		IProxyData oldData = getProxyData(type);
		data.setPort(port);
		changeProxyData(oldData, data);
	}

	private void setUser(String type, String user, String password) throws CoreException {
		IProxyData data = getProxyData(type);
		IProxyData oldData = getProxyData(type);
		data.setUserid(user);
		data.setPassword(password);
		changeProxyData(oldData, data);
	}

	private void setDataTest(String type) throws CoreException {
		setHost(type, "www.eclipse.org");
		setPort(type, 1024);
		setUser(type, "me", "passw0rd");
	}

	private boolean isProxiesEnabled() {
		return this.getProxyManager().isProxiesEnabled();
	}

	private boolean isSystemProxiesEnabled() {
		return this.getProxyManager().isProxiesEnabled();
	}

	private void setProxiesEnabled(boolean enabled) {
		this.getProxyManager().setProxiesEnabled(enabled);
		if (enabled && this.getProxyManager().isSystemProxiesEnabled() && !this.getProxyManager().hasSystemProxies()) {
			assertEquals(false, this.getProxyManager().isProxiesEnabled());
		} else {
			assertEquals(enabled, this.getProxyManager().isProxiesEnabled());
		}
	}

	private void setSystemProxiesEnabled(boolean enabled) {
		this.getProxyManager().setSystemProxiesEnabled(enabled);
		assertEquals(enabled, this.getProxyManager().isSystemProxiesEnabled());
	}

	private void delaySettingData() {
		isSetEnabled = false;
	}

	private void performSettingData() throws CoreException {
		IProxyData[] data = (IProxyData[]) dataCache.values().toArray(new IProxyData[dataCache.size()]);
		this.getProxyManager().setProxyData(data);
		for (IProxyData proxyData : data) {
			assertProxyDataEqual(proxyData);
		}
		isSetEnabled = true;
		dataCache.clear();
	}

	@Test
	public void testIndividualSetAndClear() throws CoreException {
		setDataTest(IProxyData.HTTP_PROXY_TYPE);
		setDataTest(IProxyData.HTTPS_PROXY_TYPE);
		setDataTest(IProxyData.SOCKS_PROXY_TYPE);
		IProxyData[] data = this.getProxyManager().getProxyData();
		for (IProxyData proxyData : data) {
			disableProxy(proxyData);
		}
	}

	@Test
	public void testAllSetAndClear() throws CoreException {
		delaySettingData();
		setDataTest(IProxyData.HTTP_PROXY_TYPE);
		setDataTest(IProxyData.HTTPS_PROXY_TYPE);
		setDataTest(IProxyData.SOCKS_PROXY_TYPE);
		performSettingData();

		delaySettingData();
		IProxyData[] data = this.getProxyManager().getProxyData();
		for (IProxyData proxyData : data) {
			disableProxy(proxyData);
		}
		performSettingData();
	}

	@Test
	public void testSetWhenDisabled() throws CoreException {
		setProxiesEnabled(false);
		String type = IProxyData.HTTP_PROXY_TYPE;
		setHost(type);
	}

	@Test
	public void testDisableAfterSet() throws CoreException {
		String type = IProxyData.HTTP_PROXY_TYPE;
		setHost(type);
		IProxyData data = this.getProxyManager().getProxyData(type);
		setProxiesEnabled(false);
		assertProxyDataEqual(data);
	}

	@Test
	@Ignore("Disabled due to bug 403311")
	public void _testSimpleHost() throws CoreException {

		setDataTest(IProxyData.HTTP_PROXY_TYPE);
		setDataTest(IProxyData.HTTPS_PROXY_TYPE);
		setDataTest(IProxyData.SOCKS_PROXY_TYPE);

		IProxyData[] allData = this.getProxyManager().getProxyDataForHost("www.randomhot.com");
		assertEquals(3, allData.length);

		IProxyData data = this.getProxyManager().getProxyDataForHost("www.randomhot.com", IProxyData.HTTP_PROXY_TYPE);
		assertNotNull(data);

		allData = this.getProxyManager().getProxyDataForHost("localhost");
		assertEquals(0, allData.length);

		data = this.getProxyManager().getProxyDataForHost("localhost", IProxyData.HTTP_PROXY_TYPE);
		assertNull(data);
	}

	@Test
	public void testHostPattern() throws CoreException {
		setDataTest(IProxyData.HTTP_PROXY_TYPE);
		setDataTest(IProxyData.HTTPS_PROXY_TYPE);
		setDataTest(IProxyData.SOCKS_PROXY_TYPE);

		String[] oldHosts = this.getProxyManager().getNonProxiedHosts();
		this.getProxyManager().setNonProxiedHosts(new String[] { "*ignore.com" });

		IProxyData[] allData = this.getProxyManager().getProxyDataForHost("www.randomhot.com");
		assertEquals(3, allData.length);

		IProxyData data = this.getProxyManager().getProxyDataForHost("www.randomhot.com", IProxyData.HTTP_PROXY_TYPE);
		assertNotNull(data);

		allData = this.getProxyManager().getProxyDataForHost("www.ignore.com");
		assertEquals(0, allData.length);

		data = this.getProxyManager().getProxyDataForHost("www.ignore.com", IProxyData.HTTP_PROXY_TYPE);
		assertNull(data);

		allData = this.getProxyManager().getProxyDataForHost("ignore.com");
		assertEquals(0, allData.length);

		data = this.getProxyManager().getProxyDataForHost("ignore.com", IProxyData.HTTP_PROXY_TYPE);
		assertNull(data);

		this.getProxyManager().setNonProxiedHosts(oldHosts);
	}

	@Test
	public void testHostPatternBug505906() throws CoreException {
		setDataTest(IProxyData.HTTP_PROXY_TYPE);
		setDataTest(IProxyData.HTTPS_PROXY_TYPE);
		setDataTest(IProxyData.SOCKS_PROXY_TYPE);

		String[] oldHosts = this.getProxyManager().getNonProxiedHosts();
		this.getProxyManager().setNonProxiedHosts(new String[] { "ignore.com" });

		IProxyData[] allData = this.getProxyManager().getProxyDataForHost("ignore.com.randomhot.com");
		assertEquals(3, allData.length);

		IProxyData data = this.getProxyManager().getProxyDataForHost("ignore.com.randomhot.com",
				IProxyData.HTTP_PROXY_TYPE);
		assertNotNull(data);

		allData = this.getProxyManager().getProxyDataForHost("www.ignore.com");
		assertEquals(0, allData.length);

		data = this.getProxyManager().getProxyDataForHost("www.ignore.com", IProxyData.HTTP_PROXY_TYPE);
		assertNull(data);

		allData = this.getProxyManager().getProxyDataForHost("ignore.com");
		assertEquals(0, allData.length);

		data = this.getProxyManager().getProxyDataForHost("ignore.com", IProxyData.HTTP_PROXY_TYPE);
		assertNull(data);

		this.getProxyManager().setNonProxiedHosts(oldHosts);
	}

	@Test
	public void testBug238796() throws CoreException {
		setDataTest(IProxyData.HTTP_PROXY_TYPE);
		setDataTest(IProxyData.HTTPS_PROXY_TYPE);
		setDataTest(IProxyData.SOCKS_PROXY_TYPE);

		String[] oldHosts = this.getProxyManager().getNonProxiedHosts();

		this.getProxyManager().setNonProxiedHosts(new String[] { "nonexisting.com" });

		IProxyData[] allData = this.getProxyManager().getProxyDataForHost("NONEXISTING.COM");
		assertEquals(0, allData.length);
		IProxyData data = this.getProxyManager().getProxyDataForHost("NONEXISTING.COM", IProxyData.HTTP_PROXY_TYPE);
		assertNull(data);

		this.getProxyManager().setNonProxiedHosts(oldHosts);
	}

	@Test
	public void testBug247408() throws CoreException, URISyntaxException {
		setDataTest(IProxyData.HTTP_PROXY_TYPE);
		setDataTest(IProxyData.HTTPS_PROXY_TYPE);
		setDataTest(IProxyData.SOCKS_PROXY_TYPE);

		IProxyData data1 = this.getProxyManager().getProxyDataForHost("randomhost.com", IProxyData.HTTP_PROXY_TYPE);
		IProxyData[] data2 = this.getProxyManager().select(new URI("http://randomhost.com"));
		assertEquals(data2.length, 1);
		assertEquals(data1, data2[0]);

		IProxyData data3 = this.getProxyManager().getProxyDataForHost("randomhost.com", null);
		IProxyData[] data4 = this.getProxyManager().select(new URI(null, "randomhost.com", null, null));
		assertNull(data3);
		assertEquals(data4.length, 0);
	}

	@Test
	public void testBug255981() throws CoreException, URISyntaxException {
		setDataTest(IProxyData.HTTP_PROXY_TYPE);
		setDataTest(IProxyData.HTTPS_PROXY_TYPE);
		setDataTest(IProxyData.SOCKS_PROXY_TYPE);

		this.getProxyManager().setProxiesEnabled(false);

		IProxyData data = this.getProxyManager().getProxyDataForHost("randomhost.com", IProxyData.HTTP_PROXY_TYPE);
		assertNull(data);

		IProxyData[] data2 = this.getProxyManager().select(new URI("http://randomhost.com"));
		assertEquals(data2.length, 0);

		IProxyData data3[] = this.getProxyManager().getProxyDataForHost("http://randomhost.com");
		assertEquals(data3.length, 0);
	}

	@Test
	public void testBug257503() throws CoreException {
		if (BUG_338097)
			return;

		setDataTest(IProxyData.HTTP_PROXY_TYPE);
		setDataTest(IProxyData.HTTPS_PROXY_TYPE);
		setDataTest(IProxyData.SOCKS_PROXY_TYPE);

		validateSystemProperties(true);
		setSystemProxiesEnabled(true);
		validateSystemProperties(false);
		setSystemProxiesEnabled(false);
		validateSystemProperties(true);

	}

	@Test
	public void testNonProxyHosts() throws CoreException {
		setDataTest(IProxyData.HTTP_PROXY_TYPE);
		setDataTest(IProxyData.HTTPS_PROXY_TYPE);
		setDataTest(IProxyData.SOCKS_PROXY_TYPE);

		String[] oldHosts = this.getProxyManager().getNonProxiedHosts();

		// add new host to the nonProxiedHosts list
		String testHost = "bug284540.com";
		ArrayList<String> hostsList = new ArrayList<>();
		hostsList.addAll(Arrays.asList(oldHosts));
		hostsList.add(testHost);
		String[] newHosts = hostsList.toArray(new String[] {});

		this.getProxyManager().setNonProxiedHosts(newHosts);

		// check if system properties are updated
		String sysPropNonProxyHosts = System.getProperty("http.nonProxyHosts");
		String assertMessage = "http.nonProxyHost should contain '" + testHost + "', but its current value is '"
				+ sysPropNonProxyHosts + "'";
		assertTrue(assertMessage, sysPropNonProxyHosts.contains(testHost));

		this.getProxyManager().setNonProxiedHosts(oldHosts);
	}

	private void validateSystemProperties(boolean present) {
		validateProperty("http.proxySet", "true", present);
		validateProperty("http.proxyHost", "www.eclipse.org", present);
		validateProperty("http.proxyPort", "1024", present);
		validateProperty("http.proxyUser", "me", present);
		validateProperty("http.proxyUserName", "me", present);
		validateProperty("http.proxyPassword", "passw0rd", present);

		validateProperty("https.proxySet", "true", present);
		validateProperty("https.proxyHost", "www.eclipse.org", present);
		validateProperty("https.proxyPort", "1024", present);
		validateProperty("https.proxyUser", "me", present);
		validateProperty("https.proxyUserName", "me", present);
		validateProperty("https.proxyPassword", "passw0rd", present);

		validateProperty("socksProxyHost", "www.eclipse.org", present);
		validateProperty("socksProxyPort", "1024", present);
	}

	private void validateProperty(String key, String expected, boolean equals) {
		String actual = System.getProperties().getProperty(key);
		assertTrue((equals && expected.equals(actual)) || (!equals && !expected.equals(actual)));
	}

}
