package geniusweb.profile;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.HashSet;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.Set;

import com.fasterxml.jackson.annotation.JsonCreator;
import com.fasterxml.jackson.annotation.JsonGetter;
import com.fasterxml.jackson.annotation.JsonProperty;

import geniusweb.issuevalue.Bid;
import geniusweb.issuevalue.Domain;

/**
 * Default implementation of partial ordering that stores all is-better
 * relations explicitly in a map.
 * 
 * NOTICE this can handle profiles of max size Integer. This is because various
 * functions used here rely on basic java functions that can handle only int.
 * Besides, the size of partial maps grows very rapidly so this approach is
 * limited anyway.
 */
public class DefaultPartialOrdering extends DefaultProfile
		implements PartialOrdering {

	/**
	 * Set is sparsely filled. If a Bid is not a key, it is not better than any
	 * other bid.
	 */
	private final Map<Bid, Set<Bid>> isBetter;

	/**
	 * 
	 * @param name           name of the profile
	 * @param domain         the {@link Domain}
	 * @param reservationbid the reservation bid, this is the minimum acceptable
	 *                       bid
	 * @param bids           a list of bids that this ordering contains
	 *                       comparisons for
	 * @param isbetterList   a list of tuples [bid1index, bid2index]. It
	 *                       indicates that bids[bid1index] isbetterthan
	 *                       bids[bid2index].
	 */
	@JsonCreator
	public DefaultPartialOrdering(@JsonProperty("name") String name,
			@JsonProperty("domain") Domain domain,
			@JsonProperty("reservationBid") Bid reservationbid,
			@JsonProperty("bids") List<Bid> bids,
			@JsonProperty("better") List<List<Integer>> isbetterList) {
		this(name, domain, reservationbid, makeBidMap(bids, isbetterList));
	}

	/**
	 * @param name           the name for the profile
	 * @param domain         the {@link Domain} description
	 * @param reservationbid the reservation {@link Bid}
	 * @param isBetterMap    a map with keys = a better bid and value=a less
	 *                       good bid.
	 */
	public DefaultPartialOrdering(String name, Domain domain,
			Bid reservationbid, Map<Bid, Set<Bid>> isBetterMap) {
		super(name, domain, reservationbid);
		this.isBetter = isBetterMap;
	}

	@Override
	public boolean isPreferredOrEqual(Bid bid1, Bid bid2) {
		if (!isBetter.containsKey(bid1))
			return false;
		return isBetter.get(bid1).contains(bid2);
	}

	/**
	 * 
	 * @return a list with all the bids that are referred to, either as better
	 *         or as worse than another bid
	 */
	@JsonGetter
	public List<Bid> getBids() {
		// FIXME the iteration order may not be guaranteed!
		Set<Bid> bids = new HashSet<>();
		for (Bid bid : isBetter.keySet()) {
			bids.add(bid);
			bids.addAll(isBetter.get(bid));
		}
		return new ArrayList<Bid>(bids);
	}

	@JsonGetter
	/**
	 * 
	 * @return a list of tuples [bid1index, bid2index]. It indicates that
	 *         bids[bid1index] isbetterthan bids[bid2index].
	 */
	public List<List<Integer>> getBetter() {
		List<List<Integer>> betterlist = new LinkedList<>();
		List<Bid> bidslist = getBids();

		for (Bid bid : bidslist) {
			if (isBetter.containsKey(bid)) {
				for (Bid worsebid : isBetter.get(bid)) {
					betterlist.add(Arrays.asList(bidslist.indexOf(bid),
							bidslist.indexOf(worsebid)));
				}
			}
		}

		return betterlist;
	}

	@Override
	public String toString() {
		return "DefaultPartialOrdering[" + getValuesString() + "," + isBetter
				+ "]";
	}

	private static Map<Bid, Set<Bid>> makeBidMap(List<Bid> bids,
			List<List<Integer>> isBetterList) {
		Map<Bid, Set<Bid>> betterMap = new HashMap<>();

		for (List<Integer> tuple : isBetterList) {
			if (tuple.size() != 2) {
				throw new IllegalArgumentException("Expected tuple but found "
						+ tuple + "in " + isBetterList);
			}
			Bid betterbid = bids.get(tuple.get(0));
			Set<Bid> map = betterMap.get(betterbid);
			if (map == null) {
				map = new HashSet<>();
				betterMap.put(betterbid, map);
			}
			map.add(bids.get(tuple.get(1)));
		}

		return betterMap;
	}

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

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

}