source: src/main/java/agents/anac/y2019/harddealer/HardDealer.java

package agents.anac.y2019.harddealer;

import java.util.List;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.Map;

import agents.anac.y2019.harddealer.math3.optimization.GoalType;
import agents.anac.y2019.harddealer.math3.optimization.PointValuePair;
import agents.anac.y2019.harddealer.math3.optimization.linear.LinearConstraint;
import agents.anac.y2019.harddealer.math3.optimization.linear.LinearObjectiveFunction;
import agents.anac.y2019.harddealer.math3.optimization.linear.Relationship;
import agents.anac.y2019.harddealer.math3.optimization.linear.SimplexSolver;
import genius.core.Bid;
import genius.core.boaframework.AcceptanceStrategy;
import genius.core.boaframework.BoaParty;
import genius.core.boaframework.OMStrategy;
import genius.core.boaframework.OfferingStrategy;
import genius.core.boaframework.OpponentModel;
import genius.core.issue.Issue;
import genius.core.issue.IssueDiscrete;
import genius.core.issue.ValueDiscrete;
import genius.core.parties.NegotiationInfo;
import genius.core.uncertainty.AdditiveUtilitySpaceFactory;
import genius.core.utility.AbstractUtilitySpace;


@SuppressWarnings({"serial", "deprecation"})
public class HardDealer extends BoaParty
{
        @Override
        public void init(NegotiationInfo info)
        {
                // The choice for each component is made here
                AcceptanceStrategy      ac  = new HardDealer_AS();
                OfferingStrategy        os  = new HardDealer_BS();
                OpponentModel           om  = new HardDealer_OM();
                OMStrategy                      oms = new HardDealer_OMS();

                // All component parameters can be set below.
                Map<String, Double> noparams = Collections.emptyMap();
                Map<String, Double> osParams = new HashMap<String, Double>();
                // Set the concession parameter "e" for the offering strategy to yield Boulware-like behavior
                osParams.put("e", 1.8 / info.getDeadline().getTimeOrDefaultTimeout());

                // Initialize all the components of this party to the choices defined above
                configure(ac, noparams,
                                os,     osParams,
                                om, noparams,
                                oms, noparams);
                super.init(info);
        }

    // total number of values
    private int nValues;
    // occurrences of the values in bids
    private Integer[] occurenceCheck;
    
        @Override
    public AbstractUtilitySpace estimateUtilitySpace() {                
                AdditiveUtilitySpaceFactory additiveUtilitySpaceFactory = new AdditiveUtilitySpaceFactory(getDomain());
        List<IssueDiscrete> issues = additiveUtilitySpaceFactory.getIssues();

        List<Bid> ranking = userModel.getBidRanking().getBidOrder();
        double maxUtil = userModel.getBidRanking().getHighUtility();
        double minUtil = userModel.getBidRanking().getLowUtility();
        
     // The linear method estimates the utilities but does nothing with the issue weights.
        // We use a variance and spread based method to estimate these issue weights. 
                List<Bid> bidOrder = userModel.getBidRanking().getBidOrder();

                /**
                 * Create a custom issue weight
                 * Iterate over all values in all bids to build up the issue weights.
                 */
                
                int bidOrderSize = bidOrder.size();
                int numberOfIssues = 0;
                // Initialize dictionaries in which we will store information we will extract from the bidranking.
                // Information for the Values
                // v1. Store at which index each value occurs in the bidranking
                // v2. Store the mean index in the ranking of each value
                // v3. Store the variance for each value
                Map<String, ArrayList<Integer>> valueIndicesListDict = new HashMap<String, ArrayList<Integer>>();
                Map<String, Double> valueMeanIndexDict = new HashMap<String, Double>();
                Map<String, Double> valueVarianceDict = new HashMap<String, Double>();  
                
                // Information for the Issues
                // i1. Store the variance for each issue (combined value variance)
                // i2. Store the spread of each issue (how far apart are the mean indices of its values)
                // i3. Store the Weight of the Issues
                Map<Issue, Double> issueVarianceDict = new HashMap<Issue, Double>();
                Map<Issue, Double> issueSpreadDict = new HashMap<Issue, Double>();
                Map<Issue, Double> issueWeightDict = new HashMap<Issue, Double>();

                // Variable that can be tweaked:
                // Tweaks how much the weights are shifted when converting from variance to partial issue weight.
                double inverseShiftVariable = 2;
                
                // Tweaks the ratio between the usage of the variance and the spread of the means within an issue to build the issue weight.
                // This variable is scaled automatically dependinng on the size of the bidordering.
                // The transition value of 40 bids in the bidranking has been chosen trough extensive testing.
                double blendVariable = 1-(Math.min(bidOrderSize/40,1));

                // Create a list of all issuevalue strings. This is used for looping over all values in the dictionary.
                // Initialize the valueIndicesListDict with all the values and initialize empty ArrayLists.
                ArrayList<String> listOfAllIssueValues = new ArrayList<String>();
                for (Issue i : issues)
                {
                        List<ValueDiscrete> values = ((IssueDiscrete) i).getValues();
                        for (ValueDiscrete v : values)
                        {
                                ArrayList<Integer> indicesList = new ArrayList<Integer>();
                                String IssueValueString =  i.getName() +v.toString();

                                valueIndicesListDict.put(IssueValueString , indicesList);
                                listOfAllIssueValues.add(IssueValueString);
                        }
                        numberOfIssues += 1;
                }

    // 1. Build up the double representation of the issue weights by using the variance and the spread.
                // Build the valueIndicesListDict by iterating trough all bids and storing the location of the values.
                int bidIndex = 0;
                for (Bid bid : bidOrder)
                {
                        for (Issue i : issues)
                        {
                                // Fill the valueIndicesListDict with the indices at which these values occur.
                                int no = i.getNumber();
                                ValueDiscrete value = (ValueDiscrete) bid.getValue(no);
                                String IssueValueString =  i.getName() +value.toString();
                                ArrayList<Integer> indicesList = valueIndicesListDict.get(IssueValueString);
                                indicesList.add(bidIndex);
                                valueIndicesListDict.replace(IssueValueString,indicesList);
                        }
                        // Setup for the next bid in the loop
                        bidIndex += 1;
                }

                // Calculate variance for each value.
                for (String key : listOfAllIssueValues)
                {
                        ArrayList<Integer> indicesList = valueIndicesListDict.get(key);
                        int sumOfIndices = indicesList.stream().mapToInt(Integer::intValue).sum();
                        double mu;
                        if (sumOfIndices == 0)
                        {
                                mu = bidOrderSize/2;
                        } 
                        else 
                        {
                                mu = sumOfIndices / indicesList.size();
                        }
                        valueMeanIndexDict.put(key,mu);
                        double P = ((double) 1) / indicesList.size();

                        ArrayList<Double> listOfPartialVariance = new ArrayList<Double>();
                        for (int index : indicesList)
                        {
                                double partialVariance = Math.pow((index - mu),2.0) * P;
                                listOfPartialVariance.add(partialVariance);
                        }

                        double variance = listOfPartialVariance.stream().reduce(0.0, Double::sum);
                        valueVarianceDict.put(key,variance);
                }

                // Add the variances of the values together to get issue variances.
                // Determine the spread of the mean values within the issues.
                for (Issue i : issues)
                {
                        double issueVariance = 0;
                        double issueSpread = 0;
                        List<ValueDiscrete> values = ((IssueDiscrete) i).getValues();
                        for (ValueDiscrete v : values)
                        {
                                String IssueValueString = i.getName()+v.toString();
                                double middleIndex = bidOrderSize/2;
                                double meanIndex = valueMeanIndexDict.get(IssueValueString);
                                double distanceFromMiddleIndex = Math.abs(meanIndex - middleIndex);
                                issueSpread += distanceFromMiddleIndex;
                                issueVariance += valueVarianceDict.get(IssueValueString);
                        }
                        issueSpreadDict.put(i, issueSpread);
                        issueVarianceDict.put(i,issueVariance);
                }

                // Normalize the spread
                double totalSpread = 0;
                for (Issue i : issues)
                {
                        totalSpread += issueSpreadDict.get(i);
                }
                for (Issue i : issues)
                {
                        double spread = issueSpreadDict.get(i);
                        double normalizedSpread = spread/totalSpread;
                        issueSpreadDict.replace(i,normalizedSpread);
                }

                // Calculate the max variance
                double oldValue = 0;
                double maxVariance = 0;
                for (Issue i : issues)
                {
                        double newValue = issueVarianceDict.get(i);
                        maxVariance = Math.max(newValue,oldValue);
                        oldValue = newValue;
                }

                // Normalize the variance and translate it to a partial issueWeight
                double totalIssueWeight = 0;
                for (Issue i : issues)
                {
                        double oldVariance = issueVarianceDict.get(i);
                        double partialIssueWeight = Math.abs(inverseShiftVariable - oldVariance/maxVariance);
                        totalIssueWeight += partialIssueWeight;
                        issueWeightDict.put(i,partialIssueWeight);
                }

                // Normalize the partial Issue weights
                for (Issue i: issues)
                {
                        double oldWeight = issueWeightDict.get(i);
                        double newWeight = oldWeight/totalIssueWeight;
                        issueWeightDict.replace(i,newWeight);
                }
                // Combine spread and variance into one issue weight and load into Genius. Use a blendVariable to adjust their ratio
                for (Issue i : issues)
                {
                        double finalIssueWeight = (issueWeightDict.get(i) * blendVariable) + (issueSpreadDict.get(i) * (1 - blendVariable));
                issueWeightDict.replace(i, finalIssueWeight);
                        additiveUtilitySpaceFactory.setWeight(i, finalIssueWeight);
                }

// The issue weights are now constructed, now we are going to generate the weights of the values trough linear programming.
        // All values are collected in a LinkedHashMap
        LinkedHashMap<IssueDiscrete, List<ValueDiscrete>> valuesMap = new LinkedHashMap<>();

        nValues = 0;
        for (IssueDiscrete issue : issues) {
            valuesMap.put(issue, issue.getValues());
            nValues += issue.getValues().size();
        }

        occurenceCheck = new Integer[nValues];
        Arrays.fill(occurenceCheck,0);

        int nSlackVariables = ranking.size()-1;
        // The number of variables needed for the linear optimization
        int nVariables = nSlackVariables + nValues;

        // The objective function is to minimize all slack variables
        // Therefore, all the slack variables should have a coefficient of 1, and all the other should have a coefficient of 0
        double[] functionList = new double[nVariables];
        Arrays.fill(functionList, 0);

        for (int i = 0; i < nSlackVariables; i++) {
            functionList[i] = 1;
        }

        LinearObjectiveFunction f = new LinearObjectiveFunction(functionList, 0);

        // A collection with all constraints
        Collection<LinearConstraint> constraints = new ArrayList<>();
        createVarGEQ0Constraints(constraints, functionList, nSlackVariables);
        createSlackComparisonGEQ0Constraints(constraints, functionList, nSlackVariables, valuesMap, ranking);
        createMaxMinConstraints(constraints, valuesMap, ranking, nSlackVariables, maxUtil, minUtil);

        
        // Use a Simplex solver to solve f
        SimplexSolver solver = new SimplexSolver();
        solver.setMaxIterations(Integer.MAX_VALUE);
        PointValuePair solution = solver.optimize(f, constraints, GoalType.MINIMIZE, true);

        // The average utility of a value is estimated based on the max utility, min utility and the variance within the bid ranking.
                double functionIndex = totalIssueWeight/numberOfIssues;
                double exponent = 5 - (4/(1+Math.exp(-50*(functionIndex-1))));
                double yScale = maxUtil - minUtil;
        
        double average = minUtil + yScale*Math.pow(0.5, exponent);
        // Initialization of new utilities
        // The utilities of the actual values are stored at indices after the slack variables,
        // so start iterating after nSlackVariables
        int iterator = nSlackVariables;
        for (IssueDiscrete issue : issues) {
            // In case there is not much information about the value (0, 1 or 2 occurrences), it also takes the average into consideration
            for (int v = 0; v < issue.getNumberOfValues(); v++) {
                if(occurenceCheck[iterator - nSlackVariables] < 3) {
                    int occ = occurenceCheck[iterator - nSlackVariables];
                    double util = ((occ * solution.getPoint()[iterator]) + average) / (occ + 1);                
                    additiveUtilitySpaceFactory.setUtility(issue, issue.getValue(v), util);
                }
                else {
                    additiveUtilitySpaceFactory.setUtility(issue, issue.getValue(v), solution.getPoint()[iterator]);
                }

                iterator++;
            }
        }
        // Normalize the weights
        additiveUtilitySpaceFactory.normalizeWeights();
    
        // The factory is done with setting all parameters, now return the estimated utility space
        return additiveUtilitySpaceFactory.getUtilitySpace();
    }

        
    // Transforms a bid into a double list of 0's and 1's representing it values
    private double[] valuesFunctionList(Bid bid, LinkedHashMap<IssueDiscrete, List<ValueDiscrete>> values, int nSlackValues) {
        double[] linear = new double[nSlackValues + nValues];
        Arrays.fill(linear, 0);

        int count = 0;

        // A 1 is placed at the corresponding value position
        for (int i = 0; i < bid.getIssues().size(); i++) {
            ValueDiscrete v = (ValueDiscrete) bid.getValue(i+1);

            for (int val = 0; val < values.get(bid.getIssues().get(i)).size(); val++) {
                ValueDiscrete v2 = values.get(bid.getIssues().get(i)).get(val);
                if (v.equals(v2)) {
                    linear[count + nSlackValues] = 1;
                    occurenceCheck[count] += 1;
                }
                count++;
            }
        }
        return linear;
    }

    // Creates a 'variable is greater or equal than 0' constraint for all slack and value variables
    private void createVarGEQ0Constraints(Collection<LinearConstraint> constraints, double[] functionList, int nSlackVariables) {
        for (int i = 0; i < functionList.length; i++) {
                // reset all coefficients to 0
            Arrays.fill(functionList, 0);
            // set the coefficient for variable i to 1
            functionList[i] = 1;
            // create the greater or equal constraint
            constraints.add(new LinearConstraint(functionList, Relationship.GEQ, 0));
        }
    }

    // Creates the 'slack + comparison variable is greater or equal than 0' constraints for every slack and corresponding comparison variable
    private void createSlackComparisonGEQ0Constraints(Collection<LinearConstraint> constraints, double[] functionList, int nSlackVariables, LinkedHashMap<IssueDiscrete, List<ValueDiscrete>> values, List<Bid> ranking) {
        for (int i = 0; i < nSlackVariables; i++) {
                // reset all coefficients to 0
            Arrays.fill(functionList, 0);
            // get bid o
            Bid o = ranking.get(i);
            // get bid o'
            Bid oPrime = ranking.get(i+1);
            // create a function list for o
            double[] oList = valuesFunctionList(o, values, nSlackVariables);
            // create a function list for o'
            double[] oPrimeList = valuesFunctionList(oPrime, values, nSlackVariables);
            // create the delta u as values of o - values of o'
            for(int j = 0; j < functionList.length; j++) {
                functionList[j] = oPrimeList[j] - oList[j];
            }
            // set the coefficient of slack variable i to 1
            functionList[i] = 1;
            constraints.add(new LinearConstraint(functionList, Relationship.GEQ, 0));
        }
    }

    // Creates the constraints which represent the max and min utility
    private void createMaxMinConstraints(Collection<LinearConstraint> constraints,
                                                  LinkedHashMap<IssueDiscrete, List<ValueDiscrete>> values, List<Bid> ranking, int nSlackVariables, double maxU, double minU) {
        
        Bid strongestBid = ranking.get(ranking.size()-1);
        double[] functionList = valuesFunctionList(strongestBid, values, nSlackVariables);
        // The comparison strongest bid == maxU is added
        constraints.add(new LinearConstraint(functionList, Relationship.EQ, maxU));
        
        Bid weakestBid = ranking.get(0);
        functionList = valuesFunctionList(weakestBid, values, nSlackVariables);
        // The comparison strongest bid == maxU is added
        constraints.add(new LinearConstraint(functionList, Relationship.EQ, minU));

    }

    
        @Override
        public String getDescription()
        {
                return "Hardheaded but concedes at the very end to make a deal.";
        }
        // All the rest of the agent functionality is defined by the components selected above, using the BOA framework
}