package bargainingchips.utilityfunctions;

import java.util.Random;
import bargainingchips.Bundle;
import bargainingchips.ChipIssueValue;
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;
import bargainingchips.wishlist.WishList;

/**
 * 
 * This class works to pick a random utility function and pass the buyer's preferences to. 
 * 
 * Besides the buyer operator, it is useful for the experiments in which it is required 
 * to create several random agents to negotiate on behalf of the buyer. 
 * 
 * The utility functions are UF_CloseToQuantity, UF_LessPrice, UF_LessPriceCloseToQuantity, 
 * UF_IntensifiedLessPriceCloseToQuantity, UF_PeakedPricePeakedQuantity, UF_PeakedFlatPricePeakedFlatQuantity, 
 * UF_PeakedFlatCurvePriceGaussianQuantity, UF_BezierPriceBezierQuantity, and UF_BezierPriceGaussianQuantity.
 * 
 * They receive different number and types of parameters. 
 * 
 * 
 * @author Faria Nassiri-Mofakham
 *
 */
public class UF implements UtilityFunction 
{
	WishList 					wishlist;			// example: {Yellow=6, Orange=40, Green=4}
	ChipIssueValue<Double> 		breakEvenPrices;	// example: {Yellow=5.0, Orange=1.0, Green=3.0}
	ChipIssueValue<Double[]> 	prices1;			// example: 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;			// example: ChipIssueValueBuilder<Double>().addIssue("Green", 1.0).addIssue("Yellow", 0.8).addIssue("Orange", 0.75).build();
	ChipIssueValue<Integer> 	deviations1;		// example: {Yellow=1, Orange=10, Green=1}
	ChipIssueValue<Double[]> 	prices2;			// example: { Yellow={5.0, 5.2, 6.2, 8.0} Orange={1.0, 1.8, 2.5, 3.0} Green={3.0, 3.5, 4.8, 5.0} }
	ChipIssueValue<Double[]> 	uPrices2;			// example: { Yellow={0.8, 0.1} Orange={0.9, 0.3} Green={0.7, 0.2} }
	ChipIssueValue<Double[]> 	deviations2;		// example: { Yellow={50.0, 30.0, 30.0, 50.0} Orange={200.0, 40.0, 60.0, 1000.0} Green={100.0, 20.0, 50.0, 500.0} }
	ChipIssueValue<Double[]> 	uDev2;				// example: { Yellow={0.3, 0.7, 0.7, 0.3} Orange={0.15, 0.95, 0.85, 0.3} Green={0.25, 0.8, 0.9, 0.1} }
	ChipIssueValue<Integer[]> 	deviations3;		// example: { Yellow={3, 2, 2, 3} Orange={10, 2, 5, 10} Green={2, 1, 2, 3} }
	ChipIssueValue<Double> 		wC;					// example: {Yellow=0.3, Orange=0.2, Green=0.5}
	double 						wP;					// example: 0.6;
	double						wQ;					// example: 0.4;
	boolean 					pVq;				// example: true; true, if less price is more important; false, if close to quantity is important. 
	int 						m;					// example: 4; input Bezier points

	UtilityFunction u = null;

	public UF (
			WishList wish,
			ChipIssueValue<Double> breakEvenP,
			ChipIssueValue<Double[]> pr1,
			ChipIssueValue<Double> uPr1,
			ChipIssueValue<Integer> dev1,
			ChipIssueValue<Double[]> pr2,
			ChipIssueValue<Double[]> uPr2,
			ChipIssueValue<Double[]> dev2,
			ChipIssueValue<Double[]> uDv2,
			ChipIssueValue<Integer[]> dev3,
			ChipIssueValue<Double> c,
			double p,
			double q,
			boolean pq,
			int n
			)
	{
		wishlist			= wish;
		breakEvenPrices		= breakEvenP;
		prices1				= pr1;
		uPrices1			= uPr1;
		deviations1			= dev1;
		prices2 			= pr2;
		uPrices2			= uPr2;
		deviations2			= dev2;
		uDev2				= uDv2;
		deviations3			= dev3;
		wC					= c;
		wP					= p;
		wQ					= q;
		pVq					= pq;
		m					= n;
	}

	@Override
	public Double getUtility(Bundle b) 
	{
		//	boolean priceVSQuantity = ((new Random().nextInt(2)+1 == 1) ? true : false);
		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, pVq); 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;
		}
		return u.getUtility(b);
	}

	@Override
	public String toString()
	{
		return u.toString();
	}

//	public static void main(String[] args) 
//	{
//		System.out.println(u.getClass().getName());
//	}
	
}