package geniusweb.blingbling;

// old one, not used.
import java.math.BigInteger;
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.nd4j.linalg.api.ndarray.INDArray;
import org.nd4j.linalg.factory.Nd4j;

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

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;

public class MyUtilityModel {
	//model param
	private NeuralRankNet ann;
	private double LearningRate = 0.001;
	private int Epoch = 500;
	private int inputcount = 0;
	private int hiddencount = 30;
	
	//train data
	private List<INDArray> Input1 = new ArrayList<>();
	private List<INDArray> Input2 = new ArrayList<>();
	
	//negotiation param
	private Domain domain;
	private List<Bid> bidlist = new ArrayList<>();
	private Bid reservationbid;
	private Bid maxBid;
	private Bid minBid;
	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 MyUtilityModel(Profile profile) {
		DefaultPartialOrdering prof = (DefaultPartialOrdering) profile;

		this.domain = prof.getDomain();
		this.bidlist = prof.getBids();
		this.reservationbid = prof.getReservationBid();
		
		//get input size.	
		for (String issue: domain.getIssues()) {
			int num = domain.getValues(issue).size().intValue();
			inputcount = inputcount+num;		
		}

		buildRankModel(prof.getDomain(), hiddencount);
		
//		if (true) {
//			throw new RuntimeException("ttt done"+ inputcount);
//		}
		getValueind();
		constructdata(profile);
		train();
	}
	
	public void buildRankModel(Domain domain, int Hiddencount) {
//		Set<String> issueset = domain.getIssues();
		ann = NeuralRankNet.Builder().setLearningRate(LearningRate)
				.addLayer(Layer.Builder().setInCount(inputcount).setOutCount(Hiddencount).setActivationFunction(SigmoidActivationFunction.INSTANCE).build())
				.addLayer(Layer.Builder().setInCount(Hiddencount).setOutCount(Hiddencount).setActivationFunction(SigmoidActivationFunction.INSTANCE).build())
				.addLayer(Layer.Builder().setInCount(Hiddencount).setOutCount(1).setActivationFunction(SigmoidActivationFunction.INSTANCE).build())
				.build();
	}
	
	public void constructdata(Profile profile) {
		DefaultPartialOrdering prof = (DefaultPartialOrdering) profile;
		int ind = 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)) {
					Input1.add(ind, bidtoArray(bid1));
					Input2.add(ind, bidtoArray(bid2));
					ind ++;
				}
				if (prof.isPreferredOrEqual(bid2, bid1)) {
					Input1.add(ind, bidtoArray(bid2));
					Input2.add(ind, bidtoArray(bid1));
					ind ++;
				}
			}
		}
//		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 INDArray bidtoArray(Bid bid) {//input the bid, return a indarray vector.
		
		INDArray features = Nd4j.zeros(1, inputcount);
		for (String issue: domain.getIssues()) {
			Value v = bid.getValue(issue);
			int valuepos = valuePosition.get(issue).get(v);
			features.putScalar(0, valuepos, 1.0);
		}
//		features.putScalar(row, col, value)
		return features;
	}
	
	
	public void train() {
		
		for (int epoch = 0; epoch< Epoch; epoch++) {
			for (int ind= 0; ind < Input1.size(); ind++) {
				ann.train(Input1.get(ind), Input2.get(ind), Nd4j.scalar(1));
			}
		}
	}
	
	public void update(Bid bid, List<Bid> betterBids, List<Bid> worseBids) {
		
	}
	
	public double getUtility(Bid bid) {
		//get the utility from the model.
		List<INDArray> feedForward = ann.feedForward(bidtoArray(bid));
		return feedForward.get(feedForward.size() - 1).getDouble(0);
	}
	
	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(){//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 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 NeuralRankNet getann() {
		return this.ann;
	}
	
}