package network;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
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.LinkedHashMap;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.Set;

import GraphAlgorithm.GraphGenerator;
import GraphAlgorithm.RandGraph;

/**
 * Provides methods for building a disese comorbidity network (DCN) from FAERS \
 * and save it into a file
 * 
 * @author zhengc
 *
 */
public class CommLoader {
	public static HashSet<String> disease_set = new HashSet<String>();
	public static HashMap<String, Integer> disease_index = new HashMap<String, Integer>();
	public static HashMap<Integer, String> index_disease = new HashMap<Integer, String>();
	public static Map<String, String> idnamemap = new HashMap<String, String>();
	public static Map<String, String> nameidmap = new HashMap<String, String>();
	public static HashSet<String> soc_set = new HashSet<String>();
	public static Map<String, String> umlssocmap = new HashMap<String, String>();
	public static Map<String, String> umlssocabbrmap = new HashMap<String, String>();
	public static Map<String, Integer> soc_idx = new HashMap<String, Integer>();
	public static Map<Integer, String> idx_soc = new HashMap<Integer,String>();
	public static final double P = 0.85;
	
	public static HashSet<String> gene_set = new HashSet<String>();
	public static List<String> gene_list = new ArrayList<String>();
	public static HashMap<String, Integer> gene_index = new HashMap<String, Integer>();
	public static HashMap<Integer, String> index_gene = new HashMap<Integer, String>();
	
	
	
	/**
	 * Reads an association rule file to create necessary map file for building DCN
	 * @param filename an association rule file 
	 * @throws IOException
	 */
	public static void readAssocRules(String filename) throws IOException{
		// get all unique disease set
		BufferedReader br = new BufferedReader(new FileReader(new File(filename)));
		String line = br.readLine();
		while ((line = br.readLine()) != null) {
			line = line.replace("[", "");
			line = line.replace("]", "");
//			System.out.println(line);
			String[] symptoms = line.split("\\|")[0].split(",");
//			System.out.println(symptoms.length);
			String[] diseases = line.split("\\|")[2].split(",");
			
			for (int i = 0; i < symptoms.length; i++) {
				symptoms[i] = symptoms[i].trim();
				disease_set.add(symptoms[i]);
			}
			for (int j = 0; j < diseases.length; j++) {
				diseases[j] = diseases[j].trim();
				disease_set.add(diseases[j]);
			}
		}
		br.close();
		
		int m = 0; 
		for (String d: disease_set) {
				disease_index.put(d, m);
				index_disease.put(m, d);
				m++;
		}
	}
	
	public static void readUMLSSOC(String filename) throws IOException{
		BufferedReader br = new BufferedReader(new FileReader(new File(filename)));
		String line = null;
		while ((line=br.readLine()) != null) {
			String[] parts = line.split("\\$");
			String umls = parts[0];
			String soc = parts[8];
			String soc_abbr = parts[9];
			soc_set.add(soc);
			umlssocmap.put(umls, soc);
			umlssocabbrmap.put(umls, soc_abbr);
		}
		br.close();
		
		int m = 0;
		for (String soc : soc_set) {
			soc_idx.put(soc, m);
			idx_soc.put(m, soc);
			m++;
		}
		
	}
	
	
	public static void readPPI(String filename) throws IOException{
		BufferedReader br = new BufferedReader(new FileReader(new File(filename)));
		String line = null;
		while ((line=br.readLine()) != null) {
			String gene = line.split("\\|")[0];
//			System.out.println(2);
			gene_set.add(gene);
		}
		br.close();
		gene_list = util.CollectionsEx.setToList(gene_set);
		
		int m = 0; 
		for (String d: gene_set) {
				gene_index.put(d, m);
				index_gene.put(m, d);
				m++;
		}
		
	}
	
	
	public static DisGraph createPPINet(String ppifile) throws IOException {
		File file = new File(ppifile);
		BufferedReader br = new BufferedReader(new FileReader(file));
		
		int n = gene_index.size();
		DisGraph ppinet = new DisGraph(n);
		
		String line = br.readLine();
		while ((line = br.readLine()) != null) {
			String[] parts = line.split("\\|");
			String dis1 = parts[0];
			int d1 = gene_index.get(dis1);
//			System.out.println(symptoms.length);
			String dis2 = parts[1];
			int d2 = gene_index.get(dis2);
			ppinet.addEdge(d1, d2);
		}
		br.close();
		return ppinet;
	}
	
	
	public static Map<Integer, List<Integer>> readDisGene(String disgenefile, 
			Map<String, List<String>> dcn_omim) throws IOException{
		
		Map<Integer, List<Integer>> dis_gene = new HashMap<>();
		BufferedReader br = new BufferedReader(new FileReader(new File(disgenefile)));
		String line = null;
		
		while ((line = br.readLine()) != null) {
			String [] s = line.split("\\|");
//			System.out.println(s[0]);
			String dis = s[0];
			String gene = s[1];
			if (disease_index.containsKey(dis)) {
				int dis_idx = disease_index.get(dis);
				if (gene_index.containsKey(gene)) {
					int gene_idx = gene_index.get(gene);
					if (!dis_gene.containsKey(dis_idx)) {
						List<Integer> genes = new ArrayList<Integer>();
						genes.add(gene_idx);
						dis_gene.put(dis_idx, genes);
					} else {
						dis_gene.get(dis_idx).add(gene_idx);
					}
				}
			} else {
				for (String id : dcn_omim.keySet()) {
					List<String> omim_ids = dcn_omim.get(id);
					if (omim_ids.contains(dis)) {
						dis = id; // update id
//						System.out.println(dis);
						if (disease_index.containsKey(dis) && gene_index.containsKey(gene)) {
							int dis_idx = disease_index.get(dis);
							int gene_idx = gene_index.get(gene);
							if (!dis_gene.containsKey(dis_idx)) {
								List<Integer> genes = new ArrayList<Integer>();
								genes.add(gene_idx);
								dis_gene.put(dis_idx, genes);
							} else {
								dis_gene.get(dis_idx).add(gene_idx);
							}
						}
					}
				}
			}
			
			// add additional dcn_omim map
			
			
			
//			for (String id : dcn_omim.keySet()) {
//				List<String> omim_ids = dcn_omim.get(id);
//				if (!disease_index.containsKey(dis) && omim_ids.contains(dis)) {
//					dis = id; // update id
//					if (disease_index.containsKey(dis) && gene_index.containsKey(gene)) {
//						int dis_idx = disease_index.get(dis);
//						int gene_idx = gene_index.get(gene);
//						dis_gene.get(dis_idx).add(gene_idx);
//					}
//				}
//			}
		}
		br.close();
		return dis_gene;
	} 
	
	/**
	 * Builds a DCN from an association rule file
	 * @param filename an association rule file
	 * @return an undirected and unweighted DisGraph
	 * @throws IOException
	 */
	public static DisGraph createCommNet(String filename) throws IOException{
		
		File file = new File(filename);
		BufferedReader br = new BufferedReader(new FileReader(file));
		
		int n = disease_index.size();
		DisGraph commnet = new DisGraph(n);
		
		String line = br.readLine();
		while ((line = br.readLine()) != null) {
		
			line = line.replace("[", "");
			line = line.replace("]", "");
		
			//undirected, unweighted network 
		 
			String[] disease1 = line.split("\\|")[0].split(",");
			List<String> diseases_raw = new ArrayList<String>(Arrays.asList(disease1));
			String[] disease2 = line.split("\\|")[2].split(",");
			diseases_raw.addAll(Arrays.asList(disease2));
			
			List<String> diseases = new ArrayList<String>();
			for (String d:diseases_raw) {
				d = d.trim();
				diseases.add(d);
			}
			
			for (int i=0; i<diseases.size() - 1; i++) {
				//System.out.println(diseases.get(i));
				int d1 = disease_index.get(diseases.get(i));
				for (int j=i+1; j<diseases.size(); j++) {
					int d2 = disease_index.get(diseases.get(j));
					//double conf = Double.parseDouble(line.split("\\|")[4]);
					//commnet.addNode(d1, d2, conf);
					commnet.addEdge(d1, d2);
				}
			}
			
		}
		br.close();
		
		return commnet;
	}
	
	
	public static DisGraph createRandNet(String filename) throws IOException {
		DisGraph commnet = createCommNet(filename);
		DisGraph randnet = (new RandGraph(commnet)).getRandGraph();
		return randnet;
	}
	
	
	public static DisGraph createERNet(String filename) throws IOException {
		DisGraph commnet = createCommNet(filename);
		int V = commnet.getNodes();
		double p = (double) V / (V*(V-1)/2);
		System.out.println("Probability: " + p);
		DisGraph randnet = GraphGenerator.simple(V, p);
		return randnet;
	}
	
	public static DisGraph createCommNetFromAdjFile(String netfile, String adjfile) throws IOException {
		DisGraph commnet = createCommNet(netfile);
		
		DisGraph adjnet = new DisGraph(commnet.getNodes());
		
		BufferedReader br = new BufferedReader(new FileReader(new File(adjfile)));
		String line = null;
		int num_line = 0;
		while ((line=br.readLine()) != null) {
			String[] parts = line.split("\\|");
			for (int i=0; i<parts.length; i++) {
				int entry = Integer.parseInt(parts[i]);
				if (entry==1) {
					adjnet.addEdge(num_line, i);
				}
			}
			num_line++;
		}
		br.close();
		return adjnet;
	}
	
	
	public static List<String> getNeibors(String dis, DisGraph dg) {
		
		String dis_id = CommLoader.nameidmap.get(dis);
		int dis_idx = CommLoader.disease_index.get(dis_id);
		
		SparseVector sv = dg.getNeibor(dis_idx);
		List<String> neibors = new ArrayList<>();
		for (int j : sv.getKeys()) {
			String id = CommLoader.index_disease.get(j);
			neibors.add(CommLoader.idnamemap.get(id));
		}
		Collections.sort(neibors);
		return neibors;
	}
	
	public static Map <Integer, Integer> getDegDistri(DisGraph dg) {
		Map <Integer, Integer> dis_neibor = new HashMap<>();
		SparseMatrix commMatrix = dg.getNet();
		for (int i=0; i<commMatrix.size(); i++) {
			dis_neibor.put(i, commMatrix.getNeibor(i).nnz());
		}
		
		return dis_neibor;
	}
	
	public static List<String> compareGraph(DisGraph dg, DisGraph randgraph,  String disname1, String disname2) {
		
		List<String> neibors_original = getNeibors(disname1, dg);
		
		System.out.println("\nComorbidities of " + disname1 + " in original graph:" + neibors_original.size() + "\n");
		for (String d : neibors_original) {
			System.out.println(d);
		}
		
		
		List<String> neibors_random = getNeibors(disname2, randgraph);
		System.out.println("\nComorbidities of " + disname2 + " in random graph:" + neibors_random.size() + "\n" );
		for (String d : neibors_random) {
			System.out.println(d);
		}
		
		List<String> neibors_common = new ArrayList<>();
		if (neibors_original.size() >= neibors_random.size()) {
			for (String j: neibors_original) {
				if (neibors_random.contains(j)) {
					neibors_common.add(j);
				}
			}
		} else {
			for (String j: neibors_random) {
				if (neibors_original.contains(j)) {
					neibors_common.add(j);
				}
			}
		}
		
		Collections.sort(neibors_common);
		System.out.println("\nShared comorbidities of " + disname1 + "and " + disname2 + 
				" between original and random graphs :" + neibors_common.size() + "\n" );
		for (String d : neibors_common) {
			System.out.println(d);
		}
		return neibors_common;
	}
	
	
	/**
	 * Write network to a txt file
	 * @param omimnet a DisGraph
	 * @param filename a file to be written
	 * @throws IOException
	 * dis1_UMLS| dis1_name|dis1_SOC|dis1_SOC_idx|dis2_UMLS|dis2_name|dis2_SOC|dis2_SOC_idx|conf
	 */
	
	public static void writeCommNet(DisGraph commnet, String filename) throws IOException {
		BufferedWriter bw = new BufferedWriter(new FileWriter(new File(filename)));
		bw.write("#dis1_UMLS" + "|" + "dis1_name" + "|"+ "dis1_SOC" + "|" + "dis1_SOC_abbr" + "|" +  "dis1_SOC_idx" + "|" + 
		"dis2_UMLS" + "|" + "dis2_name" + "|"+ "dis2_SOC" + "|" +  "dis2_SOC_abbr" + "|" + "dis2_SOC_idx" + "|" + "conf" + "\n");
		for (int i = 0; i < commnet.getNet().size(); i++) {
			String d1 = index_disease.get(i);
			String d1_name = idNameConverter(d1, idnamemap);
			String d1_soc = umlssocmap.get(d1);
			String d1_soc_abbr = umlssocabbrmap.get(d1);
			int d1_soc_idx = 0;
			if (soc_idx.keySet().contains(d1_soc)) {
				d1_soc_idx = soc_idx.get(d1_soc);
			} else {
				d1_soc_idx = soc_idx.size();
			}
			
			Set<Integer> sv = commnet.getNet().getKey(i);
			for (int k : sv) {
				String d2 = index_disease.get(k);
				String d2_name = idNameConverter(d2, idnamemap);
				String d2_soc = umlssocmap.get(d2);
				String d2_soc_abbr = umlssocabbrmap.get(d2);
				int d2_soc_idx = 0;
				if (soc_idx.keySet().contains(d2_soc)) {
					d2_soc_idx = soc_idx.get(d2_soc);
				} else {
					d2_soc_idx = soc_idx.size();
				}
				
				double conf = commnet.getNet().get(i, k) ;
				bw.write(d1 + "|" + d1_name + "|"+ d1_soc + "|" + d1_soc_abbr + "|" + d1_soc_idx + "|" 
				+ d2 + "|" + d2_name + "|"+ d2_soc + "|" + d2_soc_abbr + "|" + d2_soc_idx + "|" + conf + "\n");
			}
		}
		bw.close();
	}
	

	
	/**
	 * Write disease node (UMLS) to a txt file
	 * @param filename a txt file to be written
	 * @throws IOException
	 */
	private static void writeTerms(String filename) throws IOException {
		BufferedWriter bw = new BufferedWriter(new FileWriter(new File(filename)));
		for (String dis : disease_index.keySet()) {
			bw.write(dis + "\n");
		}
		bw.close();
	}
	
	/**
	 * Write degree for all disease nodes to a file
	 * @param filename a file to be written
	 * @throws IOException
	 */
	public static void writeNodeDeg(DisGraph commnet, String filename) throws IOException {
		BufferedWriter bw = new BufferedWriter(new FileWriter(new File(filename)));
		Map <Integer, Integer> dis_neibor = getDegDistri(commnet);
		
		bw.write("disease" + "|" + "numofdeg" + "index" + "\n");;
		for (int k : dis_neibor.keySet()) {
			String dis = idNameConverter(index_disease.get(k), idnamemap);
			int deg = dis_neibor.get(k);
			bw.write(dis + "|" + deg + "|" + k + "\n");
		}
		bw.close();
	}

	/**
	 * Converts a disease UMLS ID to a disease concept name
	 * @param id a UMLS ID
	 * @param idnamemap a Map from UMLS to name
	 * @return a disease name
	 */
	private static String idNameConverter(String id, Map<String, String> idnamemap) {
		return idnamemap.get(id);
	}

	/**
	 * Creates a map from UMLS to disease concept name
	 * @param mapfile a file containing map information from UMLS to disease concept name
	 * @throws IOException
	 */
	public static void createIdNameMap(String mapfile) throws IOException {
		
		BufferedReader br = new BufferedReader(new FileReader(mapfile));
		String line = null;
		while((line = br.readLine()) != null){
			String[] parts = line.split("\\|");
			idnamemap.put(parts[0], parts[1].toLowerCase());
			nameidmap.put(parts[1].toLowerCase(), parts[0]);
		}
		br.close();
	}
	
			
	/*
	 * main method	
	 */
	
	public static void main(String[] args) throws IOException {
		/* Create disease comorbidity network
		 * Write network to a file
		 */
//		**************** rule file *************************
		
		String rulefile = "./data/ID_indications_all_clean_width_umls_id_diso_filtered_sp_lift_1_0.000002_3_processed.txt";

//		**************** UMLS id to disease name map file file *************************

		String mapfile = "./data/umls_id_name_diso";		
		
//		**************** network file to be saved *************************
		String netfile = "./results/fares_comm_net_conf_final_abbr.txt";
//		String netfile = "/Users/zhengc/workspace/FARES_final/analysis/network/DCN/fares_comm_net_lift_final_abbr.txt";

//		**************** term file to be saved *************************
		String termfile = "./results/fares_comm_net_term_lift_final_public.txt";	

		
		
//		####################################################################
//		------------------ Build and save network to files ----------------
//		####################################################################
		
		readAssocRules(rulefile);
		readUMLSSOC("/Users/zhengc/workspace/FARES_final/analysis/Cluster/umls_soc.txt");

		DisGraph commnet = createCommNet(rulefile);

		//		System.out.println(commnet.getNet());
		System.out.println("Nodes: " + commnet.getNodes());
		System.out.println("Edges: " + commnet.getEdges());
		

		createIdNameMap(mapfile);
 		
		writeCommNet(commnet, netfile);
		writeTerms(termfile);

	}
}