source: src/main/java/negotiator/parties/EnumeratorParty.java

package negotiator.parties;

import java.io.FileNotFoundException;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.List;

import genius.core.AgentID;
import genius.core.Bid;
import genius.core.Domain;
import genius.core.actions.Action;
import genius.core.actions.Offer;
import genius.core.issue.Issue;
import genius.core.issue.IssueDiscrete;
import genius.core.issue.Value;
import genius.core.logging.CsvLogger;
import genius.core.parties.AbstractNegotiationParty;
import genius.core.parties.NegotiationInfo;

/**
 * Debug class for enumerating all offers to a file
 */
public class EnumeratorParty extends AbstractNegotiationParty {

        public static int id = 0;

        @Override
        public void init(NegotiationInfo info) {
                super.init(info);

                // vars
                Domain dom = getUtilitySpace().getDomain();
                List<Integer> issueSizes = new ArrayList<Integer>();
                for (Issue issue : dom.getIssues())
                        issueSizes.add(((IssueDiscrete) issue).getNumberOfValues());

                System.out.printf("Enumerating all %d possible offers\n", dom.getNumberOfPossibleBids());
                System.out.printf("There are %d issues with the following number of values: %s\n", dom.getIssues().size(),
                                issueSizes.toString());
                try {
                        String party = "unknown";
                        switch (id) {
                        case 0:
                                party = "Minister";
                                break;
                        case 1:
                                party = "NS";
                                break;
                        case 2:
                                party = "ProRail";
                                break;
                        }

                        id++;
                        CsvLogger logger = new CsvLogger(String.format("Railway-%s-utils.csv", party));

                        for (int issueIndex = 0; issueIndex < issueSizes.size(); issueIndex++) {
                                logger.log(String.format("\"Issue %d\"", issueIndex + 1));
                        }
                        logger.logLine("utility");

                        for (int bidIndex = 0; bidIndex < dom.getNumberOfPossibleBids(); bidIndex++) {
                                Integer[] issueIndices = new Integer[issueSizes.size()];
                                Arrays.fill(issueIndices, 0);
                                int remainder = bidIndex;
                                int currentIndex = 0;

                                while (remainder > 0) {
                                        int size = issueSizes.get(currentIndex);
                                        int div = remainder / size;
                                        int mod = remainder % size;

                                        issueIndices[currentIndex] = mod;
                                        remainder = div;
                                        currentIndex++;
                                }

                                Bid bid = generateBid(issueIndices);
                                double util = getUtility(bid);

                                System.out.printf("%s -> %.3f\n", new ArrayList<Integer>(Arrays.asList(issueIndices)), util);
                                for (Integer issueIndex : issueIndices) {
                                        logger.log(issueIndex);
                                }
                                logger.logLine(util);
                        }

                        logger.close();
                } catch (FileNotFoundException e) {
                        System.err.println("Problems starting EnumeratorParty logger");
                        e.printStackTrace();
                } catch (IOException e) {
                        System.err.println("Problems closing EnumeratorParty logger");
                        e.printStackTrace();
                }

                System.out.println("Enumeration finished\n");
        }

        public Bid generateBid(Integer[] indices) {

                HashMap<Integer, Value> values = new HashMap<Integer, Value>();

                for (int i = 0; i < indices.length; i++) {
                        IssueDiscrete issue = (IssueDiscrete) getUtilitySpace().getDomain().getIssues().get(i);
                        values.put(i + 1, issue.getValue(indices[i]));
                }

                try {
                        return new Bid(getUtilitySpace().getDomain(), values);
                } catch (Exception e) {
                        System.err.println("Could not generate offer");
                        return null;
                }
        }

        @Override
        public Action chooseAction(List<Class<? extends Action>> possibleActions) {
                return new Offer(getPartyId(), generateRandomBid());
        }

        @Override
        public void receiveMessage(AgentID sender, Action arguments) {
                // do nothing
        }

        @Override
        public String getDescription() {
                return "Enumerator Party for Debug";
        }
}