package geniusweb.protocol.partyconnection;

import java.io.IOException;
import java.util.HashMap;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;
import java.util.stream.Stream;

import geniusweb.actions.PartyId;
import geniusweb.inform.Inform;

/**
 * Contains all parties with their connections. immutable
 */
public class ProtocolToPartyConnections
		implements Iterable<ProtocolToPartyConn> {
	private List<ProtocolToPartyConn> connections;

	public ProtocolToPartyConnections(List<ProtocolToPartyConn> connections) {
		this.connections = connections;
	}

	/**
	 * @param id the {@link PartyId} needed
	 * @return a connection with that party, or null if no such connection.
	 */
	public ProtocolToPartyConn get(PartyId id) {
		return connections.stream().filter(conn -> id.equals(conn.getParty()))
				.findAny().orElse(null);
	}

	/**
	 * 
	 * @return true iff all parties have one connection only
	 */
	public boolean allunique() {
		return getParties().size() == connections.size();
	}

	/**
	 * 
	 * @return list of parties currently in the connections.
	 */
	private List<PartyId> getParties() {
		return connections.stream().map(conn -> conn.getParty()).distinct()
				.collect(Collectors.toList());
	}

	/**
	 * Broadcast info to all parties. Notice that the broadcast immediately
	 * aborts if an error occurs and remaining parties will not receive the
	 * event. Therefore it is recommended to instead send to all parties
	 * individually to ensure all parties are handled individually.
	 * 
	 * @param info the {@link Inform} to broadcast
	 * @return a Map&lt;PartyId, IOException&gt; where possible exceptions for
	 *         each party are stored. Normally a protocol would kick these
	 *         parties.
	 */
	public Map<PartyId, IOException> broadcast(Inform info) {
		Map<PartyId, IOException> exceptions = new HashMap<>();
		for (ProtocolToPartyConn conn : connections) {
			try {
				conn.send(info);
			} catch (IOException e) {
				exceptions.put(conn.getParty(), e);
			}
		}
		return exceptions;
	}

	/**
	 * 
	 * @return number of connections available
	 */
	public int size() {
		return connections.size();
	}

	/**
	 * @param i the connection number
	 * @return the ith connection
	 */
	public ProtocolToPartyConn get(int i) {
		return connections.get(i);
	}

	public Stream<ProtocolToPartyConn> stream() {
		return connections.stream();
	}

	@Override
	public Iterator<ProtocolToPartyConn> iterator() {
		return connections.iterator();
	}

	public ProtocolToPartyConnections with(ProtocolToPartyConn conn) {
		List<ProtocolToPartyConn> newconnections = new LinkedList<>(
				connections);
		newconnections.add(conn);
		return new ProtocolToPartyConnections(newconnections);
	}

	@Override
	public String toString() {
		return "ConnectionWithParties" + connections;
	}

	@Override
	public int hashCode() {
		final int prime = 31;
		int result = 1;
		result = prime * result
				+ ((connections == null) ? 0 : connections.hashCode());
		return result;
	}

	@Override
	public boolean equals(Object obj) {
		if (this == obj)
			return true;
		if (obj == null)
			return false;
		if (getClass() != obj.getClass())
			return false;
		ProtocolToPartyConnections other = (ProtocolToPartyConnections) obj;
		if (connections == null) {
			if (other.connections != null)
				return false;
		} else if (!connections.equals(other.connections))
			return false;
		return true;
	}

}