source: src/main/java/onetomany/bargainingchipsgame/BargainingChips.java@ 302

package onetomany.bargainingchipsgame;

import java.util.concurrent.BlockingQueue;
import java.util.concurrent.LinkedBlockingQueue;

import onetomany.bargainingchipsgame.interactions.Offer;
import onetomany.bargainingchipsgame.players.Agent;
import onetomany.bargainingchipsgame.players.BoulwareNegotiationParty;
import onetomany.bargainingchipsgame.players.CoordinationMessage;
import onetomany.bargainingchipsgame.players.Coordinator;
import onetomany.bargainingchipsgame.players.NegotiationStatusMessage;
import onetomany.bargainingchipsgame.players.utilityfunction.UF_CloseToQuantity;
import onetomany.bargainingchipsgame.players.utilityfunction.UtilityFunction;

/**
 * This package describes all the fundamental concepts in Bargaining Chips Game (BCG).
 * 
 * BCG rules are based on a non-alternating offer protocol in each bilateral negotiation thread. 
 * Multiple deals via simultaneous threads in the BCG one-to-many negotiation need to be coordinated.
 * So the players are equipped with two modules, one coordinator and multiple negotiators one per each thread.
 * 
 * One-to-Many package is dedicated to one-to-many negotiation which is a kind of negotiation different from bilateral and multilateral settings.
 * It is between a party which, in parallel, negotiates with many counter parties, opponents, on multiple multi-issue items. 
 * Of course each opponent, in turn, could be in one-to-many negotiation with its own opponents including this party.
 * 
 * Each of these individual negotiations is itself a bilateral negotiation over multiple items and multiple issues, a multi-issue multi-item thread. Each thread could reach a deal. 
 * So, the whole negotiation could reach multiple deals. 
 *  
 * Negotiating in this atmosphere needs some coordination efforts to synchronize threads according to the progress of each individual negotiation as well as the multiple deals compared with the party's preference.
 *   
 * Bargaining Chips Game, is a testbed dealing with these complexities.
 * The fundamental elements of its domain is in a package with this name (bargainingchipsname).
 * The players and the rules for their interactions are in packages `players' and 'interactions', respectively.
 * 
 *
 */
public class BargainingChips 
{
        public static void main(String[] args) throws InterruptedException 
        {
//              Domain domain = new Domain();
//              domain.add("Red"); domain.add("Green"); domain.add("Blue");
//              OutcomeSpace outcomeSpace = new OutcomeSpace(domain);
                
                BlockingQueue<Offer> in  = new LinkedBlockingQueue<Offer>();
                BlockingQueue<Offer> out = new LinkedBlockingQueue<Offer>();
                
                BlockingQueue<CoordinationMessage>      cin  = new LinkedBlockingQueue<CoordinationMessage>();
                BlockingQueue<NegotiationStatusMessage> cout = new LinkedBlockingQueue<NegotiationStatusMessage>();
                
                BlockingQueue<CoordinationMessage>      dummyin  = new LinkedBlockingQueue<CoordinationMessage>();
                BlockingQueue<NegotiationStatusMessage> dummyout = new LinkedBlockingQueue<NegotiationStatusMessage>();
                
                // Bob
                WishList wishlist       = new WishListBuilder().addWish("Green", 2).build();
                UtilityFunction u       = new UF_CloseToQuantity(wishlist);
                Agent bob1                      = new BoulwareNegotiationParty("Bob 1", u, in, out, cin, cout);
                
                System.out.println(bob1.toDescription());
                System.out.println("vs");
                
                Coordinator       c = new Coordinator(wishlist, cout, cin);
                
                // Sam
                WishList wishlistSam    = new WishListBuilder().addWish("Green", 10).build();
                UtilityFunction uSam    = new UF_CloseToQuantity(wishlistSam);
                Agent sam                               = new BoulwareNegotiationParty("Sam 1", uSam, out, in, dummyin, dummyout);
                
                System.out.println(sam.toDescription());
                
                Thread threadBuyer = new Thread(bob1);
                threadBuyer.start();
                
                Thread threadSeller = new Thread(sam);
                threadSeller.start();
                
                Thread threadCoordinator = new Thread(c);
                threadCoordinator.start();
        }

}