package agents.anac.y2014.E2Agent;

import java.io.Serializable;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Random;

import agents.anac.y2014.E2Agent.myUtility.AgentKStorategy;
import agents.anac.y2014.E2Agent.myUtility.BidStorage;
import agents.anac.y2014.E2Agent.myUtility.BidStorageComparator;
import agents.anac.y2014.E2Agent.myUtility.BidStorageList;
import agents.anac.y2014.E2Agent.myUtility.IAgentKStorategyComponent;
import agents.anac.y2014.E2Agent.myUtility.Parameters;
import agents.anac.y2014.E2Agent.myUtility.SessionData;
import agents.anac.y2014.E2Agent.myUtility.SimulatedAnealing;
import agents.anac.y2014.E2Agent.myUtility.SummaryStatistics;
import genius.core.Agent;
import genius.core.Bid;
import genius.core.NegotiationResult;
import genius.core.actions.Accept;
import genius.core.actions.Action;
import genius.core.actions.ActionWithBid;
import genius.core.actions.Offer;
import genius.core.issue.Issue;
import genius.core.issue.IssueInteger;
import genius.core.issue.ValueInteger;
import genius.core.utility.AbstractUtilitySpace;
import genius.core.utility.Bound;

public class AnacSampleAgent extends Agent {
	private Action actionOfPartner = null;
	private static int SAMPLE_NUMBER = 3; // �得�るサンプル数
	private static int SA_K_MAX = 10000; // 焼����法�ループ数
	private AbstractUtilitySpace nonlinear = null; // �線形効用空間
	// private ArrayList<BidStorage> partnerBidHistory = null; //
	// 相手�Bid履歴
	private BidStorageList partnerBidHistory = null;
	private ArrayList<BidStorage> candidateBids = null; // Bid候補
	private List<Issue> issues = null; // 効用空間�全��論点
	private Random randomnr = null;
	private SimulatedAnealing simulatedAnealing = null;
	private double discountFactor = 0;
	private double reservationValue = 0;
	private AgentKStorategy agentKStorategy = null;
	private SessionData sessionData = null;
	private double time = 0;
	private double worstUtility = 1.0;
	private Parameters param;
	private BidStorage bestBid;

	@Override
	public void init() {
		Serializable s = loadSessionData();
		if (s != null && sessionNr != 0) {

			sessionData = (SessionData) s;
		} else {
			// System.out.println("######################################################################################################################################################");
			sessionData = new SessionData(sessionsTotal);
		}

		param = sessionData.getParamters(reservationValue, discountFactor);
		// System.out.println(param);

		randomnr = new Random();
		nonlinear = (AbstractUtilitySpace) utilitySpace.copy();
		issues = utilitySpace.getDomain().getIssues();
		discountFactor = utilitySpace.getDiscountFactor();
		reservationValue = utilitySpace.getReservationValue();
		agentKStorategy = new AgentKStorategy(randomnr,
				new AgentKStorategyComponentImpl());

		partnerBidHistory = new BidStorageList();
		bestBid = new BidStorage(null, 0, 0);

		try {
			simulatedAnealing = new SimulatedAnealing(utilitySpace);

			candidateBids = searchOptimumBids(SAMPLE_NUMBER);
			// 効用値�ソート
			Collections.sort(candidateBids, new BidStorageComparator());
			Collections.reverse(candidateBids); // �順�変更

			// System.out.println(candidateBids);
		} catch (Exception e) {
			e.printStackTrace();
			candidateBids = null;
		}
	}

	/**
	 * 最��Bidを探索
	 */
	private ArrayList<BidStorage> searchOptimumBids(int sampleNr)
			throws Exception {
		ArrayList<BidStorage> bids = new ArrayList<BidStorage>();
		for (int index = 0; index < sampleNr; ++index) {
			Bid startBid = utilitySpace.getDomain().getRandomBid(null);
			// 焼����法�よる最�解探索
			BidStorage optimumBid = simulatedAnealing.run(startBid, 1.0,
					SA_K_MAX);
			// Bid候補追加
			bids.add(optimumBid);
		}
		return bids;
	}

	/**
	 * 自分�行動�択
	 */
	@Override
	public Action chooseAction() {
		Action action = null;
		try {
			// 一番始��Bid
			if (actionOfPartner == null) {
				BidStorage myBidStorage = candidateBids.get(0);
				action = generateOffer(myBidStorage.getBid());
			}
			if (actionOfPartner instanceof Offer) { // 相手�Offer����場�
				time = timeline.getTime();
				double tau = 1;

				// 相手�Bidを記憶
				Bid partnerBid = ((Offer) actionOfPartner).getBid();
				BidStorage partnerBidStorage = new BidStorage(partnerBid,
						utilitySpace.getUtility(partnerBid), time);
				partnerBidHistory.addBidStorage(partnerBidStorage);
				SummaryStatistics stat = partnerBidHistory
						.getSummaryStatistics();
				// BidStorage bestBid = partnerBidHistory.getBestBidStorage();
				// System.out.println(stat);
				BidStorage myBidStorage = null;
				double targetUtility = 1.0;

				// 自分����最も良�相手�Bid
				if (bestBid.getUtility() < partnerBidStorage.getUtility()) {
					bestBid = partnerBidStorage;
				}

				if (discountFactor > 0.9) {
					targetUtility = agentKStorategy.fintarget(time,
							stat.getAve(), stat.getVar(), tau);
				} else {
					targetUtility = fintarget2(time, stat, param);
				}

				myBidStorage = search2(partnerBid, targetUtility);
				if (myBidStorage == null) {
					// 指定��効用値を���Bidを検索
					myBidStorage = searchBidWithApproximateUtlity(partnerBid,
							targetUtility);
					if (myBidStorage == null) {
						myBidStorage = candidateBids.get(0);
					}
				}

				double myUtility = myBidStorage.getUtility();

				if (// worstUtility <= partnerBidStorage.getUtility() ||
				isAcceptable(time, partnerBidStorage.getUtility(),
						stat.getAve(), stat.getVar(), tau)) {
					// System.out.println("Accept");
					action = new Accept(getAgentID(), partnerBid);
				} else {
					if (targetUtility < bestBid.getUtility()) {
						// 目標効用値よりも高�値を相手�既�Offer����ら�れをOffer
						action = generateOffer(bestBid.getBid());
						// System.out.printf("bestUtility: %f.5 ",
						// bestBid.getUtility());
					} else {
						action = generateOffer(myBidStorage.getBid());
					}

					// 自身�最も悪�Bidを記憶
					if ((targetUtility - myUtility) < 0.05
							&& myUtility < worstUtility) {
						worstUtility = myUtility;
					}
					// 目標���り�も離れ�bid�最大Bid�置��る
					if (Math.abs(targetUtility - myUtility) > 0.1) {
						action = generateOffer(candidateBids.get(0).getBid());
					}
					/*
					 * if(sessionNr>0 && time > 0.999 && (reservationValue *
					 * discountFactor) * 1.5 < partnerBidStorage.getUtility()) {
					 * System.out.println("Limit"); action = new
					 * Accept(getAgentID()); }
					 */
				}
			}
		} catch (Exception e) { // 例外発生時�相手���案を��る
			e.printStackTrace();
			// System.out.println("Exception in ChooseAction:"+e.getMessage());
			// best guess if things go wrong.
			action = new Accept(getAgentID(),
					((ActionWithBid) actionOfPartner).getBid());
		}
		return action;
	}

	private BidStorage search2(Bid bid, double targetUtil) throws Exception {
		double min = 1;
		BidStorage ret = null;

		for (int i = 0; i < issues.size(); ++i) {
			IssueInteger lIssueInteger = (IssueInteger) issues.get(i);
			int issueIndexMin = lIssueInteger.getLowerBound();
			int issueIndexMax = lIssueInteger.getUpperBound();

			for (int j = issueIndexMin; j <= issueIndexMax; ++j) {
				Bid neighbourBid = new Bid(bid);
				neighbourBid = neighbourBid.putValue(i + 1,
						new ValueInteger(j));
				double u = utilitySpace.getUtility(neighbourBid);
				if (/* Math.abs(u-targetUtil) < min && */u > targetUtil) {
					min = u;
					ret = new BidStorage(neighbourBid, u, -1);
					System.out.println(ret);
				}
			}
		}

		return ret;
	}

	/**
	 * 相手���案を��る�
	 */
	private boolean isAcceptable(double time, double u, double myu, double var,
			double tau) throws Exception {
		// 相手�効用値�時間�0~1�値を得る
		double p = agentKStorategy.pAccept(time, u, myu, var, tau);
		if (p < 0.1) {
			return false;
		}

		// System.out.printf(" P: %f.5\n", p);
		return p > Math.random();
	}

	private double fintarget2(double time, SummaryStatistics stat,
			Parameters param) {
		double ret = 1;
		double target = agentKStorategy.fintarget(time, stat.getAve(),
				stat.getVar(), 1);
		if (Double.isNaN(target)) {
			target = 1.0;
		}
		double co = 0;
		if (target > param.utility) {
			co = 0.8;
			if (param.time - time > 0) {
				co *= (1 - Math.pow((param.time - time) / param.time,
						param.alpha));
			}
		}
		ret = co * param.utility + (1 - co) * target;
		// System.out.printf("%.4f ",ret);
		return ret;
	}

	private double fintarget(double time, SummaryStatistics stat,
			Parameters param) {
		double ret = 1;
		double param_t = param.time * 0.85;
		double e = agentKStorategy.emax(stat.getAve(), stat.getVar());

		if (time < param_t) {
			ret = 1 - ((1 - param.utility)
					* Math.pow(time / param_t, 1 / param.alpha));
		} else {
			/*
			 * double t = (time - param_t) / (1 - param_t); double ave =
			 * stat.getAve() / param.utility; double var = stat.getVar() /
			 * Math.pow(param.utility,2); double target =
			 * agentKStorategy.fintarget(t, ave, var, 1); ret = target /
			 * param.utility;
			 */

			if (e > param.utility || Double.isNaN(e)) {
				e = param.utility;
			}
			ret = param.utility - (param.utility - e)
					* Math.pow((time - param_t) / (1 - param_t), param.beta);
			if (Double.isNaN(ret)) {
				ret = 1.0;
			}
		}

		// System.out.printf("%.4f ",ret);
		return ret;
	}

	private BidStorage searchBidWithApproximateUtlity(Bid startBid, double u)
			throws Exception {
		// Bid startBid = utilitySpace.getDomain().getRandomBid();
		// 焼����法�よる最�解探索
		BidStorage optimumBid = null;
		try {
			optimumBid = simulatedAnealing.run(startBid, u, SA_K_MAX);
		} catch (Exception e) {
			return null;
		}
		return optimumBid;
	}

	private ArrayList<Bound> searchConstraint(Bid bid) {
		ArrayList<Bound> constraint = new ArrayList<Bound>();
		double u = getUtility(bid);
		return constraint;
	}

	@Override
	public void endSession(NegotiationResult result) {
		// System.out.printf("\n");
		try {
			sessionData.save(sessionNr, partnerBidHistory, result,
					utilitySpace.getUtility(result.getLastBid()),
					timeline.getTime());
		} catch (Exception e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		saveSessionData(sessionData);
	}

	@Override
	public void ReceiveMessage(Action opponentAction) {
		actionOfPartner = opponentAction;
	}

	private Offer generateOffer(Bid bid) {
		return new Offer(getAgentID(), bid);
	}

	@Override
	public String getVersion() {
		return "5.0";
	}

	@Override
	public String getName() {
		return "Anac Sample Agent";
	}

	class AgentKStorategyComponentImpl implements IAgentKStorategyComponent {
		@Override
		public double g(double t) {
			return param.g;
		}
	}

	@Override
	public String getDescription() {
		return "ANAC2014 compatible with non-linear utility spaces";
	}
}