package geniusweb.blingbling;

import java.util.LinkedHashMap;
import java.util.Map;

import javax.lang.model.util.ElementScanner6;

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


import geniusweb.issuevalue.Bid;
import geniusweb.issuevalue.Value;
import geniusweb.issuevalue.ValueSet;
import geniusweb.issuevalue.Domain;
import geniusweb.profile.utilityspace.UtilitySpace;


public class OpponentProfile {
    private Distribution distOfferUtil = new Distribution();
    private Distribution distOfferOppUtil = new Distribution();

    private Map<String, Double> issueWeights = new LinkedHashMap<String, Double>();// 原issue使用number index，geniusweb中用insuusenam:string
    private Map<String, IssueTracker> issueTrackers = new LinkedHashMap<String, IssueTracker>();

    private Domain domain;
//    private UtilitySpace oppUtilitySpace;

    private List<Bid> offers = new ArrayList<Bid>();

    private Bid bestOffer = null;
    private double bestOffer_util = 0.0;

    private boolean oldWeights = false;//用于对比改进后的与原有的
    private boolean oldEvaluation = false;

    public OpponentProfile(Domain domain) {
//        this.oppUtilitySpace = oppUtilitySpace;
        this.domain = domain;

        for (String issuename : domain.getIssues())
            issueTrackers.put(issuename, new IssueTracker(issuename, domain.getValues(issuename)));
    }

    public void registerOffer(Bid bid) {
        offers.add(bid);

//        if (bid.getMyUndiscountedUtil() > bestOffer_util) {
//            bestOffer = bid;
//            bestOffer_util = bid.getMyUndiscountedUtil();
//        }

        double totalWeight = 0.0;
        for (String issuename : issueTrackers.keySet()) {
            issueTrackers.get(issuename).registerValue(bid.getValue(issuename), offers.size());

            double weight = issueTrackers.get(issuename).getWeight();
            totalWeight += weight;
            issueWeights.put(issuename, weight);
        }

        for (String issuename : issueWeights.keySet()) {
            double putWeight = (totalWeight == 0.0) ? (1.0 / (double) issueWeights.size())
                    : (issueWeights.get(issuename) / totalWeight);
            issueWeights.put(issuename, putWeight);
        }
    }

    public double getPredOppUtility(Bid bid) {
        if (offers.size() == 0 || bid == null)
            return 0.0;

        Map<String, Double> usedIssueWeights = (oldWeights) ? getOldIssueWeights() : issueWeights;

        double predict = 0.0;
        for (String issuename : issueTrackers.keySet()) {
            Value value = bid.getValue(issuename);

            IssueTracker it = issueTrackers.get(issuename);
            double valueEvaluation = (oldEvaluation) ? it.getEvaluationOld(value) : it.getEvaluation(value);

            predict += usedIssueWeights.get(issuename) * valueEvaluation;
        }

        return predict;
    }

    public void setMethod(boolean oldWeights, boolean oldEvaluation) {//确定用新的SFM还是老的SFM
        this.oldWeights = oldWeights;
        this.oldEvaluation = oldEvaluation;
    }

    public String getMethod() {
        return "_" + (oldWeights ? "oldW" : "newW") + "_" + (oldEvaluation ? "oldE" : "newE");
    }

    private Map<String, Double> getOldIssueWeights() {//老SFM的计算issueweight的方法
        Map<String, Double> oldIssueWeights = new LinkedHashMap<String, Double>();

        double totalWeight = 0.0;
        for (String issuename : issueTrackers.keySet()) {
            double weight = issueTrackers.get(issuename).getOldWeight(offers.size());

            totalWeight += weight;
            oldIssueWeights.put(issuename, weight);
        }

        for (String issuename : oldIssueWeights.keySet())
            oldIssueWeights.put(issuename, oldIssueWeights.get(issuename) / totalWeight);

        return oldIssueWeights;
    }

    //get real utility via opponent utility 
//    public double getOppUtility(Bid bid) {
//        return bid == null ? 0.0 : oppUtilitySpace.getUtility(bid);//return type
//    }

    public Bid getPredOppMaxBid() {
        if (offers.size() == 0)
            return null;

        HashMap<String, Value> values = new HashMap<String, Value>();

        // For each issue, get the max value
        for (String issuename : issueTrackers.keySet())
            values.put(issuename, issueTrackers.get(issuename).getMaxValue());

        // create and return bid
        return new Bid(values);
    }

    public Bid getBestOffer() {
        return bestOffer;
    }

    public Bid getLastOffer() {
        return (offers.size() == 0) ? null : offers.get(offers.size() - 1);
    }

    public List<Bid> getOppOffers() {
        return offers;
    }

//    public UtilitySpace getOppUtilitySpace() {
//        return oppUtilitySpace;
//    }

//    public double getWindowAVG(double time) {
//        if (time < 0.5)
//            return 1.0;
//
//        double start = 2 * time - 1;
//
//        double sum = 0.0;
//        int count = 0;
//        for (Bid bid : offers) {
//            if (bid.getTime() > start) {
//                sum += bid.getMyUndiscountedUtil();
//                count++;
//            }
//        }
//
//        return (count == 0) ? 1.0 : (sum / (double) count);
//    }
//
//    public double getWindowMAX(double time) {
//        if (time < 0.5)
//            return 1.0;
//
//        double start = 2 * time - 1;
//
//        double max = 0.0;
//        for (BidDetails bid : offers) {
//            if (bid.getTime() > start) {
//                if (bid.getMyUndiscountedUtil() > max)
//                    max = bid.getMyUndiscountedUtil();
//            }
//        }
//
//        return (max == 0.0) ? 1.0 : max;
//    }

    public String toString() {
        return "\nWeights:\n" + issueWeights.toString() + "\n\nValues:\n" + issueTrackers.toString() + "\n";
    }
}