source: anac2020/Anaconda/src/main/java/geniusweb/exampleparties/anaconda/oponnentMap.java@ 14

package geniusweb.exampleparties.anaconda;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Comparator;
import java.util.HashMap;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Map;
import java.util.PriorityQueue;
import java.util.Set;

import geniusweb.bidspace.AllBidsList;
import geniusweb.issuevalue.Bid;
import geniusweb.issuevalue.Domain;
import geniusweb.issuevalue.Value;
import geniusweb.issuevalue.ValueSet;
import geniusweb.profile.PartialOrdering;

@SuppressWarnings("serial")
public class oponnentMap extends HashMap<String, List<impUnit>> {
        private Domain domain;
        private HashMap<Bid, Double> bidsRank;
        private ArrayList<Bid> historyBids;
        

        // importance map
        public oponnentMap(PartialOrdering profile) {
                super();
                this.domain = profile.getDomain();
                this.bidsRank = new HashMap<Bid, Double>();
                this.historyBids = new ArrayList<Bid>();
                // Create empty my import map and opponent's value map
                for (String issue : domain.getIssues()) {
                        ValueSet values = domain.getValues(issue);
                        List<impUnit> issueImpUnit = new ArrayList<>();
                        for (Value value : values) {
                                issueImpUnit.add(new impUnit(value));
                        }
                        this.put(issue, issueImpUnit);
                }
        }
        
        
        public void update(Bid receivedOfferBid) {
                for (String issue : receivedOfferBid.getIssues()) {
                        List<impUnit> currentIssueList = this.get(issue);
                        for (impUnit currentUnit : currentIssueList) {
                                if (currentUnit.valueOfIssue.equals(receivedOfferBid.getValue(issue))) {
                                        currentUnit.total_count += 1;
                                        break;
                                }
                        }
                }
                for (List<impUnit> impUnitList : this.values()) {
                        impUnitList.sort(new impUnit.impSumComparator());
                }
                this.historyBids.add(receivedOfferBid);
        }
        
        
        public void updateBidsRank(AllBidsList allBids) {
                for (Bid bid: allBids) {
                        this.bidsRank.put(bid, getImportance(bid));
                }
        }
        
        
        public List<Bid> getTopBids(List<Bid> bids, int topN) {
                class BidComparator implements Comparator<Bid> {

                        @Override
                        public int compare(Bid bid1, Bid bid2) {
                                return ((Double)getImportance(bid1)).compareTo((Double)(getImportance(bid2)));
                        }
                }
                
                Comparator<Bid> bidComparator = new BidComparator();
                PriorityQueue<Bid> bidsQueue = new PriorityQueue<Bid>(bids.size(), bidComparator);
                bidsQueue.addAll(bids);
                
                ArrayList<Bid> topBids = new ArrayList<Bid>();
                
                for(int i = 0; i < topN && i < bidsQueue.size(); i++) {
                        Bid bid = bidsQueue.poll();
                        topBids.add(bid);
                }
                
                return topBids;
        }

        public double getImportance(Bid bid) {
                int bidImportance = 0;
                for (String issue : bid.getIssues()) {
                        Value value = bid.getValue(issue);
                        int valueImportance = 0;
                        for (impUnit i : this.get(issue)) {
                                if (i.valueOfIssue.equals(value)) {
                                        valueImportance = i.total_count;
                                        break;
                                }
                        }
                        bidImportance += valueImportance;
                }
                return bidImportance;
        }

        public List<Bid> getEqualsBids(Bid bid) {
                List<Bid> keys = new ArrayList<>();
                double currentRank = getImportance(bid);
                for (Map.Entry<Bid, Double> entry : this.bidsRank.entrySet()) {
                    if (entry.getValue()==currentRank) {
                        keys.add(entry.getKey());
                    }
                }
                return keys;
        }
        
        
        public List<Bid> getMoreFreqBids(Bid bid) {
                double currentRank = getImportance(bid);
                Object[] arr = (Object[])(this.bidsRank.values().toArray());
                Arrays.sort(arr);
                Set<Object> uniqueVals = new LinkedHashSet<Object>(Arrays.asList(arr));
                arr = uniqueVals.toArray(); 
                
                int currentFreqIdx = -1;
                int nextFreqIdx = -1;

            for (int i = 0; (i < arr.length) && (currentFreqIdx == -1); i++) {
                if (Integer.parseInt(arr[i].toString()) == currentRank) {
                        currentFreqIdx = i;
                }
            }
            
            if (currentFreqIdx + 1 < arr.length) {
                nextFreqIdx = currentFreqIdx + 1;
            }
            else {
                nextFreqIdx = currentFreqIdx;
            }
            
                List<Bid> keys = new ArrayList<>();
                int biggerRank = (int) arr[nextFreqIdx];
                for (Map.Entry<Bid, Double> entry : this.bidsRank.entrySet()) {
                    if (entry.getValue()==biggerRank) {
                        keys.add(entry.getKey());
                    }
                }
                return keys;
        }
        
        
        public List<Bid> getLessFreqBids(Bid bid) {
                double currentRank = getImportance(bid);
                Object[] arr = (Object[])(this.bidsRank.values().toArray());
                Arrays.sort(arr);
                Set<Object> uniqueVals = new LinkedHashSet<Object>(Arrays.asList(arr));
                arr = uniqueVals.toArray(); 
                
                int currentFreqIdx = -1;
                int nextFreqIdx = -1;

            for (int i = 0; (i < arr.length) && (currentFreqIdx == -1); i++) {
                if (Integer.parseInt(arr[i].toString()) == currentRank) {
                        currentFreqIdx = i;
                }
            }
            
            if (currentFreqIdx - 1 >= 0) {
                nextFreqIdx = currentFreqIdx - 1;
            }
            else {
                nextFreqIdx = currentFreqIdx;
            }
            
                List<Bid> keys = new ArrayList<>();
                int smallerRank = (int) arr[nextFreqIdx];
                for (Map.Entry<Bid, Double> entry : this.bidsRank.entrySet()) {
                    if (entry.getValue()==smallerRank) {
                        keys.add(entry.getKey());
                    }
                }
                return keys;
        }

        public List<Bid> getBidsInRange(double lowerImportance, double higherImportance, AllBidsList allBids) {
                List<Bid> foundBids = new ArrayList<Bid>();

                for (Bid bid: allBids) {
                        double impOfBid = getImportance(bid);
                        if (impOfBid >= lowerImportance &&
                                        impOfBid <= higherImportance) {
                                foundBids.add(bid);
                        }
                }
                return foundBids;
        }
        
}