package geniusweb.blingbling;

import java.math.BigInteger;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Set;

import geniusweb.bidspace.AllBidsList;
import geniusweb.blingbling.Ranknet.Layer;
import geniusweb.blingbling.Ranknet.NeuralRankNet;
import geniusweb.blingbling.Ranknet.SigmoidActivationFunction;
import geniusweb.issuevalue.Bid;
import geniusweb.issuevalue.Domain;
import geniusweb.issuevalue.Value;
import geniusweb.profile.DefaultPartialOrdering;
import geniusweb.profile.Profile;

import org.neuroph.core.NeuralNetwork;
import org.neuroph.core.data.DataSet;
import org.neuroph.core.data.DataSetRow;
import org.neuroph.core.learning.LearningRule;
import org.neuroph.util.TransferFunctionType;

import geniusweb.blingbling.Ranknet4j.Ranknet;
import geniusweb.blingbling.Ranknet4j.BackPropagation;

public class MyProfile {
	//model param
	private Ranknet ann;
	private DataSet dataset;
	//these params can be set via the Strategy entry 
	private double LearningRate = 0.0025;
	private int Epoch = 3000;
	private int inputcount = 0;
	private int hiddencount = 30;
	
	//negotiation param
	private Domain domain;
	private List<Bid> bidlist = new ArrayList<>();
	private AllBidsList allbid;
	private Bid reservationbid;
	private Bid maxBid;
	private Bid minBid;
	private HashMap<Bid, Double> AllUtilityMap = new HashMap<Bid, Double>();
	private HashMap<String, HashMap<Value, Integer>> valuePosition = new HashMap<String, HashMap<Value, Integer>>();
	
	//for elicit compare
	private HashMap<String, HashMap<Value, Integer>> valuefrequency = new HashMap<String, HashMap<Value, Integer>>();//new？or null?
	
	public MyProfile(Profile profile, int epoch, double learningrate) {
		DefaultPartialOrdering prof = (DefaultPartialOrdering) profile;
		
		this.LearningRate = learningrate;
		this.Epoch  = epoch;
		this.domain = prof.getDomain();
		this.bidlist = prof.getBids();//the partial info bid
		this.reservationbid = prof.getReservationBid();
		this.allbid = new AllBidsList(domain);
		
		//get input size.	
		for (String issue: domain.getIssues()) {
			int num = domain.getValues(issue).size().intValue();
			inputcount = inputcount+num;		
		}
		hiddencount = inputcount*2;
		this.ann = new Ranknet(TransferFunctionType.SIGMOID, inputcount, hiddencount, 1);
		this.dataset = new DataSet(inputcount*2, 1);
		
//		if (true) {
//			throw new RuntimeException("ttt done"+ inputcount);
//		}
		setvaluefrequency(bidlist);
		getValueind();
		constructdata(profile);
		train(dataset, Epoch, LearningRate);
	}
	
	
	public void constructdata(Profile profile) {
		DefaultPartialOrdering prof = (DefaultPartialOrdering) profile;
		double[] output = new double[1];
		output[0] = 1.0;
		for(int i = 0; i < bidlist.size(); i++) {
			for (int j = i+1; j < bidlist.size(); j++) {
				Bid bid1 = bidlist.get(i);
				Bid bid2 = bidlist.get(j);
				
				if(prof.isPreferredOrEqual(bid1, bid2)) {
					double[] data1 = new double[inputcount*2];
					for (int ind=0; ind<inputcount*2; ind++) {
						if (ind<inputcount) {
							data1[ind] = bidtoVector(bid1)[ind];
						}else {
							data1[ind] = bidtoVector(bid2)[ind-inputcount];
						}
					}
					dataset.add(data1, output);
				}
				if (prof.isPreferredOrEqual(bid2, bid1)) {
					double[] data2 = new double[inputcount*2];
					for (int ind=0; ind<inputcount*2; ind++) {
						if (ind<inputcount) {
							data2[ind] = bidtoVector(bid2)[ind];
						}else {
							data2[ind] = bidtoVector(bid1)[ind-inputcount];
						}
					}
					dataset.add(data2, output);
				}
			}
		}
//		return null;
	}
	
	public void getValueind() {//get the input position of a value
		
		int valueind = 0;
		for(String issue: domain.getIssues()) {
			HashMap<Value, Integer> temp = new HashMap<Value, Integer>();
			for (Value value: domain.getValues(issue)) {
				temp.put(value, valueind);
				valuePosition.put(issue, temp);
				valueind ++;
			}
		}
	}
	
	public double[] bidtoVector(Bid bid) {//input the bid, return a double[] vector.
		
		double[] features = new double[inputcount];
		for (int i =0; i<inputcount; i++) {
			features[i]=0.0;
		}
		for (String issue: domain.getIssues()) {
			Value v = bid.getValue(issue);
			int valuepos = valuePosition.get(issue).get(v);
			features[valuepos] = 1.0;
		}
//		features.putScalar(row, col, value)
		return features;
	}
	
	
	public void train(DataSet ds, int epoch, double lr) {
		
		BackPropagation bp = new BackPropagation();
		bp.setMaxIterations(epoch);
		bp.setLearningRate(lr);
		ann.setLearningRule(bp);
		ds.shuffle();
		ann.learn(ds);
		getSorted(allbid);
	}
	
	public void subtrain(int epoch, double lr) {
		train(dataset, epoch, lr);
	}
	
	
	public double getUtility(Bid bid) {
		//get the utility from the model.
		double[] bidvec = bidtoVector(bid);
		ann.setInput(bidvec);
		ann.calculate();
		return ann.getOutput()[0];
	}
	
	public double getRankUtility(Bid bid) {
		return AllUtilityMap.get(bid);
	}
	
 	public void getSorted(AllBidsList allbids) {
		long spacesize = allbids.size().intValue();
		List<Bid> allbidlist = new ArrayList<Bid>();
		for (int n = 0; n< spacesize; n++) {
			Bid bid = allbids.get(BigInteger.valueOf(n));
			allbidlist.add(bid);
		}
		Collections.sort(allbidlist, new Comparator<Bid>() {
			public int compare(Bid b1, Bid b2) {
				return getUtility(b1)>=getUtility(b2) ? -1 : 1; //descending order
			}
		});
		
		for (double n=0.0; n<allbidlist.size(); n++) {
			Bid bid = allbidlist.get((int) n);
			double utility = (double)(allbidlist.size()-n)/allbidlist.size();
			AllUtilityMap.put(bid, utility);
		}
		
	}
	
	public void setvaluefrequency(List<Bid> inbidlist) {//init and update the valuefrequency.
//		Set<Bid> inbidset = new HashSet<Bid>(inbidlist);
		//init valuefrequency map
		if (valuefrequency.isEmpty()) {
			for (String issue: domain.getIssues()) {
				HashMap<Value, Integer> temp = new HashMap<Value, Integer>();
				for(Value value: domain.getValues(issue)) {
					temp.put(value, 0);
				}
				valuefrequency.put(issue, temp);
			}
		}
		
		for (Bid bid: inbidlist) {
			for (String issue: bid.getIssues()) {
				Value v =  bid.getValue(issue);
				HashMap<Value, Integer> temp = valuefrequency.get(issue);
				int cnt = temp.get(v);
				temp.put(v, cnt+1);
				valuefrequency.put(issue, temp);
			}
		}
	}
	
	public HashMap<String, List<Value>> getmostinformative(){//return a map contains the 

		HashMap<String, List<Value>> infovalue = new HashMap<String, List<Value>>();
		for (String issue : domain.getIssues()) {
			List<Value> elicitvalueset = new ArrayList<Value>();
			int minfreq = 0;
			for (Value value: domain.getValues(issue)) {
				int freq = valuefrequency.get(issue).get(value);
				if (elicitvalueset.isEmpty()) {
					elicitvalueset.add(value);
					minfreq = freq;
				}else {
					if (freq<minfreq) {
						elicitvalueset.clear();
						elicitvalueset.add(value);
					}else if(freq == minfreq) {
						elicitvalueset.add(value);
					}
				}
			}
			infovalue.put(issue, elicitvalueset);

		}
		return infovalue;
	}
	
	public List<Bid> getElicitBid() {
		//find the most informative value of every issue.
		HashMap<String, List<Value>> infomap = getmostinformative();
		HashMap<String, Value> bidmap = new HashMap<String, Value>();
		List<Bid> bidresult = new ArrayList<Bid>();
		bidDFS(new ArrayList<String>(infomap.keySet()), bidmap, infomap, bidresult);
		return bidresult;
	}
	
	public void bidDFS(List<String> issues, HashMap<String, Value> bidmap, HashMap<String, List<Value>> infomap, List<Bid> bidresultlist) {
		if (bidmap.keySet().size() == issues.size()) {
			bidresultlist.add(new Bid(bidmap));
			return;
		}
		
		for (Value value: infomap.get(issues.get(bidmap.size()))) {
			bidmap.put(issues.get(bidmap.size()), value);
			bidDFS(issues, bidmap, infomap, bidresultlist);
			bidmap.remove(issues.get(bidmap.size()-1));
		}
	}
	
	public void update(Bid bid, List<Bid> betterBids, List<Bid> worseBids) {
		updateDataset(bid, betterBids, worseBids);
		updateBidAndValueFrequency(bid);
		train(dataset, Epoch, LearningRate);
	}
	
	public void updateDataset(Bid bid, List<Bid> betterBids, List<Bid> worseBids) {
		double[] output = new double[1];
		output[0] = 1.0;
		for (int i=0; i< betterBids.size(); i++) {
			Bid betterbid = betterBids.get(i);
			double[] data = new double[inputcount*2];
			for (int ind=0; ind<inputcount*2; ind++) {
				if (ind< inputcount) {
					data[ind] = bidtoVector(betterbid)[ind];
				}else {
					data[ind] = bidtoVector(bid)[ind-inputcount];
				}
			}
			dataset.add(data, output);
		}
		for (int i=0; i< worseBids.size(); i++) {
			Bid worsebid = worseBids.get(i);
			double[] data = new double[inputcount*2];
			for (int ind=0; ind<inputcount*2; ind++) {
				if (ind< inputcount) {
					data[ind] = bidtoVector(bid)[ind];
				}else {
					data[ind] = bidtoVector(worsebid)[ind-inputcount];
				}
			}
			dataset.add(data, output);
		}

	}
	
	public void updateBidAndValueFrequency(Bid bid) {
		bidlist.add(bid);
		setvaluefrequency(new ArrayList<Bid>(Arrays.asList(bid)));//add upon the original.		
	}
	
	public Domain getDomain() {
		return this.domain;
	}
	
	public Bid getBestBid() {
		return this.maxBid;
	}
	
	public Bid getWorstBid() {
		return this.minBid;
	}
	
	public Bid getReservationBid() {
		return this.reservationbid;
	}
	public List<Bid> getBidlist(){
		return this.bidlist;
	}
	public List<Bid> getAllBidlist(){
		long spacesize = allbid.size().intValue();
		List<Bid> allbidlist = new ArrayList<Bid>();
		for (int n = 0; n< spacesize; n++) {
			Bid bid = allbid.get(BigInteger.valueOf(n));
			allbidlist.add(bid);
		}
		return allbidlist;
	}
	public Ranknet getann() {
		return this.ann;
	}
	
}