# ========4.plot========

#' Plot a metanet

#'

#' @param x metanet object

#' @param ... add

#'

#' @return plot

#' @exportS3Method

#' @method plot metanet

plot.metanet <- function(x, ...) {

  # 具有n_type的metanet的默认参数记录在这里，用于快速绘图。

  go <- x

  if (is.null(get_n(go)$n_type)) {

    c_net_plot(go, ...)

  } else if (get_n(go)$n_type == "skeleton") {

    skeleton_plot(go, ...)

  } else if (get_n(go)$n_type == "module") {

    default_arg <- list(

      labels_num = 0,

      group_legend_title = "Module"

    )

    do.call(c_net_plot, append(list(go = go), pcutils::update_param(default_arg, list(...))))

  } else if (get_n(go)$n_type == "venn") {

    nice_size <- ceiling(60 / sqrt(length(V(go)))) + 1

    default_arg <- list(

      labels_num = "all",

      vertex_size_range = list("Group" = c(1.5 * nice_size, 1.5 * nice_size), "elements" = c(0.5 * nice_size, 0.5 * nice_size)),

      vertex.shape = "circle",

      legend = FALSE, edge.curved = 0.3,

      edge.color = unique(V(go)$color)

    )

    do.call(c_net_plot, append(list(go = go), pcutils::update_param(default_arg, list(...))))

  } else if (get_n(go)$n_type == "twocol") {

    nice_size <- ceiling(60 / sqrt(length(V(go)))) + 1

    default_arg <- list(

      labels_num = 0,

      vertex.shape = "circle",

      edge_legend = FALSE,

      edge.color = "black"

    )

    do.call(c_net_plot, append(list(go = go), pcutils::update_param(default_arg, list(...))))

  } else if (get_n(go)$n_type == "ko_net") {

    nice_size <- ceiling(60 / sqrt(length(V(go)))) + 1

    default_arg <- list(

      labels_num = "all",

      vertex.shape = "circle",

      vertex_size_range = list("Pathway" = c(1.2 * nice_size, 1.2 * nice_size), "KOs" = c(0.6 * nice_size, 0.6 * nice_size)),

      edge_legend = FALSE,

      edge.color = "black",

      mark_alpha = 0.1

    )

    do.call(c_net_plot, append(list(go = go), pcutils::update_param(default_arg, list(...))))

  } else {

    c_net_plot(go, ...)

  }

}

get_net_main <- function(n_index) {

  main <- "Network"

  if (!is.null(n_index$n_type)) {

    switch(n_index$n_type,

      "single" = {

        main <- "Correlation network"

      },

      "bipartite" = {

        main <- "Bipartite network"

      },

      "multi_full" = {

        main <- "Multi-omics network"

      },

      "module" = {

        main <- paste0(n_index$n_modules, "-modules network")

      },

      "skeleton" = {

        main <- paste0(n_index$skeleton, " skeleton network")

      },

      "venn" = {

        main <- "Venn network"

      },

      default = {

        main <- "Network"

      }

    )

  }

  return(main)

}

scale_size_width <- function(tmp_v, tmp_e, vertex_size_range, edge_width_range) {

  {        v_groups <- unique(tmp_v$v_group)

    nice_size <- ceiling(100 / sqrt(nrow(tmp_v))) + 1

    vertex_size_range_default <- rep(list(c(max(nice_size * 0.4, 3), min(nice_size * 1.6, 12))), length(v_groups))

    names(vertex_size_range_default) <- v_groups

    if (!is.null(vertex_size_range)) {

      if (!is.list(vertex_size_range)) vertex_size_range <- list(vertex_size_range)

      if (is.null(names(vertex_size_range))) {

        vertex_size_range <- rep(vertex_size_range, length(v_groups))

        names(vertex_size_range) <- v_groups

      }

      vertex_size_range <- pcutils::update_param(vertex_size_range_default, vertex_size_range)

    } else {

      vertex_size_range <- vertex_size_range_default

    }

    node_size_text <- setNames(as.list(numeric(length(v_groups))), v_groups)

    for (i in v_groups) {

      node_size_text[[i]] <- c(

        min(tmp_v[tmp_v$v_group == i, "size"], na.rm = TRUE),

        max(tmp_v[tmp_v$v_group == i, "size"], na.rm = TRUE)

      )

      tmp_v[tmp_v$v_group == i, "size"] <- do.call(pcutils::mmscale, append(

        list(tmp_v[tmp_v$v_group == i, "size"]),

        as.list(sort(vertex_size_range[[i]][1:2]))

      ))

    }    }

  {

    edge_width_range_default <- vertex_size_range_default[[1]] / 6

    if (is.null(edge_width_range)) edge_width_range <- edge_width_range_default

    edge_width_range <- sort(edge_width_range)

    edge_width_text <- c(min(tmp_e$width, na.rm = TRUE), max(tmp_e$width, na.rm = TRUE))

    tmp_e$width <- pcutils::mmscale(tmp_e$width, edge_width_range[1], edge_width_range[2])

  }

  envir <- parent.frame()

  assign("node_size_text", node_size_text, envir)

  assign("edge_width_text", edge_width_text, envir)

  assign("tmp_e", tmp_e, envir)

  assign("tmp_v", tmp_v, envir)

}

some_custom_paras <- function(tmp_v, tmp_e, ...) {

  params <- list(...)

  params_name <- names(params)

  # 下列都是mapping好的颜色，形状等，无法单独修改某一个vertex或edge的颜色，形状等

  # ！！！考虑增加额外参数，用于单独修改某一个vertex或edge的颜色，形状等

  if (!"label.color" %in% colnames(tmp_v)) tmp_v$label.color <- "black"

  if ("vertex.size" %in% params_name) tmp_v$size <- params[["vertex.size"]]

  if ("vertex.color" %in% params_name) {

    tmp_v$color <- condance(data.frame(

      tmp_v$color,

      pcutils::tidai(tmp_v$v_class, params[["vertex.color"]], fac = TRUE)

    ))

  }

  if ("vertex.shape" %in% params_name) {

    tmp_v$shape <- condance(data.frame(

      tmp_v$shape,

      pcutils::tidai(tmp_v$v_group, params[["vertex.shape"]])

    ))

  }

  if ("vertex.label" %in% params_name) tmp_v$label <- params[["vertex.label"]]

  if ("vertex.label.color" %in% params_name) {

    tmp_v$label.color <- condance(data.frame(

      "black",

      pcutils::tidai(tmp_v$v_group, params[["vertex.label.color"]], fac = TRUE)

    ))

  }

  if ("edge.color" %in% params_name) {

    tmp_e$color <- condance(data.frame(

      tmp_e$color,

      pcutils::tidai(tmp_e$e_type, params[["edge.color"]], fac = TRUE)

    ))

  }

  if ("edge.lty" %in% params_name) {

    tmp_e$lty <- condance(data.frame(

      tmp_e$lty,

      pcutils::tidai(tmp_e$e_class, params[["edge.lty"]], fac = TRUE)

    ))

  }

  if ("edge.width" %in% params_name) tmp_e$width <- params[["edge.width"]]

  envir <- parent.frame()

  assign("tmp_e", tmp_e, envir)

  assign("tmp_v", tmp_v, envir)

}

pie_set_for_plot <- function(tmp_v, pie_value, pie_color) {

  if ("pie" %in% tmp_v$shape) {

    if (!is.null(pie_value)) {

      if (!is.data.frame(pie_value)) stop("pie_value must be a data.frame.")

      if (!"name" %in% colnames(pie_value)) {

        pie_value$name <- rownames(pie_value)

      }

      if (any(duplicated(pie_value$name))) {

        stop(

          "Duplicated name in annotation tables: ",

          paste0(pie_value$name[duplicated(pie_value$name)], collapse = ", ")

        )

      }

      tmp_merge_df <- left_join(tmp_v["name"], pie_value, by = "name")

      pie_value <- tmp_merge_df[, -1]

      pie_parts <- colnames(pie_value)

      pie_value[is.na(pie_value)] <- 0

      pie_value$`__others` <- ifelse(rowSums(pie_value) > 0, 0, 1)

      pie_value_list <- as.list(pcutils::t2(pie_value))

      default_pie_color <- setNames(pcutils::get_cols(length(pie_parts), "col1"), pie_parts)

      if (is.null(pie_color)) pie_color <- default_pie_color

      if (is.null(names(pie_color))) {

        pie_color <- setNames(pie_color, pie_parts)

      } else {

        pie_color <- pcutils::update_param(default_pie_color, pie_color)

      }

      pie_color <- pie_color[pie_parts]

      pie_color <- c(pie_color, `__others` = NA)

    } else {

      pie_value_list <- pie_color <- NULL

    }

  } else {

    pie_value_list <- pie_color <- NULL

  }

  envir <- parent.frame()

  assign("pie_value_list", pie_value_list, envir)

  assign("pie_color", pie_color, envir)

}

get_show_labels <- function(tmp_v, labels_num) {

  name <- size <- NULL

  if (is.null(labels_num)) {

    if (nrow(tmp_v) < 20) {

      labels_num <- "all"

    } else {

      labels_num <- 0

    }

  }

  {

    if (labels_num == "all") {

      tmp_v %>% dplyr::pull(name) -> toplabel

    } else {

      if (labels_num >= 1) {

        tmp_v %>%

          dplyr::top_n(labels_num, size) %>%

          dplyr::arrange(-size) %>%

          dplyr::pull(name) %>%

          head(labels_num) -> toplabel

      } else {

        tmp_v %>%

          dplyr::top_frac(labels_num, size) %>%

          dplyr::arrange(-size) %>%

          dplyr::pull(name) %>%

          head(ceiling(labels_num * nrow(tmp_v))) -> toplabel

      }

    }

    tmp_v$label <- ifelse(tmp_v$name %in% toplabel, tmp_v$label, NA)

  }

  return(tmp_v)

}

module_set_for_plot <- function(tmp_v, mark_module, mark_color) {

  if (mark_module) {

    new_modu <- as_module(setNames(tmp_v$module, tmp_v$name))

    new_modu[["others"]] <- NULL

    module_color <- pcutils::get_cols(length(new_modu))

    if (!is.null(mark_color)) module_color <- condance(data.frame(module_color, pcutils::tidai(names(new_modu), mark_color)))

    module_color <- setNames(module_color, names(new_modu))

    module_color <- module_color[names(module_color) != "others"]

  } else {

    new_modu <- module_color <- NULL

  }

  envir <- parent.frame()

  assign("new_modu", new_modu, envir)

  assign("module_color", module_color, envir)

}

get_module_coors <- function(go = NULL, coors = NULL, tmp_v = NULL, ori_coors = NULL, module_label_just = c(0.5, 0.5), rescale_flag = TRUE) {

  X <- Y <- module <- minx <- maxx <- miny <- maxy <- NULL

  if (is.null(go)) {

    if (is.null(tmp_v) && is.null(ori_coors)) message("input `tmp_v` and `ori_coors` when `go` is null.")

  } else {

    tmp_v <- get_v(go)

    ori_coors <- get_coors(coors, go)

  }

  module_coors <- dplyr::left_join(tmp_v[, c("name", "module")], ori_coors, by = "name")

  if (rescale_flag) module_coors <- dplyr::mutate(module_coors, X = mmscale(X, -1, 1), Y = mmscale(Y, -1, 1))

  module_coors <- dplyr::group_by(module_coors, module) %>%

    dplyr::summarise(minx = min(X), maxx = max(X), miny = min(Y), maxy = max(Y))

  module_label_just <- rep(module_label_just, 2)

  module_coors <- mutate(module_coors,

    X = minx + module_label_just[1] * (maxx - minx),

    Y = miny + module_label_just[2] * (maxy - miny)

  )

  return(module_coors)

}

produce_c_net_legends <- function(tmp_v, tmp_e, vertex_frame_width,

                                  legend_position, legend_number, legend_cex,

                                  node_size_text, edge_width_text,

                                  group_legend_title, group_legend_order,

                                  color_legend, color_legend_order,

                                  size_legend, size_legend_title,

                                  edge_legend, edge_legend_title, edge_legend_order,

                                  width_legend, width_legend_title,

                                  lty_legend, lty_legend_title, lty_legend_order,

                                  module_legend, module_legend_title, module_legend_order, module_color, mark_alpha,

                                  pie_legend, pie_legend_title, pie_legend_order, pie_color,

                                  ...) {

  color <- e_type <- lty <- e_class <- v_class <- shape <- left_leg_x <- right_leg_x <- NULL

  legend_position_default <- c(left_leg_x = -2, left_leg_y = 1, right_leg_x = 1.2, right_leg_y = 1)

  if (is.null(legend_position)) legend_position <- legend_position_default

  if (is.null(names(legend_position))) {

    legend_position <- setNames(legend_position, names(legend_position_default)[seq_along(legend_position)])

  }

  legend_position <- pcutils::update_param(legend_position_default, legend_position)

  here_env <- environment()

  lapply(names(legend_position), \(i){

    assign(i, legend_position[i], here_env)

  })

  vgroups <- pcutils::change_fac_lev(tmp_v$v_group, group_legend_order)

  vgroups <- levels(vgroups)

  if (color_legend) {

    # ！！！考虑添加更多的形状，至少是21:25，形状为pie时添加额外legend

    if (is.null(group_legend_title)) {

      group_legend_title <- setNames(vgroups, vgroups)

    } else if (is.null(names(group_legend_title))) {

      group_legend_title <- setNames(rep(group_legend_title, len = length(vgroups)), vgroups)

    }

    this_shape <- unique(tmp_v$shape)

    if (!all(this_shape %in% names(default_v_shape))) {

      default_v_shape <- pcutils::update_param(

        default_v_shape,

        setNames(rep(21, length(this_shape)), this_shape)

      )

    }

    for (g_i in vgroups) {

      if ("count" %in% names(tmp_v)) {

        tmp_v1 <- tmp_v[tmp_v$v_group == g_i, c("v_class", "color", "shape", "count")]

      } else {

        tmp_v1 <- tmp_v[tmp_v$v_group == g_i, c("v_class", "color", "shape")]

      }

      tmp_v1$v_class <- factor(tmp_v1$v_class, levels = custom_sort(unique(tmp_v1$v_class)))

      vclass <- pcutils::change_fac_lev(tmp_v1$v_class, color_legend_order)

      vclass <- levels(vclass)

      node_cols <- dplyr::distinct(tmp_v1, color, v_class)

      node_cols <- setNames(node_cols$color, node_cols$v_class)

      node_shapes <- dplyr::distinct(tmp_v1, shape, v_class)

      node_shapes <- setNames(node_shapes$shape, node_shapes$v_class)

      if (legend_number) {

        eee <- table(tmp_v1$v_class)

        if (!is.null(attributes(tmp_v)$skeleton)) {

          eee <- setNames(tmp_v1$count, tmp_v1$v_class)

          legend_number <- FALSE

        }

        le_text <- paste(vclass, eee[vclass], sep = ": ")

      } else {

        le_text <- vclass

      }

      if (length(le_text) == 0) le_text <- ""

      legend(left_leg_x, left_leg_y,

        cex = 0.7 * legend_cex, adj = 0, pt.lwd = vertex_frame_width,

        legend = le_text, title.cex = 0.8 * legend_cex,

        title = group_legend_title[g_i], title.font = 2, title.adj = 0,

        col = "black", pt.bg = node_cols[vclass], bty = "n", pch = default_v_shape[node_shapes[vclass]]

      )

      left_leg_y <- left_leg_y - (length(vclass) * 0.12 + 0.2) * legend_cex

    }

  }

  if (module_legend) {

    tmp_v$module <- factor(tmp_v$module, levels = custom_sort(unique(tmp_v$module)))

    modules <- pcutils::change_fac_lev(tmp_v$module, module_legend_order)

    modules <- levels(modules)

    if (legend_number) {

      eee <- table(tmp_v$module)

      le_text <- paste(modules, eee[modules], sep = ": ")

    } else {

      le_text <- modules

    }

    legend(left_leg_x, left_leg_y,

      cex = 0.7 * legend_cex, adj = 0,

      legend = le_text, title.cex = 0.8 * legend_cex,

      title = module_legend_title, title.font = 2, title.adj = 0,

      fill = pcutils::add_alpha(module_color[modules], mark_alpha),

      border = module_color[modules], bty = "n"

    )

    left_leg_y <- left_leg_y - (length(modules) * 0.12 + 0.2) * legend_cex

  }

  if (pie_legend) {

    pie_color <- pie_color[names(pie_color) != "__others"]

    pies <- pcutils::change_fac_lev(names(pie_color), pie_legend_order)

    pies <- levels(pies)

    le_text <- pies

    legend(left_leg_x, left_leg_y,

      cex = 0.7 * legend_cex, adj = 0,

      legend = le_text, title.cex = 0.8 * legend_cex,

      title = pie_legend_title, title.font = 2, title.adj = 0,

      fill = pie_color[pies],

      border = "black", bty = "n"

    )

    left_leg_y <- left_leg_y - (length(pies) * 0.12 + 0.2) * legend_cex

  }

  if (size_legend) {

    legend(

      x = right_leg_x, y = right_leg_y,

      cex = 0.7 * legend_cex, title.font = 2, title = size_legend_title, title.adj = 0,

      legend = c(

        paste(lapply(node_size_text[vgroups], \(i)round(i[1], 3)), collapse = "/ "),

        paste(lapply(node_size_text[vgroups], \(i)round(i[2], 3)), collapse = "/ ")

      ),

      adj = 0, title.cex = 0.8 * legend_cex,

      col = "black", bty = "n", pch = 21, pt.cex = c(min(tmp_v$size), max(tmp_v$size)) * legend_cex / 5

    )

    right_leg_y <- right_leg_y - 0.5 * legend_cex

  }

  if (edge_legend) {

    tmp_e$e_type <- factor(tmp_e$e_type, levels = custom_sort(unique(tmp_e$e_type)))

    edges <- pcutils::change_fac_lev(tmp_e$e_type, edge_legend_order)

    edges <- levels(edges)

    edge_cols <- dplyr::distinct(tmp_e, color, e_type)

    edge_cols <- setNames(edge_cols$color, edge_cols$e_type)

    if (legend_number) {

      eee <- table(tmp_e$e_type)

      le_text <- paste(edges, eee[edges], sep = ": ")

    } else {

      le_text <- edges

    }

    legend(right_leg_x, right_leg_y,

      cex = 0.7 * legend_cex, title.font = 2, title = edge_legend_title, title.adj = 0,

      legend = le_text, adj = 0, title.cex = 0.8 * legend_cex,

      col = edge_cols[edges], bty = "n", lty = 1

    )

    right_leg_y <- right_leg_y - (length(unique(tmp_e$color)) * 0.12 + 0.2) * legend_cex

  }

  if (width_legend) {

    legend(right_leg_x, right_leg_y,

      cex = 0.7 * legend_cex, title.font = 2, title = width_legend_title, title.adj = 0,

      legend = edge_width_text %>% round(., 3), adj = 0, title.cex = 0.8 * legend_cex,

      col = "black", bty = "n", lty = 1, lwd = c(min(tmp_e$width), max(tmp_e$width))

    )

    right_leg_y <- right_leg_y - 0.5 * legend_cex

  }

  if (lty_legend) {

    edges <- pcutils::change_fac_lev(tmp_e$e_class, lty_legend_order)

    edges <- levels(edges)

    edge_ltys <- dplyr::distinct(tmp_e, lty, e_class)

    edge_ltys <- setNames(edge_ltys$lty, edge_ltys$e_class)

    if (legend_number) {

      eee <- table(tmp_e$e_class)

      le_text <- paste(edges, eee[edges], sep = ": ")

    } else {

      le_text <- edges

    }

    legend(right_leg_x, right_leg_y,

      cex = 0.7 * legend_cex, title.font = 2, title = lty_legend_title, title.adj = 0,

      legend = le_text, adj = 0, title.cex = 0.8 * legend_cex,

      col = "black", bty = "n", lty = edge_ltys[edges]

    )

  }

}

#' Plot a metanet

#'

#' @param go an igraph or metanet object

#' @param coors the coordinates you saved

#' @param ... additional parameters for \code{\link[igraph]{igraph.plotting}}

#' @param labels_num show how many labels, >1 indicates number, <1 indicates fraction, "all" indicates all.

#' @param vertex_size_range the vertex size range, e.g. c(1,10)

#' @param edge_width_range the edge width range, e.g. c(1,10)

#'

#' @param plot_module logical, plot module?

#' @param mark_module logical, mark the modules?

#' @param mark_color mark color

#' @param mark_alpha mark fill alpha, default 0.3

#' @param module_label show module label?

#' @param module_label_cex module label cex

#' @param module_label_color module label color

#' @param module_label_just module label just, default c(0.5,0.5)

#'

#' @param pie_value a dataframe using to plot pie (with rowname or a "name" column)

#' @param pie_color color vector

#'

#' @param legend all legends

#' @param legend_number legend with numbers

#' @param legend_cex character expansion factor relative to current par("cex"), default: 1

#' @param legend_position legend_position, default: c(left_leg_x=-1.9,left_leg_y=1,right_leg_x=1.2,right_leg_y=1)

#'

#' @param group_legend_title group_legend_title, length must same to the numbers of v_group

#' @param group_legend_order group_legend_order vector

#' @param color_legend logical

#' @param color_legend_order color_legend_order vector

#' @param size_legend logical

#' @param size_legend_title size_legend_title

#'

#' @param edge_legend logical

#' @param edge_legend_title edge_legend_title

#' @param edge_legend_order edge_legend_order vector, e.g. c("positive","negative")

#' @param width_legend logical

#' @param width_legend_title width_legend_title

#'

#' @param lty_legend logical

#' @param lty_legend_title lty_legend_title

#' @param lty_legend_order lty_legend_order

#'

#' @param module_legend logical

#' @param module_legend_title module_legend_title

#' @param module_legend_order module_legend_order

#'

#' @param pie_legend logical

#' @param pie_legend_title pie_legend_title

#' @param pie_legend_order pie_legend_order

#'

#' @param seed random seed, default:1234, make sure each plot is the same.

#' @param params_list a list of parameters, e.g. list(edge_legend = TRUE, lty_legend = FALSE), when the parameter is duplicated, the format argument will be used rather than the argument in params_list.

#' @param rescale Logical constant, whether to rescale the coordinates to the (-1,1).

#'

#' @family plot

#' @return a network plot

#' @export

#'

#' @examples

#' data("c_net")

#' c_net_plot(co_net)

#' c_net_plot(co_net2)

#' c_net_plot(multi1)

c_net_plot <- function(go, coors = NULL, ..., labels_num = NULL,

                       vertex_size_range = NULL, edge_width_range = NULL,

                       plot_module = FALSE,

                       mark_module = FALSE, mark_color = NULL, mark_alpha = 0.3,

                       module_label = FALSE, module_label_cex = 2, module_label_color = "black",

                       module_label_just = c(0.5, 0.5),

                       pie_value = NULL, pie_color = NULL,

                       legend = TRUE, legend_number = FALSE, legend_cex = 1,

                       legend_position = c(left_leg_x = -2, left_leg_y = 1, right_leg_x = 1.2, right_leg_y = 1),

                       group_legend_title = NULL, group_legend_order = NULL,

                       color_legend = TRUE, color_legend_order = NULL,

                       size_legend = FALSE, size_legend_title = "Node Size",

                       edge_legend = TRUE, edge_legend_title = "Edge type", edge_legend_order = NULL,

                       width_legend = FALSE, width_legend_title = "Edge width",

                       lty_legend = FALSE, lty_legend_title = "Edge class", lty_legend_order = NULL,

                       module_legend = FALSE, module_legend_title = "Module", module_legend_order = NULL,

                       pie_legend = FALSE, pie_legend_title = "Pie part", pie_legend_order = NULL,

                       params_list = NULL, rescale = FALSE,

                       seed = 1234) {

  if (!is.null(params_list)) {

    as.list(match.call()[-1]) -> set_params_list

    set_params_list[["params_list"]] <- NULL

    for (i in seq_along(params_list)) {

      if (names(params_list)[i] %in% names(set_params_list)) {

        message("The parameter `", names(params_list)[i], "` is duplicated, the format argument will be used.")

      }

    }

    pcutils::update_param(params_list, set_params_list) -> set_params_list

    do.call(c_net_plot, set_params_list)

    return(invisible())

  }

  if (length(V(go)) == 0) {

    message("The network is empty.")

    return(invisible())

  }

  new_modu <- module_color <- node_size_text <- edge_width_text <- NULL

  set.seed(seed)

  if (!is_metanet(go)) go <- c_net_update(go)

  # go <- c_net_update(go)

  # modules

  if (plot_module) {

    go <- to_module_net(go)

    if (is.null(group_legend_title)) group_legend_title <- "Module"

  }

  # get network type

  get_net_main(get_n(go)) -> main

  get_v(go) -> tmp_v

  get_e(go) -> tmp_e

  # get coordinates

  ori_coors <- get_coors(coors, go, seed = seed)

  coors <- ori_coors[, c("X", "Y")] %>% as.matrix()

  if (is.null(attributes(ori_coors)$curved)) {

    edge_curved <- NULL

  } else {

    edge_curved <- attributes(ori_coors)$curved$curved

  }

  # scale the size and width

  scale_size_width(tmp_v, tmp_e, vertex_size_range, edge_width_range)

  # some custom parameters

  some_custom_paras(tmp_v, tmp_e, ...)

  # set pie

  pie_set_for_plot(tmp_v, pie_value, pie_color)

  if (is.null(pie_value) || !"pie" %in% tmp_v$shape) pie_legend <- FALSE

  if (is.null(pie_color)) {

    pie_color_list <- NULL

  } else {

    pie_color_list <- list(pie_color)

  }

  # show labels

  tmp_v <- get_show_labels(tmp_v, labels_num)

  # modules set

  module_set_for_plot(tmp_v, mark_module, mark_color)

  if (!mark_module) module_legend <- FALSE

  if (any(igraph::is.loop(go))) go <- clean_multi_edge_metanet(go)

  # main plot

  {

    old_xpd <- graphics::par(mar = c(4, 2, 2, 2), xpd = TRUE)

    on.exit(graphics::par(old_xpd), add = TRUE)

    igraph::plot.igraph(go,

      layout = coors,

      vertex.size = tmp_v$size,

      vertex.color = tmp_v$color,

      vertex.shape = tmp_v$shape,

      vertex.label.color = tmp_v$label.color,

      edge.color = tmp_e$color,

      edge.lty = tmp_e$lty,

      edge.width = tmp_e$width,

      mark.groups = new_modu,

      mark.col = pcutils::add_alpha(module_color[names(new_modu)], mark_alpha),

      mark.border = module_color[names(new_modu)],

      vertex.pie = pie_value_list,

      vertex.pie.color = pie_color_list,

      ...,

      vertex.frame.width = 0.5,

      main = main,

      rescale = rescale,

      vertex.label.font = 1,

      vertex.label.cex = 0.07 * tmp_v$size,

      vertex.label = tmp_v$label,

      edge.arrow.size = 0.3 * tmp_e$width * 3,

      edge.arrow.width = 0.6 * tmp_e$width * 3,

      edge.curved = edge_curved,

      margin = c(0, 0, 0, 0)

    )

  }

  # add module_label

  if (module_label) {

    rescale_flag <- TRUE

    params <- list(...)

    if ("rescale" %in% names(params)) {

      if (!params[["rescale"]]) rescale_flag <- FALSE

    }

    module_coors <- get_module_coors(

      tmp_v = tmp_v, ori_coors = ori_coors,

      module_label_just = module_label_just, rescale_flag = rescale_flag

    )

    n_module <- nrow(module_coors)

    module_label_cex <- rep(module_label_cex, n_module)

    module_label_color <- rep(module_label_color, n_module)

    for (i in seq_len(n_module)) {

      text(

        x = module_coors[i, "X"], y = module_coors[i, "Y"],

        labels = module_coors[i, "module"],

        cex = module_label_cex, col = module_label_color[i]

      )

    }

  }

  if (!legend) {

    return(invisible())

  }

  if ("vertex.frame.width" %in% names(list(...))) {

    vertex_frame_width <- list(...)[["vertex.frame.width"]]

  } else {

    vertex_frame_width <- 0.5

  }

  # produce legends

  if (grepl("skeleton", main)) attributes(tmp_v)$skeleton <- TRUE

  produce_c_net_legends(

    tmp_v, tmp_e, vertex_frame_width,

    legend_position, legend_number, legend_cex,

    node_size_text, edge_width_text,

    group_legend_title, group_legend_order,

    color_legend, color_legend_order,

    size_legend, size_legend_title,

    edge_legend, edge_legend_title, edge_legend_order,

    width_legend, width_legend_title,

    lty_legend, lty_legend_title, lty_legend_order,

    module_legend, module_legend_title, module_legend_order, module_color, mark_alpha,

    pie_legend, pie_legend_title, pie_legend_order, pie_color, ...

  )

}