package geniusweb.blingbling;

//old one not used.
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.HashSet;
import java.util.LinkedList;
import java.util.List;
import java.util.Set;
import java.util.logging.Level;

import org.neuroph.core.Layer;
import org.neuroph.core.NeuralNetwork;
import org.neuroph.core.Neuron;
import org.neuroph.core.data.DataSet;
import org.neuroph.core.data.DataSetRow;
import org.neuroph.core.learning.LearningRule;
import org.neuroph.nnet.learning.BackPropagation;
import org.neuroph.util.ConnectionFactory;

import geniusweb.profile.DefaultPartialOrdering;
import geniusweb.profile.Profile;
import geniusweb.profile.utilityspace.UtilitySpace;
import geniusweb.issuevalue.Bid;
import geniusweb.issuevalue.Domain;
import geniusweb.issuevalue.Value;

//ranknet
import geniusweb.blingbling.Ranknet.NeuralRankNet;
import geniusweb.blingbling.Ranknet.*;


import tudelft.utilities.logging.Reporter;


public class MyUtilitySpace {
	//my estimate utility space class.
	private Domain domain;
	private List<Bid> bidlist = new ArrayList<>();
	private List<Bid> sortedbidlist = new LinkedList<>();
	private Bid reservationbid;
	private Bid maxBid;
	private Bid minBid;
	private HashMap<String, HashMap<Value, Integer>> valuefrequency = new HashMap<String, HashMap<Value, Integer>>();//new？or null?
	private NeuralNetwork<LearningRule> ann = new NeuralNetwork<LearningRule>();// the network
	private HashMap<String, Integer> issueToNeuron = new HashMap<String, Integer>(); //track the neuron position of issue
	private HashMap<String, HashMap<Value, Integer>> valueToNeuron = new HashMap<String, HashMap<Value, Integer>>();
    int maxIter = 500; //Integer.parseInt(args[0]);
    double maxError = 0.01; // Double.parseDouble(args[1]);
    double learningRate = 0.0005 ; // Double.parseDouble(args[2]);
    
    DefaultPartialOrdering prof;
    List<List<Integer>> betterlist;
    
	
	public MyUtilitySpace(Profile profile, Reporter reporter) {
		
		DefaultPartialOrdering prof = (DefaultPartialOrdering) profile;

		this.domain = prof.getDomain();
		this.bidlist = prof.getBids();
		this.reservationbid = prof.getReservationBid();
		this.sortedbidlist = setSortedBids(prof);
		this.maxBid = sortedbidlist.get(sortedbidlist.size()-1);
		this.minBid = sortedbidlist.get(0);
		this.betterlist = prof.getBetter();//for learning to rank method.
		

		initValueFrequency();
		setvaluefrequency(prof.getBids());//for elicit compare.
		buildNetwork(prof.getDomain());
		initweight();	
		DataSet ds = setDataset(this.sortedbidlist);
		trainNetwork(ds);
	}
	
	
	public void buildNetwork(Domain domain) {
		//neural network model.
		Set<String> issueset = domain.getIssues();//get all the issues.
		Layer inputlayer = new Layer(); // set the input layer.
		Layer weightlayer = new Layer(); // set the weight layer.
		int weightind = 0; // the ind tracks the issue position in weight layer
		int valueind = 0; // the ind tracks the value position in input layer
		for (String issue: issueset) {//iterate the issues
			weightlayer.addNeuron(weightind, new Neuron()); // add one neuron to the weight layer as  
			issueToNeuron.put(issue, weightind);//put the index to the issue
			weightind ++;//update the weight index
			
			HashMap<Value, Integer> temp = new HashMap<Value, Integer>();
			for (Value value: domain.getValues(issue)) {
				inputlayer.addNeuron(valueind, new Neuron());// add neuron for every value.
				temp.put(value, valueind);
				valueToNeuron.put(issue, temp);
				valueind ++; //update the value index(position)
			}
		}
		ann.addLayer(0, inputlayer);//set layer position
		ann.addLayer(1, weightlayer);
		Layer outputlayer = new Layer();
		outputlayer.addNeuron(0, new Neuron());//add one neuron to the output layer.
		ann.addLayer(2, outputlayer);
		ann.setInputNeurons(inputlayer.getNeurons());
		ann.setOutputNeurons(outputlayer.getNeurons());
	}
	
	public void initweight() {
		//init the NN weight via a specific method. And create connections.
		Set<String> issueset = domain.getIssues();// get all the issues	
		for (String issue: issueset) {
			for (Value value: domain.getValues(issue)) {
				//create connections from value neurons to issue neurons
				if(valuefrequency.get(issue).get(value) == 0) {
					ann.createConnection(ann.getLayerAt(0).getNeuronAt(valueToNeuron.get(issue).get(value)),
							ann.getLayerAt(1).getNeuronAt(issueToNeuron.get(issue)),
							0.0);// if one value never shows in the partial data, then we assign 0 to the weight of this value. 
					continue;				
				}
				ann.createConnection(ann.getLayerAt(0).getNeuronAt(valueToNeuron.get(issue).get(value)),
				ann.getLayerAt(1).getNeuronAt(issueToNeuron.get(issue)),
				0.5);// otherwise we assign 0.5 to the weight. If there is another proper way to init this weight?
			}
			ann.createConnection(ann.getLayerAt(1).getNeuronAt(issueToNeuron.get(issue)),
					ann.getLayerAt(2).getNeuronAt(0),
					1.0/issueset.size());//equal issueweight according to number of issues. Is there a way to control the sum of the weight to be 1.0?
		}
	}
	
	public void initValueFrequency() {
		// create an all-0 hashmap 
		for (String issue: domain.getIssues()) {
			HashMap<Value, Integer> vmap = new HashMap<Value, Integer>();
			for (Value value: domain.getValues(issue)) {
				vmap.put(value, 0);
			}
			this.valuefrequency.put(issue, vmap);
		}
	}
	
	public void setvaluefrequency(List<Bid> inbidlist) {
		//init and update the valuefrequency.
		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(){
		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 DataSet setDataset(List<Bid> inbidlist) {
		//Construct the training dataset. 
	// input sorted bidlist. Utility from low to high. Trained using assigned utility.
		int inputsize = ann.getInputsCount();
		int outputsize = ann.getOutputsCount();
		DataSet ds = new DataSet(inputsize, outputsize);
		int datasize = inbidlist.size();// the size
		double cnt = 0;//
		for (Bid bid: inbidlist) {
			double[] input = new double[inputsize];
			double[] output = new double[outputsize];
			Set<Integer> indset = new HashSet<Integer>();
			for (String issue: domain.getIssues()) {
				Value v = bid.getValue(issue);//get bid's value of issue.
				indset.add(valueToNeuron.get(issue).get(v));// keep a set of the position of the bid values. 
				//ValuetoNeural is a map maps every possible value into the position of input value. 
			}
			
			for (int ind =0; ind<inputsize; ind++) { //construct input vector.
				if (indset.contains(ind)) {
					input[ind] = 1.0; // assign 1.0 to the bid's value position 
				}else {
					input[ind] =0.0;// assign 0 to others
				}
			}
			output[0] = 0.9*(cnt/datasize)+0.1;//the uniform distribution between [0.1, 1], the minimum set to 0.1？
			DataSetRow dsr = new DataSetRow(input, output);// combine the input vector and the output values.
			ds.add(dsr);//add this row to the dataset
			cnt = cnt+1.0; //update the cnt by +1.
		}
		return ds;
	}
	
	public void trainNetwork(DataSet ds) {
		//update the NN via the given compared bids. retrain the 
		// is there space to improve? maybe a better learning rule?
        BackPropagation bp = new BackPropagation();
        bp.setMaxIterations(maxIter);
        //bp.setMaxError(maxError);
        bp.setLearningRate(learningRate);
		ann.setLearningRule(bp);
		ann.learn(ds);
	}
	
	private List<Bid> setSortedBids(Profile profile) {
		//returns a sortedlist here. from low utility to high utility.
		DefaultPartialOrdering prof = (DefaultPartialOrdering) profile;
		List<Bid> bidslist = prof.getBids(); //get all the bid in the partial information.
		// NOTE sort defaults to ascending order.
		Collections.sort(bidslist, new Comparator<Bid>() {

			@Override
			public int compare(Bid b1, Bid b2) {
				return prof.isPreferredOrEqual(b1, b2) ? 1 : -1; //
			}

		});

		return bidslist;
	}
	
	//get and update method
	public void update(Bid bid, List<Bid> worseBids) {//note the frequency also need to be updated
		//relist the bids
		int n = 0;
		while (n < sortedbidlist.size() && worseBids.contains(sortedbidlist.get(n)))
			n++;
		LinkedList<Bid> newbids = new LinkedList<Bid>(sortedbidlist);
		newbids.add(n, bid);
		sortedbidlist = newbids;
		
		DataSet ds = setDataset(sortedbidlist);
		trainNetwork(ds);
		
		bidlist.add(bid);//this is unsorted bid list.
	}
	
	public double getUtility(Bid bid) {
		int inputsize = ann.getInputsCount();
		double[] input = new double[inputsize];
		
		Set<Integer> indset = new HashSet<Integer>();
		for (String issue: domain.getIssues()) {
			Value v = bid.getValue(issue);
			indset.add(valueToNeuron.get(issue).get(v));
		}
		
		for (int ind =0; ind<inputsize; ind++) { //construct input
			if (indset.contains(ind)) {
				input[ind] = 1.0;
			}else {
				input[ind] = 0.0;
			}
		}
		ann.setInput(input);
		ann.calculate();
		return ann.getOutput()[0];//transfer double[] to double.
	}
	
	public Domain getDomain() {
		return this.domain;
	}
	
	public Bid getReservationBid() {
		return this.reservationbid;
	}
	
	public List<Bid> getSortedBids(){
		return this.sortedbidlist;
	}
	
	public Bid getBestBid() {
		return this.maxBid;
	}
	
	public Bid getWorstBid() {
		return this.minBid;
	}
	public NeuralNetwork getann() {
		return this.ann;
	}
	
	// The following is for the learning to rank method. use deeplearning4j. 
	public DataSet setPairwiseDataset() {

		betterlist= prof.getBetter();
		
		return null;
	}
	
	public void trainPairwise(DataSet ds) {
		//using pairwise information
	}

}