package agents.anac.y2015.SENGOKU.etc;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;

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.utility.AdditiveUtilitySpace;

public class negotiatingInfo {
	private AdditiveUtilitySpace utilitySpace; // 効用空間
	private List<Issue> issues; // 論点
	private ArrayList<Object> opponents; // 自身以外の交渉参加者のsender
	private ArrayList<Bid> MyBidHistory = null; // 提案履歴 自分！
	private HashMap<Object, ArrayList<Bid>> opponentsBidHistory = null; // 提案履歴　相手！　ハッシュマップで保存！
	private HashMap<Object, ArrayList<Boolean>> opponentsCooperateHistory = null; // 相手の協力履歴
	private HashMap<Object, Double> opponentsAverage; // 平均
	private double allAverage = 0.0; // すべての平均
	private HashMap<Object, Double> opponentsVariance; // 分散
	private double allVariance = 0.0; // すべての分散
	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, Double>> valueNumUtility = null; // 自身の効用空間における各論点値の相対効用値行列（線形効用空間用
	private int round = 0; // 自分の手番数
	private int negotiatorNum = 3; // 交渉者数

	private int acceptNum = 0; // アクセプト数
	private double acceptRate = 0.0; // アクセプト率１ラウンドあたり

	private boolean isLinerUtilitySpace = true; // 線形効用空間であるかどうか

	// オリジナルプロパティー
	private int ActionFlag = 0; // 戦術番号
	private HashMap<Object, ArrayList<Bid>> newBidHistory = null; // 提案履歴　相手！　ハッシュマップで保存！近い履歴
	private HashMap<Object, Double> newAverage; // 平均
	private HashMap<Object, Double> newVariance; // 分散
	private HashMap<Object, Double> newStandardDeviation; // 標準偏差
	private HashMap<Object, Double> newSumNum; // 重複回数
	private HashMap<Object, Double> newAccept; // アクセプトフラグ
	private ArrayList<Double> allMaxShreshold; // 最大の閾値をたえず保存
	private HashMap<Object, ArrayList<Double>> BidValue; // 提案したビットの自分の効用値
	private Object OfferPlayer = null;
	private HashMap<Object, Double> maxUtil; // 相手の提案の最大値
	private ArrayList<Bid> LastOfferBidHistory = null; // 最後の提案に使う用のビッドリスト
	private ArrayList<Double> aveTime = new ArrayList<Double>(); // 自分のターンが回ってくるまでの時間
	public Boolean lastFlag = false; // 最後の妥協にしようするフラグ

	public negotiatingInfo(AdditiveUtilitySpace utilitySpace) {
		// 初期化
		this.utilitySpace = utilitySpace;
		issues = utilitySpace.getDomain().getIssues();
		opponents = new ArrayList<Object>();
		MyBidHistory = new ArrayList<Bid>();
		opponentsBidHistory = new HashMap<Object, ArrayList<Bid>>();
		opponentsCooperateHistory = new HashMap<Object, ArrayList<Boolean>>();
		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>>();
		valueNumUtility = new HashMap<Issue, HashMap<Value, Double>>();

		// 新しいのの初期化
		newBidHistory = new HashMap<Object, ArrayList<Bid>>();
		newAverage = new HashMap<Object, Double>();
		newVariance = new HashMap<Object, Double>();
		newStandardDeviation = new HashMap<Object, Double>();
		newSumNum = new HashMap<Object, Double>();
		newAccept = new HashMap<Object, Double>();
		BidValue = new HashMap<Object, ArrayList<Double>>();
		allMaxShreshold = new ArrayList<Double>();
		maxUtil = new HashMap<Object, Double>();
		LastOfferBidHistory = new ArrayList<Bid>();

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

	public void initOpponent(Object sender) {
		initNegotiatingInfo(sender); // 交渉情報を初期化
		opponents.add(sender); // 交渉参加者にsenderを追加
	}

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

	private void initNegotiatingInfo(Object sender) {
		opponentsBidHistory.put(sender, new ArrayList<Bid>());
		opponentsCooperateHistory.put(sender, new ArrayList<Boolean>());
		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);
		newBidHistory.put(sender, new ArrayList<Bid>());
		newAverage.put(sender, 0.0);
		newVariance.put(sender, 0.0);
		newStandardDeviation.put(sender, 0.0);
		newSumNum.put(sender, 0.0);
		newAccept.put(sender, 0.0);
		BidValue.put(sender, new ArrayList<Double>());
		maxUtil.put(sender, 0.0);
	}

	// 相対効用行列の初期化
	private void initValueRelativeUtility() throws Exception {
		ArrayList<Value> values = null;
		for (Issue issue : issues) {
			valueRelativeUtility.put(issue, new HashMap<Value, Double>()); // 論点行の初期化
			valueNumUtility.put(issue, new HashMap<Value, Double>()); // 論点行の初期化
			values = getValues(issue);
			for (Value value : values) { // 論点行の要素の初期化
				valueRelativeUtility.get(issue).put(value, 0.0);
				valueNumUtility.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 setValueNumUtility(Bid maxBid) throws Exception {
		ArrayList<Value> values = null;
		Bid currentBid = null;
		for (Issue issue : issues) {
			currentBid = new Bid(maxBid);
			Value onValue = currentBid.getValue(issue.getNumber());
			values = getValues(issue);
			for (Value value : values) {
				if (onValue.equals(value)) {
					Double i = valueRelativeUtility.get(issue).get(value);
					valueRelativeUtility.get(issue).put(value, i + 1.0);
				}
			}
		}
	}

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

		// utilは相手の提案に対するそのあたい効用値である！　自分の提案は自分でわかる！
		// utilitySpace.getUtility 引数ビットにたいする公用地を返す自分のみ！
		double util = utilitySpace.getUtility(offeredBid);
		updateBidValue(sender, util);
		if (maxUtil.get(sender) < util) {
			maxUtil.put(sender, util);
		}

		if (!lastFlag) {
			if (LastOfferBidHistory.size() == 0) {
				LastOfferBidHistory.add(offeredBid);
			} else if (utilitySpace.getUtility(LastOfferBidHistory
					.get(LastOfferBidHistory.size() - 1)) < util) {
				LastOfferBidHistory.add(offeredBid);
			}
		}

		// 新しいものを更新していくクラス！
		test(sender);

		round++;
		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))); // 標準偏差

	}

	// 提案履歴から最新x個を取り出して平均とかを求める！
	public void test(Object sender) throws Exception {
		// System.out.println(opponentsBidHistory.get(sender));
		ArrayList<Bid> bidlist = opponentsBidHistory.get(sender);
		int x = 6; // どれだけの最新でーたを採用するか
		double sumNum = 0; // どれだけ重複しているか
		int bitSize = bidlist.size(); // どれだけ履歴があるか
		int count = x; // 実際の入れる配列数
		if (bitSize < x) {
			count = bitSize;
		}

		double sum = 0;
		double ave = 0;
		double v = 0;
		double sd = 0;

		ArrayList<Bid> newlist = new ArrayList<Bid>();

		for (int i = 0; count > i; i++) {
			Bid inBit = bidlist.get(bitSize - i - 1); // 入れるビット
			// 何回同じ提案があるか計算
			if (newlist.contains(inBit)) {
				sumNum = sumNum + 1.0;
			}

			newlist.add(inBit);
			double util = utilitySpace.getUtility(inBit);
			sum = sum + util;
		}

		ave = sum / count; // 平均を出す
		for (int i = 0; count > i; i++) {
			newlist.add(bidlist.get(bitSize - i - 1));
			double util = utilitySpace.getUtility(bidlist.get(bitSize - i - 1));
			v = v + Math.pow((ave - util), 2);
		}

		sd = Math.sqrt(v);
		newBidHistory.put(sender, newlist);
		newAverage.put(sender, ave);
		newVariance.put(sender, v);
		newStandardDeviation.put(sender, sd);
		newSumNum.put(sender, sumNum);
		if (newAccept.get(sender) > 0.0) {
			newAccept.put(sender, newAccept.get(sender) - 1.0 / x);
		}
	}

	// 他人がアクセプトしたときのデータ更新
	public void updateAccept(Object sender) {
		// すべてのアクセプトの数
		acceptNum++;
		// １巡のアクセプト率
		double rate = 1.0 / opponents.size();
		acceptRate = acceptRate + rate;
		// ある人の最近アクセプト
		newAccept.put(sender, 1.0);
	}

	// 得られる最大をすべて保存
	public void updateMaxThreshold(double threshold) {
		allMaxShreshold.add(threshold);
	}

	// //得られる最大を返す
	public ArrayList<Double> getMaxThreshold() {
		return allMaxShreshold;
	}

	// アクセプト率をリセット
	public void resetAcceptRate() {
		acceptRate = 0.0;
	}

	// 自分が何をするか　オファーのとき
	public void myActionOffer() {
		ActionFlag = 0;
	}

	// 自分が何をするか　アクセプトの時
	public void myActionAccept() {
		ActionFlag = 1;
	}

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

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

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

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

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

	// 最新の平均
	public double getNewAverage(Object sender) {
		return newAverage.get(sender);
	}

	// 最新の分散
	public double getNewVariancer(Object sender) {
		return newVariance.get(sender);
	}

	// 平均
	public double getAllAverage(double m) {
		return allAverage;
	}

	// 分散
	public double getAllVariancer(double v) {
		return allVariance;
	}

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

	// 新しい標準偏差
	public double getNewStandardDeviation(Object sender) {
		return newStandardDeviation.get(sender);
	}

	// 相手の協力状態を返す
	public ArrayList<Double> getBidValue(Object sender) {
		return BidValue.get(sender);
	}

	// 相手の協力状態を更新
	public void updateBidValue(Object sender, double util) {
		BidValue.get(sender).add(util);
	}

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

	// 相手の提案履歴を返す
	public ArrayList<Bid> getPartnerBid(Object sender) {
		return opponentsBidHistory.get(sender);
	}

	// 相手の協力情報を更新する　協力ならtrue
	public void updateopponentsCooperateHistory(Object sender, boolean state) {
		opponentsCooperateHistory.get(sender).add(state);
	}

	// 相手の協力情報をリストで返す
	public ArrayList<Boolean> getopponentsCooperateHistory(Object sender) {
		return opponentsCooperateHistory.get(sender);
	}

	// 最後のリストを返す
	public Bid getLastOfferBidHistry() {
		int size = LastOfferBidHistory.size();
		return LastOfferBidHistory.get(size - 1);
	}

	// 最後のビットのリストのサイズを返す
	public int getLastOfferBidNum() {
		return LastOfferBidHistory.size();
	}

	public void removeLastOfferBidHistry() {
		int size = LastOfferBidHistory.size();
		LastOfferBidHistory.remove(size - 1);
	}

	// 自分の提案履歴を返す
	public ArrayList<Bid> getMyBidHistory() {
		return MyBidHistory;
	}

	// オファーしている相手を返す
	public Object getOfferPlayer() {
		return OfferPlayer;
	}

	// 新しい提案の重複数
	public double getNewSumNum(Object sender) {
		return newSumNum.get(sender);
	}

	// 新しいアクセプト数
	public double getNewAccept(Object sender) {
		return newAccept.get(sender);
	}

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

	// 自身の行動フラグを返す
	public int getActionFlag() {
		return ActionFlag;
	}

	// アクセプト数を返す
	public int getAccept() {
		return acceptNum;
	}

	// アクセプト数を返す
	public double getAcceptRate() {
		return acceptRate;
	}

	// 相手の提案の有効値の最大を返す
	public double getmaxUtil(Object sender) {
		return maxUtil.get(sender);
	}

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

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

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

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

	// 論点における取り得る値の一覧を返す　それほど大したものではない
	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).getUpperBound();
			int max_value = ((IssueInteger) issue).getUpperBound();
			for (int j = min_value; j <= max_value; j++) {
				Object valueObject = new Integer(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 void getValueAll() {
		for (int i = 0; getIssues().size() > i; i++) {
			System.out.println(getValues(getIssues().get(i)));
		}
	}

	public void updateTime(double time) {

		if (aveTime.size() == 0) {
			aveTime.add(time);
		} else {
			double allTime = 0.0;
			for (int i = 0; i < aveTime.size(); i++) {
				allTime = allTime + aveTime.get(i);
			}
			aveTime.add(time - allTime);
		}
	}

	public double getAveTime() {
		double allTime = 0.0;
		int count = aveTime.size();
		for (int i = 0; i < count; i++) {
			allTime = allTime + aveTime.get(i);
		}
		return allTime / (double) count;
	}

	public void laststrategy(double time) {
		updateTime(time);
		double lastTime = 1 - time;
		int bidNum = LastOfferBidHistory.size() + 2;
		// System.out.println(LastOfferBidHistory.size() +
		// "-----list"+LastOfferBidHistory);
		double yosokuTime = (double) bidNum * getAveTime();
		if (lastTime < yosokuTime) {
			lastFlag = true;
		}
	}

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