build_pheno_graph = function(selected_pheno, pval, df_gene, df_dict) {

  l_df_merge = merge_pheno_pval(selected_pheno, pval, df_gene) %>% merge_per_groups
  df_merge = do.call(rbind, l_df_merge)

  first_order_links = data.frame(from = selected_pheno, to = names(l_df_merge))
  first_order_links$weight = sapply(l_df_merge,
                                    function(df_merge_grp) {
                                        diff(range(df_merge_grp$weight)) / 1.5
                                    })

  second_order_links = df_merge[c('group', 'GENE_NAME', 'weight')] %>%
      setNames(c('from', 'to', 'weight'))

  df_links = rbind(first_order_links, second_order_links)

  df_root = subset(df_dict[c('id', 'desc', 'type_shape', 'type_color')], id == selected_pheno)

  group_idxs = match(first_order_links$to, df_dict$group)
  df_groups = cbind(id = first_order_links$to, desc = first_order_links$to,
                   df_dict[group_idxs, c('type_shape', 'type_color')])
  df_groups$type_color = 'Groups'

  leaf_idxs = match(second_order_links$to, df_dict$id)
  df_leafs = df_dict[leaf_idxs, c('id', 'desc', 'type_shape', 'type_color')]

  df_nodes = rbind(df_root, df_groups, df_leafs) %>%
      setNames(c('word', 'desc', 'type_shape', 'clusters'))

  df_nodes$weight = df_links$weight %>% c(max(.), .)

  list(df_links = df_links, df_nodes = df_nodes)
}

merge_pheno_pval = function(selected_pheno, pval, df_gene) {

  df_pval = subset(pval, PHENOTYPE == selected_pheno)
  df_merge = merge(df_pval, df_gene, by.x = 'GENE_NAME', by.y = 'id')
  df_merge$PVAL %<>% ifelse(. == 0, min(.[. != 0]), .)
  df_merge$weight = -log10(df_merge$PVAL)
  #df_merge %<>% merge(pathways, by.x = 'GENE_NAME', by.y = 'id')
  #df_merge$group = df_merge$pathwayName
  df_merge
}

merge_per_groups = function(df_merge, reset_singles = TRUE) {

  l_df_merge = split(df_merge, df_merge$group)
  if (!reset_singles) return(l_df_merge)

  single_nodes = sapply(l_df_merge, nrow) == 1
  l_df_merge$`Other gene` %<>% rbind(do.call(rbind, l_df_merge[single_nodes]))
  l_df_merge$`Other gene`$group = 'Other gene'
  l_df_merge$`Other gene`$type_color = 'Other gene'

  l_df_merge = l_df_merge[!single_nodes]
}

# when a node is from a one-indiv group for one pheno (-> assigned to other)
# and from a multiple indiv group for another (-> group retained)
# -> if a node has a link to group != other, replace link with other by group
# also replace node attrib
# maybe best to add groups after merge
merge_graphs = function(l_graphs, spring_weights = FALSE, df_dict, df_drugs = NULL) {

  df_links = do.call(rbind, lapply(l_graphs, `[[`, 'df_links'))

  nodes_other = df_links$from == 'Other gene'
  grp_idxs = match(df_links$to[nodes_other], df_dict$id)
  df_links$from[nodes_other] = df_dict$group[grp_idxs]

  single_grps = names(which(table(df_links$from) == 1))
  reset_other = df_links$from[nodes_other] %in% single_grps
  df_links$from[nodes_other][reset_other] = 'Other gene'

  df_nodes = do.call(rbind, lapply(l_graphs, `[[`, 'df_nodes'))

  new_nodes = setdiff(unique(unlist(df_links[1:2])), unique(df_nodes$word))
  if (length(new_nodes)) {
    df_new_nodes = data.frame(word = new_nodes, desc = new_nodes,
                          type_shape = 'Groups', clusters = 'Groups',
                          pval = NA, selected_pheno = names(l_graphs)[1])
    df_new_nodes$weight = subset(df_links, from %in% new_nodes) %>%
      dplyr::group_by(from) %>%
      dplyr::summarize(weight = max(weight)) %$% weight
    df_nodes %<>% rbind(df_new_nodes)
  }

  df_nodes$clusters[match(df_links$to[nodes_other][!reset_other], df_nodes$word)] = df_dict$type_color[match(df_links$to[nodes_other][!reset_other], df_dict$id)]

  df_grp_wts = subset(df_links, from %in% names(l_graphs) & to %in% df_dict$id)
  df_grp_wts = df_grp_wts %>% dplyr::group_by(to) %>% dplyr::summarize(weight = max(weight))
  df_grp_wts$group = df_dict$group[match(df_grp_wts$to, df_dict$id)]
  df_grp_wts = df_grp_wts %>% dplyr::group_by(group) %>% dplyr::summarize(weight = max(weight))


  grp_idxs = match(df_links$from, df_grp_wts$group)
  df_links$weight[!is.na(grp_idxs)] = df_grp_wts$weight[na.omit(grp_idxs)]
  grp_idxs = match(df_nodes$word, df_grp_wts$group)
  df_nodes$weight[!is.na(grp_idxs)] = df_grp_wts$weight[na.omit(grp_idxs)] - (max(df_nodes$weight) / 5)


  df_links %<>% dplyr::group_by(from, to) %>%
      dplyr::summarize(weight = max(weight))


  df_nodes %<>% dplyr::group_by(word) %>%
      dplyr::summarize(weight = max(weight),
                       pval = ifelse(all(is.na(pval)), NA,
                                     paste0(pval, ' (', selected_pheno, ')',
                                            collapse = '\nP-value: ')),
                       desc = desc[1], 
                       type_shape = type_shape[1],
                       clusters = ifelse(length(unique(clusters)) > 1,
                                         subset(clusters, clusters != 'Other gene'),
                                         clusters))

  df_nodes$weight[df_nodes$word %in% names(l_graphs)] = max(df_nodes$weight)

  if (!is.null(df_drugs)) {

    wts = diff(range(df_nodes$weight)) / c(5, 4.5, 3.5, 2.5)
    phase_idx = match(df_nodes$word, df_drugs$drug_name)
    drug_phase = df_drugs$max_phase[na.omit(phase_idx)]

    df_nodes$weight[!is.na(phase_idx)] = wts[drug_phase]

    # in case of reset singles
  nodes_other = df_links$to == 'Other gene'
  df_drugs %<>% subset(id %in% df_links$to)
  grp_idxs = match(df_links$from[nodes_other], df_drugs$drug_name)
  grps = df_drugs$group[grp_idxs]
  grps[!grps %in% df_links$from] = 'Other gene'
  df_links$to[nodes_other] = grps

  df_links %<>% dplyr::group_by(from, to) %>%
      dplyr::summarize(weight = max(weight))

    ## reduce drug pheno edge (not great, messes things up)
     #drug_pheno_edge = df_links$from %in% c(names(l_graphs), df_drugs$drug_name) &
     #   df_links$to %in% c(names(l_graphs), df_drugs$drug_name)
     #df_links$weight[drug_pheno_edge] %<>% `/`(3)
  }

  # TODO need to recompute group weights for fixed nodes/links, although rare edge cases

  if (spring_weights) df_links %<>% sigmagraph:::convert_to_spring_weights()

  df_links$weight %<>% sigmagraph:::scale_graph()
  df_nodes$weight %<>% sigmagraph:::scale_graph()

  stopifnot(nrow(df_nodes) == length(unique(unlist(df_links[1:2]))))

  list(df_links = df_links, df_nodes = df_nodes)
}
