source: src/main/java/bargainingchips/players/BargainingBuyer.java@ 340

/**
 * 
 */
package bargainingchips.players;

import java.util.List;
import java.util.Random;
import java.util.ArrayList;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.LinkedBlockingQueue;

import bargainingchips.ChipIssueValue;
import bargainingchips.ChipIssueValueBuilder;
import bargainingchips.NegotiationContext;
import bargainingchips.actions.Offer;
import bargainingchips.actions.OfferBy;
import bargainingchips.messaging.coordination.CoordinationMessage;
import bargainingchips.messaging.status.StatusMessage;
import bargainingchips.protocol.AsynchronousOffersProtocol;
import bargainingchips.utilityfunctions.UtilityFunction;
import bargainingchips.wishlist.WishList;
import bargainingchips.wishlist.WishListBuilder;
//import bargainingchips.utilityfunctions.UF;
import bargainingchips.utilityfunctions.UF_BezierPriceBezierQuantity;
import bargainingchips.utilityfunctions.UF_BezierPriceGaussianQuantity;
import bargainingchips.utilityfunctions.UF_CloseToQuantity;
import bargainingchips.utilityfunctions.UF_IntensifiedLessPriceCloseToQuantity;
import bargainingchips.utilityfunctions.UF_LessPrice;
import bargainingchips.utilityfunctions.UF_LessPriceCloseToQuantity;
import bargainingchips.utilityfunctions.UF_PeakedFlatCurvePriceGaussianQuantity;
import bargainingchips.utilityfunctions.UF_PeakedFlatPricePeakedFlatQuantity;
import bargainingchips.utilityfunctions.UF_PeakedPricePeakedQuantity;

/**
 * The {@link Buyer} class is extended in a way that the buyer negotiators could be created by using different random utility functions among 
 * UF_CloseToQuantity, UF_LessPrice, UF_LessPriceCloseToQuantity, UF_IntensifiedLessPriceCloseToQuantity, UF_PeakedPricePeakedQuantity, 
 * UF_PeakedFlatPricePeakedFlatQuantity, UF_PeakedFlatCurvePriceGaussianQuantity, UF_BezierPriceBezierQuantity, and 
 * UF_BezierPriceGaussianQuantity, where the first function takes only quantity into account, 
 * the second function considers only price, but all the others deal with both price and quantity, receive different numbers of parameters, 
 * and consider the importance of issues (i.e., for price, quantity, etc.) as well as the importance of Chips (i.e., colors) with respect to each other. 
 * It also created buyer negotiators using either Boulware or Bargaining (based on NiceTitForTat) negotiation strategies.
 *  
 *  
 * @author Faria Nassiri-Mofakham
 *
 */


public class BargainingBuyer {

        private Coordinator c;
        private BlockingQueue<CoordinationMessage> cin;
        private BlockingQueue<StatusMessage> cout;
        
        private List<NegotiationThread> threads;
        
        public BargainingBuyer(WishList overallWishlist)//, ChipIssueValue<Double> breakEvenPrices, boolean priceVSQuantity) 
        {
                cin = new LinkedBlockingQueue<CoordinationMessage>();
                cout = new LinkedBlockingQueue<StatusMessage>();                
                
                // Coordinator
                c = new Coordinator(overallWishlist, cout, cin);
                
                threads = new ArrayList<NegotiationThread>();
        }
        
        public void connectSeller(String sellerName, WishList wishlistSam)
        {
                // Set up the protocol
                BlockingQueue<OfferBy> from  = new LinkedBlockingQueue<OfferBy>();
                BlockingQueue<Offer> toBuyer = new LinkedBlockingQueue<Offer>();
                BlockingQueue<Offer> toSeller = new LinkedBlockingQueue<Offer>();

                String bobiName         = "Bob" + " " + getThreadNumber();

                AsynchronousOffersProtocol aop = new AsynchronousOffersProtocol(from, bobiName, toBuyer, sellerName, toSeller);

                NegotiationContext context = new NegotiationContext();
                
                // Make a new subnegotiator
                WishList wishlist = new WishListBuilder().addWish("Green", 4).addWish("Yellow", 6).addWish("Orange", 40).build();
                ChipIssueValue<Double> breakEvenPrices = new ChipIssueValueBuilder<Double>().addIssue("Green", 3.0).addIssue("Yellow", 5.0).addIssue("Orange", 1.0).build();
                ChipIssueValue<Double[]> prices1 = new ChipIssueValueBuilder<Double[]>().addIssue("Green", new Double[] {3.0, 4.8}).addIssue("Yellow", new Double[] {5.0, 8.0}).addIssue("Orange", new Double[] {1.0, 2.5}).build();
                ChipIssueValue<Double> uPrices1 = new ChipIssueValueBuilder<Double>().addIssue("Green", 1.0).addIssue("Yellow", 0.8).addIssue("Orange", 0.75).build();
                ChipIssueValue<Integer> deviations1 = new ChipIssueValueBuilder<Integer>().addIssue("Green", 1).addIssue("Yellow", 1).addIssue("Orange", 10).build();
                ChipIssueValue<Double[]> prices2 = new ChipIssueValueBuilder<Double[]>().addIssue("Green", new Double[] {3.0, 3.5, 4.8, 5.0}).addIssue("Yellow", new Double[] {5.0, 5.2, 6.2, 8.0}).addIssue("Orange", new Double[] {1.0, 1.8, 2.5, 3.0}).build();
                ChipIssueValue<Double[]> uPrices2 = new ChipIssueValueBuilder<Double[]>().addIssue("Green", new Double[] {0.7, 0.2}).addIssue("Yellow", new Double[] {0.8, 0.1}).addIssue("Orange", new Double[] {0.9, 0.3}).build();
                ChipIssueValue<Double[]> deviations2 = new ChipIssueValueBuilder<Double[]>().addIssue("Green", new Double[] {100.0, 20.0, 50.0, 500.0}).addIssue("Yellow", new Double[] {50.0, 30.0, 30.0, 50.0}).addIssue("Orange", new Double[] {200.0, 40.0, 60.0, 1000.0}).build();
                ChipIssueValue<Double[]> uDev2 = new ChipIssueValueBuilder<Double[]>().addIssue("Green", new Double[] {0.25, 0.8, 0.9, 0.1}).addIssue("Yellow", new Double[] {0.3, 0.7, 0.7, 0.3}).addIssue("Orange", new Double[] {0.15, 0.95, 0.85, 0.3}).build();
                ChipIssueValue<Integer[]> deviations3 = new ChipIssueValueBuilder<Integer[]>().addIssue("Green", new Integer[] {2,1,2,3}).addIssue("Yellow", new Integer[] {3,2,2,3}).addIssue("Orange", new Integer[] {10,2,5,10}).build();
                ChipIssueValue<Double> wC = new ChipIssueValueBuilder<Double>().addIssue("Green", 0.5).addIssue("Yellow", 0.3).addIssue("Orange", 0.2).build();
                double wP = 0.6; 
                double wQ = 0.4;
                boolean pq = ( (wP > wQ) ? true : false); // true, if less price is more important; false, if close to quantity is important.
                // boolean pq = ((new Random().nextInt(2)+1 == 1) ? true : false);  
                int m=4; // input Bezier points    
                
                 //One utility function is assigned to bobi, in random
//               UtilityFunction u              = new UF(wishlist, breakEvenPrices, prices1, uPrices1, deviations1, uPrices2, prices2, deviations2, uDev2, deviations3, wC, wP, wQ, pq, m );                    
                UtilityFunction u = null;
                switch(new Random().nextInt(9)+1) 
                {
                        case 1: u = new UF_CloseToQuantity(wishlist); break;
                        case 2: u = new UF_LessPrice(wishlist, breakEvenPrices); break;
                        case 3: u = new UF_LessPriceCloseToQuantity(wishlist, breakEvenPrices); break;
                        case 4: u = new UF_IntensifiedLessPriceCloseToQuantity(wishlist, breakEvenPrices, pq); break;
                        case 5: u = new UF_PeakedPricePeakedQuantity(wishlist, breakEvenPrices, deviations1, wC, wP, wQ); break;
                        case 6: u = new UF_PeakedFlatPricePeakedFlatQuantity(wishlist, deviations2, uDev2, prices2, uPrices2, wC, wP, wQ); break;
                        case 7: u = new UF_PeakedFlatCurvePriceGaussianQuantity<Double>(wishlist, prices1, uPrices1, deviations1, wC, wP, wQ); break;
                        case 8: u = new UF_BezierPriceBezierQuantity<Double> (wishlist, m, prices2, deviations3, wC, wP, wQ); break;
                        case 9: u = new UF_BezierPriceGaussianQuantity<Double> (wishlist, m, prices2, deviations1, wC, wP, wQ); break;
                }
                
                Agent bobi                              = ((new Random().nextInt(2)+1 == 1) ? 
                                                                                new BoulwareAgent(bobiName, u, context, toBuyer, from, cin, cout) :
                                                                                new BargainingAgent(bobiName, u, context, toBuyer, from, cin, cout));
                
                
                
                // Seller
                UtilityFunction uSam    = new UF_CloseToQuantity(wishlistSam);
                Agent sam                               = new BasicAgent(sellerName, uSam, context, toSeller, from);
                
                // The thread
                NegotiationThread thread = new NegotiationThread();
                thread.protocol = aop;
                thread.subbuyer = bobi;
                thread.seller = sam;
                
                threads.add(thread);
        }
        
        public void startThreads()
        {
                // Start the coordinator once
                Thread threadCoordinator = new Thread(c);
                threadCoordinator.start();
                
                // Start all threads: subnegotiator + protocol + seller
                for (NegotiationThread t : threads)
                {
                        System.out.println(t.subbuyer.toDescription());
                        System.out.println("playing vs");
                        System.out.println(t.seller.toDescription());

                        Thread aopThread = new Thread(t.protocol);
                        aopThread.start();

                        Thread threadBuyer = new Thread(t.subbuyer);
                        threadBuyer.start();

                        Thread threadSeller = new Thread(t.seller);
                        threadSeller.start();
                }

        }
        
        private int getThreadNumber()
        {
                return threads.size();
        }

}