source: src/main/java/agents/anac/y2019/ibasic/boacomponents/IBasicOMStrategy.java@ 201

package agents.anac.y2019.ibasic.boacomponents;

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

import java.util.Set;


import genius.core.bidding.BidDetails;
import genius.core.boaframework.*;
import genius.core.utility.AbstractUtilitySpace;
import genius.core.uncertainty.UserModel;
import genius.core.misc.Range;


public class IBasicOMStrategy extends OMStrategy {

        double updateThreshold = 1.1;
        private Map<BidDetails, Integer> bidlistfreq;
        AbstractUtilitySpace utilSpace;
        UserModel usermodel;
        private SortedOutcomeSpace outcomespace;
        List<BidDetails> allBids;
        Map<BidDetails, Integer> finalbids;
        
        @Override
        public void init(NegotiationSession negotiationSession, OpponentModel model, Map<String, Double> parameters) {
                super.init(negotiationSession, model, parameters);
                if (parameters.get("t") != null) {
                        updateThreshold = parameters.get("t").doubleValue();
                } else {
                        System.out.println("OMStrategy assumed t = 1.1");
                }
                  //Initializes the usermodel, utility space and reservation value. 
                this.usermodel = negotiationSession.getUserModel();
                this.utilSpace = negotiationSession.getUtilitySpace();
                        
                //If we operate under preference uncertainty, we recalculate the utility space. 
                if (usermodel != null)
                        this.utilSpace = IBasicPU.createUtilitySpace(negotiationSession.getDomain(), usermodel);
                        
                //Sets the outcomespace with the respective utility space
                this.outcomespace = new SortedOutcomeSpace(utilSpace);
                negotiationSession.setOutcomeSpace(outcomespace);
                this.bidlistfreq = new HashMap<BidDetails, Integer>();
                initbidlist();
                finalbids = new HashMap<BidDetails, Integer>();
                
        }
        
        //Initializes all of the bids
        private void initbidlist() {
                allBids = this.outcomespace.getAllOutcomes();
                for( BidDetails bids : allBids) {
                        this.bidlistfreq.put(bids, 0);
                }
        }
        
        //Updates the frequency recording list of our bids
        private void Updatebidslist(BidDetails bid) {
                int i;

                for(BidDetails key : bidlistfreq.keySet()) {
                        if(key.equals(bid)){
                                i = this.bidlistfreq.get(key);
                                this.bidlistfreq.replace(key, i += 2);
                        }
                }
        }

        @Override
        public BidDetails getBid(List<BidDetails> allBids) {
                return null;
        }

        //Returns the best bid from the given list according to the stage we are in
        public BidDetails BestBid(double utilgoal, List<BidDetails> oppbids) {
                List<BidDetails> selectedbids = SelectBids(utilgoal);
                BidDetails Bestbid;
                HashMap<BidDetails, Integer> tempbidmap = new HashMap<BidDetails, Integer>();
                for( BidDetails bid : selectedbids) {
                        if(bidlistfreq.containsKey(bid)) {
                                tempbidmap.put(bid, bidlistfreq.get(bid));
                        }
                }
                
                Bestbid = getMin(tempbidmap);

                int  currenttime = (int) negotiationSession.getTimeline().getCurrentTime();
                int  totaltime = (int) negotiationSession.getTimeline().getTotalTime();
                double phase = (double) currenttime /totaltime;
                if(phase > .25 && currenttime % 4 == 0) {
                        Bestbid = (SelectNearParetoBid(selectedbids) == null) ? Bestbid : SelectNearParetoBid(selectedbids);
                }
                if(currenttime >= totaltime -10) {
                        selectedbids = SelectBids(new Range(utilgoal, 1));
                        BidDetails lastbid = SelectFinalOffer(selectedbids);
                        Bestbid = (lastbid == null) ? Bestbid : lastbid;
                }
                if(Bestbid.getMyUndiscountedUtil() <= BestOpponentbid(oppbids).getMyUndiscountedUtil()) {
                        Bestbid = BestOpponentbid(oppbids);
                }
                Updatebidslist(Bestbid);
                return Bestbid;
        }
        
        //Return the best opponent bid
        public BidDetails BestOpponentbid(List<BidDetails> oppbids) {
                BidDetails bestbid = oppbids.get(0);
                double bestutility = bestbid.getMyUndiscountedUtil();
                for(BidDetails bidd : oppbids) {
                        if(bidd.getMyUndiscountedUtil() > bestutility) {
                                bestbid = bidd;
                                bestutility = bidd.getMyUndiscountedUtil();
                        }
                }
                return bestbid;
        }
        
        private static BidDetails getMin (HashMap<BidDetails, Integer> freqlist) {
                
            BidDetails minKey = null;
            int minValue = Integer.MAX_VALUE;
            for (BidDetails key : freqlist.keySet()) {
                int value = freqlist.get(key);
                if (value < minValue) {
                    minValue = value;
                    minKey = key;
                }
            }
            return minKey;
        }
        
        //Gets an amount of bids within the specified range given to the method. 
        public List<BidDetails> SelectBids(Range range){
                List<BidDetails> bidlist = new ArrayList<>();
                for(BidDetails key : bidlistfreq.keySet()) {
                        if (key.getMyUndiscountedUtil() >= range.getLowerbound() && key.getMyUndiscountedUtil() <=  range.getUpperbound())
                                bidlist.add(key);
                }
                return bidlist;
        }
        
        public List<BidDetails> SelectBids(Double utilgoal){
                return outcomespace.getBidsinRange(new Range(utilgoal - .05, utilgoal + .05));
        }
        
        //Gets bids near the Pareto Line
        private BidDetails SelectNearParetoBid(List<BidDetails> selectedBids) {
                BidDetails paretobid = null;
                double paretodiff = 0;
                for(BidDetails bid : selectedBids) {
                        double diff = this.model.getBidEvaluation(bid.getBid()) + bid.getMyUndiscountedUtil() ;
                        if(diff > paretodiff ) {
                                paretobid = bid;
                                paretodiff = diff;
                        }
                }
                return paretobid;
        }
        
        //This method is used in order to get a bid in the last couple of rounds. 
        private BidDetails SelectFinalOffer(List<BidDetails> selectedbids) {
                BidDetails finaloffer = null;
                double totalutil = 0;
                HashMap<BidDetails, Integer> tempbidmap = new HashMap<BidDetails, Integer>();
                if(finalbids.size() == 0) {
                        initfinalbids(selectedbids);
                for(BidDetails bid: finalbids.keySet()) {
                        if(bid.getMyUndiscountedUtil() < this.model.getBidEvaluation(bid.getBid())) {
                                double diff = this.model.getBidEvaluation(bid.getBid()) + bid.getMyUndiscountedUtil();
                                if(diff > totalutil ) {
                                        tempbidmap.put(bid, finalbids.get(bid));
                                        ;
                                }
                        }
                }
                }
                finaloffer = getMin(tempbidmap);
                Updatefinalbids(finaloffer);
                return finaloffer;
        }
        
        //Initializes the final offers that the agent will make
        private void initfinalbids(List<BidDetails> bidlist) {
                for (BidDetails bid : bidlist) {
                        finalbids.put(bid, 0);
                }
        }
        
        private void Updatefinalbids(BidDetails bid) {
                int i;

                for(BidDetails key : finalbids.keySet()) {
                        if(key.equals(bid)){
                                i = this.finalbids.get(key);
                                this.finalbids.replace(key, i += 2);
                        }
                }
        }

        @Override
        public boolean canUpdateOM() {
                return negotiationSession.getTime() < updateThreshold;
        }

        @Override
        public Set<BOAparameter> getParameterSpec() {
                Set<BOAparameter> set = new HashSet<BOAparameter>();
                set.add(new BOAparameter("t", 1.1, "Time after which the OM should not be updated"));
                return set;
        }

        @Override
        public String getName() {
                return "IBasicOMS";
        }
}