source: src/main/java/bargainingchips/players/history/BidEventHistory.java@ 340

package bargainingchips.players.history;

import java.util.List;

import java.util.ArrayList;
import java.util.Collections;
import java.util.Iterator;
import java.util.Random;

import bargainingchips.Bundle;
import bargainingchips.OutcomeSpace;
import bargainingchips.actions.Bid;

/**
 * 
 * BidEventHistory is the list of {@link BidEvent}s (including bid, its utility [for the agent], and time) that 
 * an agent stores for any further use.
 * It is adapted from {@link /NegotiatorGUI/src/main/java/agents/anac/y2011/Nice_Tit_for_Tat/BidHistory.java}
 * 
 * 
 * @author Faria Nassiri-Mofakham
 *
 */
public class BidEventHistory implements Iterable<BidEvent>
{
        List<BidEvent> history;
        private final boolean TEST_EQUIVALENCE = false;
        
        public BidEventHistory()
        {
                this.history = new ArrayList<BidEvent>();
        }
        
        public BidEventHistory(BidEventHistory h)
        {
                this.history = new ArrayList<BidEvent>(h.getHistory());
        }
        
        /**
         * Pretends all bids in the domain were made on t = 0.
         */
        public BidEventHistory(OutcomeSpace s)
        {
                this();
                for (Bundle b : s.getAllBids())
                        history.add(new BidEvent(b,0, 0));
        }
        
        public BidEventHistory filterBetweenTime(double minT, double maxT)
        {
                return filterBetween(0, 1, minT, maxT);         
        }

        public BidEventHistory filterBetween(double minU, double maxU, double minT, double maxT)
        {
                BidEventHistory bidEventHistory = new BidEventHistory();
                for (BidEvent e : history)
                {
                        if (minU < e.getMyUtility() &&
                                        e.getMyUtility() <= maxU &&
                                        minT < e.getTime() &&
                                        e.getTime() <= maxT)
                                bidEventHistory.add(e);
                }
                return bidEventHistory;                 
        }
        
        public void add(BidEvent e)
        {
                history.add(e);
        }
        
        public BidEvent getLastBidEvent()
        {
                if (history.isEmpty())
                        return null;

                BidEvent bidEvent = history.get(size() - 1);
                return bidEvent;
        }
        
        public BidEvent getFirstBidEvent()
        {
                if (history.isEmpty())
                        return null;

                BidEvent bidEvent = history.get(0);
                return bidEvent;
        }
        
        public Bundle getLastBid()
        {
                BidEvent lastBidEvent = getLastBidEvent();
                if (lastBidEvent == null)
                        return null;
                return lastBidEvent.getBid();
        }
        
        public Bundle getSecondLastBid()
        {
                if (history.size() < 2)
                        return null;
                
                return history.get(history.size() - 2).getBid();
        }
        
        public int size()
        {
                return history.size();
        }
        
        public List<BidEvent> getHistory()
        {
                return history;
        }
        
        /**
         * Get the {@link BidDetails} of the {@link Bid} with utility closest to u.
         */
        public BidEvent getBidEventOfUtility(double u)
        {
                double minDistance = -1;
                BidEvent closestBid = null;
                for (BidEvent e : history)
                {
                        double utility = e.getMyUtility();
                        if (Math.abs(utility - u) <= minDistance || minDistance == -1)
                        {
                                minDistance = Math.abs(utility - u);
                                closestBid = e;
                        }
                }
                return closestBid;
        }
        
        public double getMaximumUtility()
        {
                double max = -1;
                for (BidEvent b : history)
                {
                        double utility = b.getMyUtility();
                        if (utility >= max || max == -1)
                                max = utility;
                }
                return max;             
        }

        public double getMinimumUtility()
        {
                double min = -1;
                for (BidEvent b : history)
                {
                        double utility = b.getMyUtility();
                        if (utility <= min || min == -1)
                                min = utility;
                }
                return min;             
        }
        
        /**
         * Gets the best bid for me.
         */
        public Bundle getBestBid()
        {
                BidEvent bestBidEvent = getBestBidEvent();
                if (bestBidEvent == null)
                        return null;
                return bestBidEvent.getBid();
        }
        
        /**
         * Gets the details of the best bid for me.
         */
        public BidEvent getBestBidEvent()
        {
                double max = -1;
                BidEvent bestBid = null;
                for (BidEvent b : history)
                {
                        double utility = b.getMyUtility();
                        if (utility >= max || max == -1)
                        {
                                max = utility;
                                bestBid = b;
                        }
                }
                return bestBid;
        }
        
        /**
         * Gets the history part of the best n (or less) bids for me.
         */
        public BidEventHistory getBestBidHistory(int n)
        {
                BidEventHistory copySortedToUtility = getCopySortedToUtility();
                BidEventHistory best = new BidEventHistory();
                int i = 0;
                for (BidEvent e : copySortedToUtility)
                {
                        best.add(e);
                        i++;
                        if (i >= n)
                                break;
                }
                return best;
        }
        
        public BidEvent getRandom()
        {
                int size = size();
                if (size == 0)
                        return null;
                int index = (new Random()).nextInt(size);
                return history.get(index);
        }
        
        public BidEvent getRandom(Random r)
        {
                int size = size();
                if (size == 0)
                        return null;
                int index = r.nextInt(size);
                return history.get(index);
        }
        
        public double getAverageUtility()
        {
                int size = size();
                if (size == 0)
                        return 0;
                double totalUtil = 0;
                for (BidEvent e : history)
                        totalUtil += e.getMyUtility();
                return totalUtil / size;
        }
        
        public void sortToUtility()
        {
                if (TEST_EQUIVALENCE) {
                        Collections.sort(history, new BidEventStrictSorterUtility());
                } else {
                        Collections.sort(history, new BidEventSorterUtility());
                }
        }
        
        public BidEventHistory getCopySortedToUtility()
        {
                BidEventHistory bidEventHistoryCopy = new BidEventHistory(this);
                bidEventHistoryCopy.sortToUtility();
                return bidEventHistoryCopy;
        }

        public Bid getNextBid()
        {
                Bid b=null;
                
                
                
                return b;
        }
        
        @Override
        public String toString()
        {
                return "" + history;    
        }

        public Iterator<BidEvent> iterator()
        {
                return history.iterator();
        }
}