source: src/main/java/agents/anac/y2015/agenth/BidHistory.java

package agents.anac.y2015.agenth;

import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.Set;

import genius.core.Bid;
import genius.core.Domain;
import genius.core.issue.Issue;
import genius.core.issue.Value;
import genius.core.utility.AdditiveUtilitySpace;

public class BidHistory extends LinkedList<BidHistory.Entry> {
        /** UtilitySpace */
        private AdditiveUtilitySpace mUtilitySpace;
        /** bid と sender の対応マップ */
        private HashMap<Bid, Object> mBids;
        /** エージェントごとの値 */
        private HashMap<Object, ValueCounter> mValueCounterMap;
        /** 最後に挿入された bid */
        private Bid mLastBid;

        /** 全体の平均 bid */
        private Bid mMeans;
        private ValueCounter mValueCounter;

        public BidHistory(AdditiveUtilitySpace utilitySpace) {
                mUtilitySpace = utilitySpace;
                mBids = new HashMap<Bid, Object>();
                mValueCounterMap = new HashMap<Object, ValueCounter>();
                mValueCounter = new ValueCounter();
        }

        public void offer(Object sender, Bid bid, double utility) {
                add(new Entry(sender, bid, utility));
                mBids.put(bid, sender);
                mLastBid = bid;

                // ValueCounter に入れる
                mValueCounter.add(bid);

                ValueCounter counter = mValueCounterMap.get(sender);
                if (counter == null) {
                        counter = new ValueCounter();
                        mValueCounterMap.put(sender, counter);
                }
                counter.add(bid); // TODO 重み加えるとかする
        }

        public void accept(Object sender, Bid bid) {
                ValueCounter counter = mValueCounterMap.get(sender);
                if (counter == null) {
                        counter = new ValueCounter();
                        mValueCounterMap.put(sender, counter);
                }
                counter.add(bid); // TODO 重み加えるとかする
        }

        public boolean containsBid(Bid bid) {
                return mBids.containsKey(bid);
        }

        /**
         * 自分の効用値が高い順にソートされたリストを返す
         * 
         * @return
         */
        public List<Entry> getSortedList() {
                final LinkedList<Entry> list = new LinkedList<Entry>(this);
                Collections.sort(list, mUtilityComparator);
                return list;
        }

        public double getProbOfValue(Object agent, Issue issue, Value value) {
                ValueCounter counter = mValueCounterMap.get(agent);
                if (counter != null) {
                        return (counter.get(issue).get(value) / counter.get(issue).size());
                }
                return 0; // FIXME
        }

        private Comparator<Entry> mUtilityComparator = new Comparator<Entry>() {
                @Override
                public int compare(Entry o1, Entry o2) {
                        return (int) Math.round((o1.utility - o2.utility) * 10e5);
                }
        };

        /**
         * BidHistory が持つエントリ
         */
        public class Entry {
                public Object sender;
                public Bid bid;
                public double utility;

                public Entry(Object sender, Bid bid, double utility) {
                        this.bid = bid;
                        this.utility = utility;
                }
        }

        /**
         * Value の頻度を数えるクラス HashMap<IssueNr, HashMap<Value, Count>>
         */
        private class ValueCounter extends HashMap<Issue, HashMap<Value, Integer>> {

                public ValueCounter() {
                        final Domain domain = mUtilitySpace.getDomain();
                        final List<Issue> issues = domain.getIssues();
                        for (Issue issue : issues) {
                                put(issue, new HashMap<Value, Integer>());
                        }
                }

                public void add(Bid bid) {
                        try {
                                final List<Issue> issues = bid.getIssues();
                                for (Issue issue : issues) {
                                        final Value value = bid.getValue(issue.getNumber());
                                        increase(issue, value);
                                }
                                System.out.println("BidHistory.ValueCounter#add(): " + this);
                        } catch (Exception e) {
                                e.printStackTrace();
                        }
                }

                public void increase(Issue issue, Value value) {
                        final HashMap<Value, Integer> map = get(issue);
                        if (map != null) {
                                Integer count = map.get(value);
                                if (count == null) {
                                        count = new Integer(0);
                                }
                                map.put(value, count + 1);
                        }
                }

                public Value getMostLikelyValue(Issue issue) {
                        final HashMap<Value, Integer> map = get(issue);
                        if (map != null) {
                                Value v = null;
                                int n = 0;
                                final Set<Map.Entry<Value, Integer>> es = map.entrySet();
                                for (Map.Entry<Value, Integer> e : es) {
                                        if (n < e.getValue()) {
                                                v = e.getKey();
                                                n = e.getValue();
                                        }
                                }
                                return v;
                        }
                        return null;
                }
        }
}