package agents.anac.y2017.agentf.etc;

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.List;
import java.util.Random;

import genius.core.Bid;
import genius.core.issue.Issue;
import genius.core.issue.IssueDiscrete;
import genius.core.issue.IssueInteger;
import genius.core.issue.Value;
import genius.core.issue.ValueDiscrete;
import genius.core.issue.ValueInteger;
import genius.core.list.Tuple;
import genius.core.utility.AbstractUtilitySpace;

public class negotiationInfo {
	private AbstractUtilitySpace utilitySpace; // 効用空間
	private ArrayList<Issue> issues; // 論点
	private ArrayList<Object> opponents; // 自身以外の交渉参加者のList
	private ArrayList<Bid> MyBidHistory = null; // 提案履歴
	private ArrayList<Bid> BOBHistory = null; // BestOfferedBidの更新履歴
	private ArrayList<Bid> PBList = null; // BestPopularBidのリスト
	private HashMap<Object, Integer> opponentsAcceptNum; // acceptした回数
	private HashMap<Object, ArrayList<Bid>> opponentsBidHistory = null; // 提案履歴
	private HashMap<Object, Double> opponentsAverage; // 平均
	private HashMap<Object, Double> opponentsVariance; // 分散
	private HashMap<Object, Double> opponentsSum; // 和
	private HashMap<Object, Double> opponentsPowSum; // 二乗和
	private HashMap<Object, Double> opponentsStandardDeviation; // 標準偏差
	private HashMap<Issue, HashMap<Value, Double>> valueRelativeUtility = null; // 自身の効用空間における各論点値の相対効用値行列（線形効用空間用）
	private HashMap<Issue, HashMap<Value, Integer>> allValueFrequency = null; // 全員分の頻度行列
	private HashMap<Object, HashMap<Issue, HashMap<Value, Integer>>> opponentsValueFrequency = null; // 交渉者別の頻度行列
	private HashMap<Object, HashMap<Issue, ArrayList<Tuple<Value, Integer>>>> opponentsValueOrdinalScale = null; // 交渉者別の各issueごとの順序尺度
	private double BOU = 0.0; // BestOfferedUtility 2者間交渉以外では使わない
	private double MPBU = 0.0; // MaxPopularBidUtility
	private double time_scale = 0.0; // 自分の手番が回ってくる時間間隔
	private int round = 0; // 自分の手番数
	private int negotiatorNum = 3; // 交渉者数（不具合が生じた場合に備えて3人で初期化）
	private boolean isLinerUtilitySpace = true; // 線形効用空間であるかどうか

	private boolean isPrinting = false;

	public negotiationInfo(AbstractUtilitySpace utilitySpace, boolean isPrinting) {
		// 初期化
		this.isPrinting = isPrinting;
		this.utilitySpace = utilitySpace;
		issues = (ArrayList<Issue>) utilitySpace.getDomain().getIssues();
		opponents = new ArrayList<Object>();
		MyBidHistory = new ArrayList<>();
		BOBHistory = new ArrayList<>();
		PBList = new ArrayList<>();
		opponentsAcceptNum = new HashMap<Object, Integer>();
		opponentsBidHistory = new HashMap<Object, ArrayList<Bid>>();
		opponentsAverage = new HashMap<Object, Double>();
		opponentsVariance = new HashMap<Object, Double>();
		opponentsSum = new HashMap<Object, Double>();
		opponentsPowSum = new HashMap<Object, Double>();
		opponentsStandardDeviation = new HashMap<Object, Double>();
		valueRelativeUtility = new HashMap<Issue, HashMap<Value, Double>>();
		allValueFrequency = new HashMap<Issue, HashMap<Value, Integer>>();
		opponentsValueFrequency = new HashMap<Object, HashMap<Issue, HashMap<Value, Integer>>>();
		opponentsValueOrdinalScale = new HashMap<Object, HashMap<Issue, ArrayList<Tuple<Value, Integer>>>>();

		try {
			initAllValueFrequency();
		} catch (Exception e1) {
			System.out.println("全員分の頻度行列の初期化に失敗しました");
			e1.printStackTrace();
		}
		try {
			initValueRelativeUtility();
		} catch (Exception e) {
			System.out.println("相対効用行列の初期化に失敗しました");
			e.printStackTrace();
		}

		if (this.isPrinting) {
			System.out.println("negotiationInfo:success");
		}
	}

	public void initOpponent(Object sender) {
		initNegotiatingInfo(sender); // 交渉情報を初期化
		try {
			initOpponentsValueFrequency(sender);
			initOpponentValueOrdinalScale(sender);
			opponentsAcceptNum.put(sender, 0);
		} // senderの頻度行列を初期化
		catch (Exception e) {
			System.out.println("交渉参加者の頻度行列の初期化に失敗しました");
			e.printStackTrace();
		}
		opponents.add(sender); // 交渉参加者にsenderを追加
	}

	public void updateInfo(Object sender, Bid offeredBid) {
		try {
			updateNegotiatingInfo(sender, offeredBid);
		} // 交渉情報の更新
		catch (Exception e1) {
			System.out.println("交渉情報の更新に失敗しました");
			e1.printStackTrace();
		}
		try {
			updateFrequencyList(sender, offeredBid);
			updateOrdinalScale(sender, offeredBid);
		} // senderの頻度行列の更新
		catch (Exception e) {
			System.out.println("頻度行列の更新に失敗しました");
			e.printStackTrace();
		}
	}

	private void initNegotiatingInfo(Object sender) {
		opponentsBidHistory.put(sender, new ArrayList<Bid>());
		opponentsAverage.put(sender, 0.0);
		opponentsVariance.put(sender, 0.0);
		opponentsSum.put(sender, 0.0);
		opponentsPowSum.put(sender, 0.0);
		opponentsStandardDeviation.put(sender, 0.0);
	}

	private void initOpponentsValueFrequency(Object sender) throws Exception {
		opponentsValueFrequency.put(sender, new HashMap<Issue, HashMap<Value, Integer>>()); // senderの頻度行列の初期化
		for (Issue issue : issues) {
			opponentsValueFrequency.get(sender).put(issue, new HashMap<Value, Integer>()); // 頻度行列における論点行の初期化
			ArrayList<Value> values = getValues(issue);
			for (Value value : values) {
				opponentsValueFrequency.get(sender).get(issue).put(value, 0);
			} // 論点行の要素出現数の初期化
		}
	}

	public void initOpponentValueOrdinalScale(Object sender) throws Exception {
		opponentsValueOrdinalScale.put(sender, new HashMap<Issue, ArrayList<Tuple<Value, Integer>>>()); // senderの頻度行列の初期化
		for (Issue issue : issues) {
			opponentsValueOrdinalScale.get(sender).put(issue, new ArrayList<Tuple<Value, Integer>>()); // 頻度行列における論点行の初期化
		}
	}

	// 全員分の頻度行列の初期化
	private void initAllValueFrequency() throws Exception {
		ArrayList<Value> values = null;
		for (Issue issue : issues) {
			allValueFrequency.put(issue, new HashMap<Value, Integer>()); // 論点行の初期化
			values = getValues(issue);
			for (Value value : values) {
				allValueFrequency.get(issue).put(value, 0);
			} // 論点行の要素の初期化
		}
	}

	// 相対効用行列の初期化
	private void initValueRelativeUtility() throws Exception {
		ArrayList<Value> values = null;
		for (Issue issue : issues) {
			valueRelativeUtility.put(issue, new HashMap<Value, Double>()); // 論点行の初期化
			values = getValues(issue);
			for (Value value : values) {
				valueRelativeUtility.get(issue).put(value, 0.0);
			} // 論点行の要素の初期化
		}
	}

	// 相対効用行列の導出
	public void setValueRelativeUtility(Bid maxBid) throws Exception {
		ArrayList<Value> values = null;
		Bid currentBid = null;
		for (Issue issue : issues) {
			currentBid = new Bid(maxBid);
			values = getValues(issue);
			for (Value value : values) {
				currentBid = currentBid.putValue(issue.getNumber(), value);
				valueRelativeUtility.get(issue).put(value,
						utilitySpace.getUtility(currentBid) - utilitySpace.getUtility(maxBid));
			}
		}
	}

	public void updateNegotiatingInfo(Object sender, Bid offeredBid) throws Exception {
		opponentsBidHistory.get(sender).add(offeredBid); // 提案履歴

		double util = utilitySpace.getUtility(offeredBid);
		opponentsSum.put(sender, opponentsSum.get(sender) + util); // 和
		opponentsPowSum.put(sender, opponentsPowSum.get(sender) + Math.pow(util, 2)); // 二乗和

		int round_num = opponentsBidHistory.get(sender).size();
		opponentsAverage.put(sender, opponentsSum.get(sender) / round_num); // 平均
		opponentsVariance.put(sender,
				(opponentsPowSum.get(sender) / round_num) - Math.pow(opponentsAverage.get(sender), 2)); // 分散

		if (opponentsVariance.get(sender) < 0) {
			opponentsVariance.put(sender, 0.0);
		}
		opponentsStandardDeviation.put(sender, Math.sqrt(opponentsVariance.get(sender))); // 標準偏差

		if (util > BOU) {
			BOBHistory.add(offeredBid); // BOUの更新履歴に追加
			BOU = util; // BOUの更新
		}
	}

	public void updateAcceptNum(Object sender) {
		opponentsAcceptNum.put(sender, opponentsAcceptNum.get(sender) + 1);
	}

	public HashMap<Issue, ArrayList<Tuple<Value, Integer>>> getValueOrdinalScale() {
		// AcceptNumが多いエージェントを選びやすくしてる。
		int allAcceptNum = 0;
		for (Object agent : opponentsAcceptNum.keySet()) {
			allAcceptNum += opponentsAcceptNum.get(agent);
		}
		Object selectedAgent = null;
		if (allAcceptNum != 0) {
			double rand = Math.random();
			int acceptNum = 0;
			for (Object agent : opponentsAcceptNum.keySet()) {
				acceptNum += opponentsAcceptNum.get(agent);
				if (rand <= acceptNum / allAcceptNum) {
					selectedAgent = agent;
					break;
				}
			}
		} else {
			int rand = (new Random()).nextInt(opponents.size());
			int acceptNum = 0;
			for (Object agent : opponentsAcceptNum.keySet()) {
				acceptNum++;
				if (rand <= acceptNum) {
					selectedAgent = agent;
					break;
				}
			}
		}
		// nullを返すことはないはず。
		return opponentsValueOrdinalScale.get(selectedAgent);
	}

	// 頻度行列を更新
	private void updateFrequencyList(Object sender, Bid offeredBid) throws Exception {
		for (Issue issue : issues) {
			Value value = offeredBid.getValue(issue.getNumber());
			opponentsValueFrequency.get(sender).get(issue).put(value,
					opponentsValueFrequency.get(sender).get(issue).get(value) + 1); // リストを更新
			allValueFrequency.get(issue).put(value, allValueFrequency.get(issue).get(value) + 1); // リストを更新
		}
	}

	// 順序尺度行列を更新
	private void updateOrdinalScale(Object sender, Bid offeredBid) throws Exception {
		for (Issue issue : issues) {
			Value value = offeredBid.getValue(issue.getNumber());
			int i = 0;
			for (Tuple<Value, Integer> tuple : opponentsValueOrdinalScale.get(sender).get(issue)) {
				if (tuple.get1().equals(value)) {
					opponentsValueOrdinalScale.get(sender).get(issue).set(i,
							new Tuple<Value, Integer>(value, tuple.get2() + 1));
					break;
				}
				i++;
			}
			if (opponentsValueOrdinalScale.get(sender).get(issue).size() == i)
				opponentsValueOrdinalScale.get(sender).get(issue).add(new Tuple<Value, Integer>(value, 1));
		}
	}

	// 順序尺度行列をソート
	public void sortOrdinalScale() throws Exception {
		for (Object opponent : opponents) {
			for (Issue issue : issues) {
				Tuple<Value, Integer> tuplePre = opponentsValueOrdinalScale.get(opponent).get(issue)
						.get(opponentsValueOrdinalScale.get(opponent).get(issue).size() - 1);
				for (int i = opponentsValueOrdinalScale.get(opponent).get(issue).size() - 2; i >= 0; i--) {
					if (opponentsValueOrdinalScale.get(opponent).get(issue).get(i).get2() < tuplePre.get2()) {
						opponentsValueOrdinalScale.get(opponent).get(issue).set(i + 1,
								opponentsValueOrdinalScale.get(opponent).get(issue).get(i));
						opponentsValueOrdinalScale.get(opponent).get(issue).set(i, tuplePre);
					}
					tuplePre = opponentsValueOrdinalScale.get(opponent).get(issue).get(i);
				}
			}
		}
	}

	// 交渉者数を返す
	public void updateOpponentsNum(int num) {
		negotiatorNum = num;
	}

	// 線形効用空間でない場合
	public void utilitySpaceTypeisNonLiner() {
		isLinerUtilitySpace = false;
	}

	// 自身の提案情報の更新
	public void updateMyBidHistory(Bid offerBid) {
		MyBidHistory.add(offerBid);
	}

	// 提案時間間隔を返す
	public void updateTimeScale(double time) {
		round = round + 1;
		time_scale = time / round;
	}

	// PopularBidListを返す
	public void updatePBList(Bid popularBid) throws Exception {
		if (!PBList.contains(popularBid)) { // 一意に記録
			PBList.add(popularBid);
			MPBU = Math.max(MPBU, utilitySpace.getUtility(popularBid));
			Collections.sort(PBList, new UtilityComparator()); // ソート

			if (isPrinting) {
				System.out.println("ranking");
				for (int i = 0; i < PBList.size(); i++) {
					System.out.println(utilitySpace.getUtility(PBList.get(i)));
				}
				System.out
						.println("Size:" + PBList.size() + ", Min:" + utilitySpace.getUtility(PBList.get(0)) + ", Max:"
								+ utilitySpace.getUtility(PBList.get(PBList.size() - 1)) + ", Opponents:" + opponents);
			}
		}
	}

	public class UtilityComparator implements Comparator<Bid> {
		public int compare(Bid a, Bid b) {
			try {
				double u1 = utilitySpace.getUtility(a);
				double u2 = utilitySpace.getUtility(b);
				if (u1 < u2) {
					return 1;
				}
				if (u1 == u2) {
					return 0;
				}
				if (u1 > u2) {
					return -1;
				}
			} catch (Exception e) {
				System.out.println("効用値に基づくソートに失敗しました");
				e.printStackTrace();
			}
			return 0; // 例外処理
		}
	}

	// 平均
	public double getAverage(Object sender) {
		return opponentsAverage.get(sender);
	}

	// 分散
	public double getVariancer(Object sender) {
		return opponentsVariance.get(sender);
	}

	// 標準偏差
	public double getStandardDeviation(Object sender) {
		return opponentsStandardDeviation.get(sender);
	}

	// 相手の提案履歴の要素数を返す
	public int getPartnerBidNum(Object sender) {
		return opponentsBidHistory.get(sender).size();
	}

	// 相手の提案履歴の頻度を返す
	public HashMap<Issue, HashMap<Value, Integer>> getHistory(Object sender) {
		return opponentsValueFrequency.get(sender);
	}

	// 自身のラウンド数を返す
	public int getRound() {
		return round;
	}

	// 交渉者数を返す
	public int getNegotiatorNum() {
		return negotiatorNum;
	}

	// 相対効用行列を返す
	public HashMap<Issue, HashMap<Value, Double>> getValueRelativeUtility() {
		return valueRelativeUtility;
	}

	// 線形効用空間であるかどうかを返す
	public boolean isLinerUtilitySpace() {
		return isLinerUtilitySpace;
	}

	// 論点一覧を返す
	public ArrayList<Issue> getIssues() {
		return issues;
	}

	// BestOfferedUtilityを返す
	public double getBOU() {
		return BOU;
	}

	// MaxPopularBidUtilityを返す
	public double getMPBU() {
		return MPBU;
	}

	// 交渉者全体のBOBHistoryを返す
	public ArrayList<Bid> getBOBHistory() {
		return BOBHistory;
	}

	// PBListを返す
	public ArrayList<Bid> getPBList() {
		return PBList;
	}

	// 提案時間間隔を返す
	public double getTimeScale() {
		return time_scale;
	}

	// 論点における取り得る値の一覧を返す
	public ArrayList<Value> getValues(Issue issue) {
		ArrayList<Value> values = new ArrayList<Value>();
		switch (issue.getType()) {
		case DISCRETE:
			List<ValueDiscrete> valuesDis = ((IssueDiscrete) issue).getValues();
			for (Value value : valuesDis) {
				values.add(value);
			}
			break;
		case INTEGER:
			int min_value = ((IssueInteger) issue).getLowerBound();
			// int min_value = ((IssueInteger)issue).getUpperBound();
			int max_value = ((IssueInteger) issue).getUpperBound();
			for (int j = min_value; j <= max_value; j++) {
				ValueInteger valueObject = new ValueInteger(j);
				values.add((Value) valueObject);
			}
			break;
		default:
			try {
				throw new Exception("issue type " + issue.getType() + " not supported by Atlas3");
			} catch (Exception e) {
				System.out.println("論点の取り得る値の取得に失敗しました");
				e.printStackTrace();
			}
		}
		return values;
	}

	// 交渉相手の一覧を返す
	public ArrayList<Object> getOpponents() {
		return opponents;
	}

	// FrequencyListの頻度に基づき，要素を返す
	public Value getValuebyFrequencyList(Object sender, Issue issue) {
		int current_f = 0;
		int max_f = 0; // 最頻出要素の出現数
		Value max_value = null; // 最頻出要素
		ArrayList<Value> randomOrderValues = getValues(issue);
		Collections.shuffle(randomOrderValues); // ランダムに並び替える(毎回同じ順番で評価した場合，出現数が同値の場合に返却値が偏るため)

		for (Value value : randomOrderValues) {
			current_f = opponentsValueFrequency.get(sender).get(issue).get(value);
			// 最頻出要素を記録
			if (max_value == null || current_f > max_f) {
				max_f = current_f;
				max_value = value;
			}
		}
		return max_value;
	}

	// 全員分のFrequencyListの頻度に基づき，要素を返す
	public Value getValuebyAllFrequencyList(Issue issue) {
		int current_f = 0;
		int max_f = 0; // 最頻出要素の出現数
		Value max_value = null; // 最頻出要素
		ArrayList<Value> randomOrderValues = getValues(issue);
		Collections.shuffle(randomOrderValues); // ランダムに並び替える(毎回同じ順番で評価した場合，出現数が同値の場合に返却値が偏るため)

		for (Value value : randomOrderValues) {
			current_f = allValueFrequency.get(issue).get(value);
			// 最頻出要素を記録
			if (max_value == null || current_f > max_f) {
				max_f = current_f;
				max_value = value;
			}
		}
		return max_value;
	}

	// Wouter: DISABLED this #1534.

	// public void saveFrequency() {
	// try {
	// File file = new File("opponentBid.txt");
	// FileWriter filewriter = new FileWriter(file);
	//
	// for (Object opponent : opponents) {
	// for (Issue issue : issues) {
	// filewriter.write(opponent.toString() + "\n");
	// HashMap<Value, Integer> values =
	// opponentsValueFrequency.get(opponent).get(issue);
	// // List 生成 (ソート用)
	// List<Map.Entry<Value, Integer>> entries = new ArrayList<Map.Entry<Value,
	// Integer>>(
	// values.entrySet());
	// Collections.sort(entries, new Comparator<Map.Entry<Value, Integer>>() {
	// @Override
	// public int compare(Entry<Value, Integer> entry1, Entry<Value, Integer>
	// entry2) {
	// return ((Integer) entry2.getValue()).compareTo((Integer)
	// entry1.getValue());
	// }
	// });
	//
	// // 内容を表示
	// for (Entry<Value, Integer> s : entries) {
	// filewriter.write(s.getKey() + " , " + s.getValue() + "\n");
	// }
	// }
	// }
	// filewriter.close();
	// } catch (IOException e) {
	// System.out.println(e);
	// }
	// }
	//
	// public void saveSort() {
	// try {
	// File file = new File("sortBid.txt");
	// FileWriter filewriter = new FileWriter(file);
	// filewriter.write("save sort" + "\n");
	//
	// // for(Object opponent: opponents){
	// // filewriter.write(opponent.toString()+"\n");
	// // for(Issue issue: issues){
	// // filewriter.write(issue.toString()+"\n");
	// // ArrayList<Tuple<Value, Integer>> values =
	// // opponentsValueOrdinalScale.get(opponent).get(issue);
	// // 内容を表示
	// // for (Tuple<Value,Integer> s : values) {
	// // System.out.print("("+s.get1()+","+s.get2()+"):");
	// // }
	// // }
	// // System.out.println("");
	// // }
	// for (Bid s : MyBidHistory) {
	// filewriter.write(s + " , " + (1 - utilitySpace.getUtility(s)) + "\n");
	// }
	// filewriter.close();
	// } catch (IOException e) {
	// System.out.println(e);
	// }
	// }
}