package geniusweb.simplerunner;

import java.io.IOException;
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;
import java.net.URI;
import java.net.URISyntaxException;
import java.util.LinkedList;
import java.util.List;

import geniusweb.actions.Action;
import geniusweb.actions.PartyId;
import geniusweb.inform.Inform;
import geniusweb.party.Party;
import geniusweb.protocol.partyconnection.ProtocolToPartyConn;
import geniusweb.protocol.partyconnection.ProtocolToPartyConnFactory;
import geniusweb.references.Reference;
import tudelft.utilities.repository.NoResourcesNowException;

/**
 * A connectionfactory that only accepts URLs of the form
 * <code>classpath:org/my/package/class</code>
 * 
 */
public class ClassPathConnectionFactory implements ProtocolToPartyConnFactory {
	private List<ConnectionPair> allConnections = new LinkedList<>();

	/**
	 * @param reference the party class path reference4
	 */
	@Override
	public ProtocolToPartyConn connect(Reference reference) {
		ConnectionPair connpair = new ConnectionPair(reference);
		allConnections.add(connpair);
		return connpair.getProtocolToPartyConn();
	}

	@Override
	public List<ProtocolToPartyConn> connect(List<Reference> references)
			throws IOException, NoResourcesNowException {
		List<ProtocolToPartyConn> connections = new LinkedList<>();
		for (Reference partyref : references) {
			connections.add(connect(partyref));
		}
		return connections;
	}

	/**
	 * @return list of connections that are still open.
	 */
	public List<BasicConnection> getOpenConnections() {
		List<BasicConnection> open = new LinkedList<>();
		for (ConnectionPair connpair : allConnections) {
			open.addAll(connpair.getOpenConnections());
		}
		return open;
	}

}

class BasicConnectionWithParty extends BasicConnection<Action, Inform>
		implements ProtocolToPartyConn {

	private PartyId id;

	public BasicConnectionWithParty(Reference reference, URI uri) {
		super(reference, uri);
		this.id = new PartyId(uri.toString().replace("classpath:", "")
				.replaceAll("\\.", "_"));
	}

	@Override
	public PartyId getParty() {
		return id;
	}

	@Override
	public String toString() {
		return "WP" + super.toString();
	}

}

/**
 * Contains the connection from protocol to party and from party to protocol.
 * These two are dependent on each other, and must close together.
 *
 */
class ConnectionPair {
	private static int serialcounter = 1;
	private static final String SCHEME = "classpath";
	private final static URI PROTOCOLURI = uri("protocol:protocol");

	private final BasicConnection<Inform, Action> party2protocol;
	private final BasicConnectionWithParty protocol2party;

	/**
	 * 
	 * @param reference the party class path reference4
	 * 
	 */
	public ConnectionPair(Reference reference) {
		// set up the whole other party including the connection to it.
		String classpath = getClassPath(reference.getURI());
		Party party = instantiate(classpath);

		// if call to protocol would fail, we should also close the
		// protocol2party connection. But we assume that will work fine.
		party2protocol = new BasicConnection<Inform, Action>(reference,
				PROTOCOLURI) {

			@Override
			public void close() {
				if (isOpen()) {
					super.close();
					protocol2party.close();
				}
			}

		};

		// if callback from protocol to party fails, then also close the
		// other direction.
		protocol2party = new BasicConnectionWithParty(reference,
				uri("classpath:" + reference.getURI().getSchemeSpecificPart()
						+ "." + (serialcounter++))) {
			@Override
			public void close() {
				if (isOpen()) {
					super.close();
					party2protocol.close();
				}
			}

		};

		party2protocol.init(action -> protocol2party.notifyListeners(action));

		protocol2party.init(info -> party2protocol.notifyListeners(info));

		party.connect(party2protocol);

	}

	/**
	 * 
	 * @return the open connections
	 */
	public List<BasicConnection> getOpenConnections() {
		List<BasicConnection> open = new LinkedList<>();
		if (party2protocol.isOpen())
			open.add(party2protocol);
		if (protocol2party.isOpen())
			open.add(protocol2party);
		return open;
	}

	public BasicConnectionWithParty getProtocolToPartyConn() {
		return protocol2party;
	}

	/**
	 * Internal use for testing
	 */
	protected BasicConnection getPartyToProtocolConn() {
		return party2protocol;
	}

	/**
	 * 
	 * @param classpath
	 * @return instance of the given {@link Party} on the classpath
	 * @throws IllegalArgumentException if the Party can not be instantiated, eg
	 *                                  because of a ClassCastException,
	 *                                  ClassNotFoundException,
	 *                                  IllegalAccessException etc. Such an
	 *                                  exception is considered a bug by the
	 *                                  programmer, because this is a
	 *                                  stand-alone runner.
	 */
	@SuppressWarnings("unchecked")
	private Party instantiate(String classpath) {
		System.out.println("Connecting with party '" + classpath + "'");
		Class<Party> partyclass;
		try {
			partyclass = (Class<Party>) Class.forName(classpath);
			Constructor<Party> ctor = partyclass.getConstructor();
			return ctor.newInstance(new Object[] {});
		} catch (ClassNotFoundException | NoSuchMethodException
				| SecurityException | InstantiationException
				| IllegalAccessException | IllegalArgumentException
				| InvocationTargetException e) {
			throw new IllegalArgumentException(
					"Failed to create connection to party " + classpath, e);
		}

	}

	private static URI uri(String ref) {
		try {
			return new URI(ref);
		} catch (URISyntaxException e) {
			throw new IllegalStateException("failed to create basic URI", e);
		}
	}

	private String getClassPath(URI uri) {
		if (!SCHEME.equals(uri.getScheme())) {
			throw new IllegalArgumentException("Required the " + SCHEME
					+ " protocol but found " + uri.getScheme());
		}
		String path = uri.getSchemeSpecificPart();
		if (path == null) {
			throw new IllegalArgumentException(
					"Expected classpath but found null  in " + uri);
		}
		return path;
	}

}