# test-coverage-splot-deep.R
# Tests targeting ALL uncovered lines in R/splot.R for 100% coverage.
# Organized by line numbers and functional areas.

# =============================================================================
# LINE 485: tna dots forwarding
# splot() with a tna object and extra ... args (line 485: call_args[[nm]] <- dots[[nm]])
# =============================================================================

test_that("splot with tna object forwards dots arguments (line 485)", {
  skip_if_no_tna()

  # Create a tna object (labels come from dimnames, not a separate arg)
  tna_obj <- tna::tna(
    matrix(c(0, 0.3, 0.2,
             0.4, 0, 0.1,
             0.1, 0.3, 0), 3, 3, byrow = TRUE,
           dimnames = list(c("A", "B", "C"), c("A", "B", "C"))),
    inits = c(0.5, 0.3, 0.2)
  )

  # Pass extra unnamed args via dots - this triggers line 485
  result <- safe_plot(splot(tna_obj, background = "lightyellow"))
  expect_true(result$success, info = paste("splot(tna) with dots failed:", result$error))
})

# =============================================================================
# LINE 544: theme background color
# splot() with theme that provides background (line 544)
# =============================================================================

test_that("splot with theme applies background color (line 544)", {
  mat <- create_test_matrix(4, weighted = TRUE)

  # Use a theme that has a background color (e.g., "dark")
  result <- safe_plot(splot(mat, theme = "dark"))
  expect_true(result$success, info = paste("splot with theme=dark failed:", result$error))
})

# =============================================================================
# LINES 560-567: layout_coords fallback paths (new format without node x/y)
# =============================================================================

test_that("splot uses nodes x/y coords when available (line 558-559)", {
  # Create as_cograph() network, then provide layout which gives nodes x/y
  mat <- create_test_matrix(4)
  net <- as_cograph(mat)
  # ensure_cograph_network computes layout, giving nodes x/y
  result <- safe_plot(splot(net))
  expect_true(result$success, info = paste("splot with as_cograph node coords failed:", result$error))
})

test_that("splot uses network$layout when nodes x/y are all NA (lines 560-561)", {
  # Create a cograph_network where nodes have x/y = valid BUT
  # we set them to NA after ensure_cograph_network, and provide $layout
  # We need to bypass ensure_cograph_network's recomputation.
  # The trick: set nodes x to valid values so ensure_cograph_network skips,
  # but then the code at line 558 takes the first branch (nodes have x/y).
  # For line 560, we need nodes to NOT have valid x/y after ensure.
  # This is defensive code; exercise it via direct internal function call.
  mat <- create_test_matrix(4)
  net <- as_cograph(mat)
  net$nodes$x <- NA_real_
  net$nodes$y <- NA_real_
  coords <- data.frame(x = c(-1, 1, -1, 1), y = c(1, 1, -1, -1))
  net$layout <- coords
  # After ensure_cograph_network, layout will be recomputed,
  # so this test just ensures splot handles it gracefully
  result <- safe_plot(splot(net))
  expect_true(result$success, info = paste("splot with net$layout failed:", result$error))
})

test_that("splot uses R6 wrapper with cograph() format (lines 564-565)", {
  mat <- create_test_matrix(4)
  net <- cograph(mat)
  # cograph() creates R6 wrapper; nodes have x/y from layout computation
  result <- safe_plot(splot(net))
  expect_true(result$success, info = paste("splot with R6 wrapper failed:", result$error))
})

# =============================================================================
# LINES 584-605: Duplicate edges in undirected networks
# =============================================================================

test_that("splot errors on duplicate edges without edge_duplicates param (lines 584-599)", {
  # Create a network with duplicate edges (A->B and B->A in undirected mode)
  net <- as_cograph(data.frame(
    from = c(1L, 2L, 2L, 3L),
    to = c(2L, 1L, 3L, 1L),
    weight = c(0.5, 0.3, 0.8, 0.2)
  ))
  # Add layout
  net$layout <- data.frame(x = c(-1, 0, 1), y = c(0, 1, 0))

  expect_error(
    with_temp_png(splot(net, directed = FALSE)),
    "duplicate edge pair"
  )
})

test_that("splot handles duplicate edges with edge_duplicates='sum' (lines 601-602)", {
  net <- as_cograph(data.frame(
    from = c(1L, 2L, 2L, 3L),
    to = c(2L, 1L, 3L, 1L),
    weight = c(0.5, 0.3, 0.8, 0.2)
  ))
  net$layout <- data.frame(x = c(-1, 0, 1), y = c(0, 1, 0))

  result <- safe_plot(splot(net, directed = FALSE, edge_duplicates = "sum"))
  expect_true(result$success, info = paste("splot with edge_duplicates=sum failed:", result$error))
})

test_that("splot updates R6 network after dedup (lines 604-605)", {
  # Use cograph() which creates R6 wrapper
  mat <- matrix(0, 3, 3)
  mat[1, 2] <- 0.5
  mat[2, 1] <- 0.3
  mat[2, 3] <- 0.8
  mat[3, 2] <- 0.8
  mat[3, 1] <- 0.2
  mat[1, 3] <- 0.2
  net <- cograph(mat, layout = "circle")

  # Force duplicate edges for the R6 network: add both directions manually
  edges <- net$network$get_edges()
  if (nrow(edges) > 0) {
    result <- safe_plot(splot(net, directed = FALSE, edge_duplicates = "mean"))
    expect_true(result$success, info = paste("splot R6 dedup failed:", result$error))
  } else {
    skip("No edges in test matrix for R6 dedup test")
  }
})

# =============================================================================
# LINE 615: Layout coordinates not available (already covered above in line 567 test)
# =============================================================================

# =============================================================================
# LINES 672-679: node_svg custom shape handling
# =============================================================================

test_that("splot with node_svg registers SVG shape (lines 672-675)", {
  mat <- create_test_matrix(3)
  svg_str <- '<svg viewBox="0 0 100 100"><circle cx="50" cy="50" r="40" fill="red"/></svg>'

  result <- safe_plot(splot(mat, node_svg = svg_str))
  expect_true(result$success, info = paste("splot with node_svg failed:", result$error))
})

test_that("splot with invalid node_svg warns (lines 676-679)", {
  mat <- create_test_matrix(3)
  # Pass a length-2 character vector which causes register_svg_shape to error
  # (it requires a single character string), triggering the warning path
  expect_warning(
    with_temp_png(splot(mat, node_svg = c("a", "b"))),
    "Failed to register SVG shape"
  )
})

# =============================================================================
# LINES 728-729: edge_labels subsetting after weight filtering
# =============================================================================

test_that("splot subsets edge_labels after filtering by threshold (lines 728-729)", {
  mat <- matrix(c(0, 0.1, 0.8,
                  0.1, 0, 0.5,
                  0.8, 0.5, 0), 3, 3)

  # Provide explicit edge labels matching edge count before filtering
  # With threshold=0.3, the 0.1 edges should be filtered out
  # The edge_labels need to be character and match the original edge count
  net <- cograph(mat, layout = "circle")
  edges <- net$network$get_edges()
  n_orig <- nrow(edges)

  custom_labels <- paste0("E", seq_len(n_orig))

  result <- safe_plot(splot(mat, threshold = 0.3, edge_labels = custom_labels))
  expect_true(result$success, info = paste("splot label subsetting failed:", result$error))
})

# =============================================================================
# LINE 750: edge_alpha < 1 applies alpha to colors
# =============================================================================

test_that("splot with edge_alpha < 1 adjusts edge colors (line 750)", {
  mat <- create_test_matrix(4, weighted = TRUE)
  result <- safe_plot(splot(mat, edge_alpha = 0.5))
  expect_true(result$success, info = paste("splot with edge_alpha failed:", result$error))
})

# =============================================================================
# LINES 789, 791-792: edge_style string conversion (longdash, twodash, default)
# =============================================================================

test_that("splot with edge_style='longdash' (line 790)", {
  mat <- create_test_matrix(4, weighted = TRUE)
  result <- safe_plot(splot(mat, edge_style = "longdash"))
  expect_true(result$success, info = paste("splot edge_style=longdash failed:", result$error))
})

test_that("splot with edge_style='twodash' (line 791)", {
  mat <- create_test_matrix(4, weighted = TRUE)
  result <- safe_plot(splot(mat, edge_style = "twodash"))
  expect_true(result$success, info = paste("splot edge_style=twodash failed:", result$error))
})

test_that("splot with edge_style unknown string falls back to 1 (line 792)", {
  mat <- create_test_matrix(4, weighted = TRUE)
  # Pass an unknown style string - should default to 1
  result <- safe_plot(splot(mat, edge_style = "mystery_style"))
  expect_true(result$success, info = paste("splot edge_style=mystery_style failed:", result$error))
})

# =============================================================================
# LINE 875: curves='force' skips self-loops
# =============================================================================

test_that("splot with curves='force' skips self-loops (line 875)", {
  # Matrix with self-loop
  mat <- matrix(c(0.5, 0.3, 0,
                  0.4, 0, 0.2,
                  0, 0.1, 0), 3, 3, byrow = TRUE)
  result <- safe_plot(splot(mat, directed = TRUE, curves = "force"))
  expect_true(result$success, info = paste("splot curves=force with self-loop failed:", result$error))
})

# =============================================================================
# LINE 888: show_arrows as vector
# =============================================================================

test_that("splot with show_arrows as vector (line 888)", {
  mat <- create_test_matrix(4, weighted = TRUE, symmetric = FALSE)
  net <- cograph(mat, layout = "circle")
  n_edges <- net$network$n_edges

  if (n_edges > 0) {
    arrows_vec <- rep(c(TRUE, FALSE), length.out = n_edges)
    result <- safe_plot(splot(mat, directed = TRUE, show_arrows = arrows_vec))
    expect_true(result$success, info = paste("splot show_arrows vector failed:", result$error))
  }
})

# =============================================================================
# LINE 932: edge_ci_color recycled to n_edges
# =============================================================================

test_that("splot with edge_ci and explicit edge_ci_color (line 932)", {
  mat <- create_test_matrix(4, weighted = TRUE)
  net <- cograph(mat, layout = "circle")
  n_edges <- net$network$n_edges

  if (n_edges > 0) {
    ci_vals <- rep(0.2, n_edges)
    result <- safe_plot(splot(mat, edge_ci = ci_vals, edge_ci_color = "steelblue"))
    expect_true(result$success, info = paste("splot edge_ci_color failed:", result$error))
  }
})

# =============================================================================
# LINES 950-959: file output paths (svg, jpeg, tiff, unknown filetype)
# =============================================================================

test_that("splot saves to SVG file (line 950-951)", {
  # SVG requires working Cairo/X11 support which may not be available
  svg_works <- tryCatch({
    f <- tempfile(fileext = ".svg")
    on.exit(unlink(f), add = TRUE)
    grDevices::svg(f)
    grDevices::dev.off()
    file.exists(f)
  }, warning = function(w) FALSE, error = function(e) FALSE)
  skip_if_not(svg_works, "SVG device not available on this system")

  mat <- create_test_matrix(4)
  tmp_dir <- tempdir()
  tmp_base <- file.path(tmp_dir, paste0("splot_test_svg_", format(Sys.time(), "%H%M%S")))

  tryCatch({
    splot(mat, filetype = "svg", filename = tmp_base, width = 4, height = 4)
    expect_true(file.exists(paste0(tmp_base, ".svg")))
  }, finally = {
    unlink(paste0(tmp_base, ".svg"))
  })
})

test_that("splot saves to JPEG file (lines 952-954)", {
  mat <- create_test_matrix(4)
  tmp_dir <- tempdir()
  tmp_base <- file.path(tmp_dir, paste0("splot_test_jpeg_", format(Sys.time(), "%H%M%S")))

  tryCatch({
    splot(mat, filetype = "jpeg", filename = tmp_base, width = 4, height = 4, res = 72)
    expect_true(file.exists(paste0(tmp_base, ".jpeg")))
  }, finally = {
    unlink(paste0(tmp_base, ".jpeg"))
  })
})

test_that("splot saves to TIFF file (lines 955-957)", {
  mat <- create_test_matrix(4)
  tmp_dir <- tempdir()
  tmp_base <- file.path(tmp_dir, paste0("splot_test_tiff_", format(Sys.time(), "%H%M%S")))

  tryCatch({
    splot(mat, filetype = "tiff", filename = tmp_base, width = 4, height = 4, res = 72)
    expect_true(file.exists(paste0(tmp_base, ".tiff")))
  }, finally = {
    unlink(paste0(tmp_base, ".tiff"))
  })
})

test_that("splot errors on unknown filetype (lines 958-959)", {
  mat <- create_test_matrix(4)
  expect_error(
    splot(mat, filetype = "bmp"),
    "Unknown filetype"
  )
})

# =============================================================================
# LINE 1066: auto-enable donut_fill when node_shape is "donut"
# =============================================================================

test_that("splot auto-enables donut_fill for donut shape (line 1066)", {
  mat <- create_test_matrix(3)
  # node_shape="donut" with no donut_fill triggers line 1066
  result <- safe_plot(splot(mat, node_shape = "donut"))
  expect_true(result$success, info = paste("splot donut auto-fill failed:", result$error))
})

# =============================================================================
# LINE 1079: donut_fill as list
# =============================================================================

test_that("splot with donut_fill as list (line 1079)", {
  mat <- create_test_matrix(3)
  result <- safe_plot(splot(mat, donut_fill = list(0.3, 0.6, 0.9)))
  expect_true(result$success, info = paste("splot donut_fill list failed:", result$error))
})

# =============================================================================
# LINE 1100: donut_color as list with 2*n_nodes entries
# =============================================================================

test_that("splot with donut_color as (fill,bg) pairs list (line 1100)", {
  mat <- create_test_matrix(3)
  # 2*3 = 6 entries: alternating fill and bg colors
  dc <- as.list(c("red", "pink", "blue", "lightblue", "green", "lightgreen"))
  result <- safe_plot(splot(mat, donut_fill = c(0.5, 0.7, 0.3), donut_color = dc))
  expect_true(result$success, info = paste("splot donut_color pairs failed:", result$error))
})

# =============================================================================
# LINES 1256, 1274-1288: render_edges_splot edge_start_style paths
# =============================================================================

test_that("render_edges_splot returns invisibly for 0 edges (line 1256)", {
  empty_edges <- data.frame(from = integer(0), to = integer(0), weight = numeric(0))
  layout <- matrix(c(0, 0, 1, 1), 2, 2)

  result <- with_temp_png({
    plot.new()
    plot.window(xlim = c(-2, 2), ylim = c(-2, 2))
    cograph:::render_edges_splot(
      edges = empty_edges, layout = layout,
      node_sizes = c(0.05, 0.05), shapes = c("circle", "circle"),
      edge_color = character(0), edge_width = numeric(0),
      edge_style = numeric(0), curvature = numeric(0),
      curve_shape = numeric(0), curve_pivot = numeric(0),
      show_arrows = logical(0), arrow_size = numeric(0),
      bidirectional = logical(0), loop_rotation = numeric(0),
      edge_labels = NULL, edge_label_size = 0.8,
      edge_label_color = "gray30", edge_label_bg = "white",
      edge_label_position = 0.5, edge_label_fontface = 1
    )
  })
  expect_null(result)
})

test_that("splot with edge_start_style='dashed' (lines 1284, 1290-1292)", {
  mat <- create_test_matrix(4, weighted = TRUE, symmetric = FALSE)
  result <- safe_plot(splot(mat, directed = TRUE, edge_start_style = "dashed"))
  expect_true(result$success, info = paste("splot edge_start_style=dashed failed:", result$error))
})

test_that("splot with edge_start_style='dotted' (lines 1284, 1293)", {
  mat <- create_test_matrix(4, weighted = TRUE, symmetric = FALSE)
  result <- safe_plot(splot(mat, directed = TRUE, edge_start_style = "dotted"))
  expect_true(result$success, info = paste("splot edge_start_style=dotted failed:", result$error))
})

test_that("splot with numeric edge_start_style=2 (line 1273, 1282)", {
  mat <- create_test_matrix(4, weighted = TRUE, symmetric = FALSE)
  result <- safe_plot(splot(mat, directed = TRUE, edge_start_style = 2))
  expect_true(result$success, info = paste("splot edge_start_style=2 failed:", result$error))
})

test_that("splot with numeric edge_start_style=3 for dotted (line 1278-1280)", {
  mat <- create_test_matrix(4, weighted = TRUE, symmetric = FALSE)
  result <- safe_plot(splot(mat, directed = TRUE, edge_start_style = 3))
  expect_true(result$success, info = paste("splot edge_start_style=3 failed:", result$error))
})

test_that("splot with invalid numeric edge_start_style warns (lines 1274-1277)", {
  mat <- create_test_matrix(4, weighted = TRUE, symmetric = FALSE)
  expect_warning(
    with_temp_png(splot(mat, directed = TRUE, edge_start_style = 99)),
    "edge_start_style numeric value should be"
  )
})

test_that("splot with invalid string edge_start_style errors (lines 1285-1288)", {
  mat <- create_test_matrix(4, weighted = TRUE, symmetric = FALSE)
  expect_error(
    with_temp_png(splot(mat, directed = TRUE, edge_start_style = "wavy")),
    "edge_start_style must be one of"
  )
})

# =============================================================================
# LINES 1304, 1308: calc_curve_direction defensive paths
# =============================================================================

test_that("splot handles edges with NA coords in calc_curve_direction (line 1304)", {
  # Build a network where some node coords could be NA.
  # This is tested internally via render_edges_splot. We force curvature > 0.
  mat <- create_test_matrix(4, weighted = TRUE, symmetric = FALSE)
  # Using curves="force" triggers curve computation for all edges
  result <- safe_plot(splot(mat, directed = TRUE, curves = "force", curvature = 0.3))
  expect_true(result$success, info = paste("splot curves=force curvature failed:", result$error))
})

# =============================================================================
# LINE 1322: calc_curve_direction len < 1e-10 returns curve_val
# =============================================================================

test_that("splot handles zero-length edge in calc_curve_direction (line 1322)", {
  # Create a directed self-loop (from==to) which effectively has zero distance
  # between endpoints. The self-loop is already handled by a 'next' but
  # any curved edge between same point would trigger this.
  mat <- matrix(c(0, 1, 0, 1, 0, 0, 0, 0, 0), 3, 3, byrow = TRUE)
  result <- safe_plot(splot(mat, directed = TRUE, curves = TRUE, curvature = 0.3))
  expect_true(result$success, info = paste("splot zero-len edge failed:", result$error))
})

# =============================================================================
# LINE 1329: calc_curve_direction dot < 0 path
# =============================================================================

test_that("splot calc_curve_direction inward/outward bending (line 1329)", {
  # Directed network with reciprocal edges to trigger curvature
  mat <- matrix(c(0, 0.8, 0,
                  0.5, 0, 0.6,
                  0.3, 0, 0), 3, 3, byrow = TRUE)
  result <- safe_plot(splot(mat, directed = TRUE, curves = TRUE))
  expect_true(result$success, info = paste("splot curve direction failed:", result$error))
})

# =============================================================================
# LINE 1344: skip invalid edge (NA or out-of-bounds)
# =============================================================================

test_that("render_edges_splot skips edges with out-of-bounds indices (line 1344)", {
  # Manually create edges with an out-of-bounds index
  edges_df <- data.frame(from = c(1L, 99L), to = c(2L, 1L), weight = c(0.5, 0.3))
  layout <- matrix(c(0, 1, 0, 1), 2, 2)

  result <- with_temp_png({
    plot.new()
    plot.window(xlim = c(-2, 2), ylim = c(-2, 2))
    cograph:::render_edges_splot(
      edges = edges_df, layout = layout,
      node_sizes = c(0.05, 0.05), shapes = c("circle", "circle"),
      edge_color = c("green", "red"), edge_width = c(1, 1),
      edge_style = c(1, 1), curvature = c(0, 0),
      curve_shape = c(0, 0), curve_pivot = c(0.5, 0.5),
      show_arrows = c(FALSE, FALSE), arrow_size = c(1, 1),
      bidirectional = c(FALSE, FALSE), loop_rotation = c(0, 0),
      edge_labels = NULL, edge_label_size = 0.8,
      edge_label_color = "gray30", edge_label_bg = "white",
      edge_label_position = 0.5, edge_label_fontface = 1
    )
  })
  # Should succeed (invalid edges silently skipped)
  expect_true(TRUE)
})

# =============================================================================
# LINES 1363-1376: CI underlay for self-loops
# =============================================================================

test_that("splot draws CI underlay on self-loops (lines 1363-1376)", {
  # Matrix with self-loop and edge_ci
  mat <- matrix(c(0.5, 0.3, 0,
                  0, 0, 0.2,
                  0, 0, 0), 3, 3, byrow = TRUE)

  net <- cograph(mat, layout = "circle")
  n_edges <- net$network$n_edges
  if (n_edges > 0) {
    ci_vals <- rep(0.3, n_edges)
    result <- safe_plot(splot(mat, directed = TRUE, edge_ci = ci_vals,
                              edge_ci_color = "blue"))
    expect_true(result$success, info = paste("splot self-loop CI failed:", result$error))
  }
})

# =============================================================================
# LINES 1423-1434: CI underlay for curved edges
# =============================================================================

test_that("splot draws CI underlay on curved edges (lines 1423-1434)", {
  # Create reciprocal directed edges to force curvature
  mat <- matrix(c(0, 0.7, 0,
                  0.5, 0, 0,
                  0, 0, 0), 3, 3, byrow = TRUE)

  net <- cograph(mat, layout = "circle")
  n_edges <- net$network$n_edges
  if (n_edges > 0) {
    ci_vals <- rep(0.25, n_edges)
    result <- safe_plot(splot(mat, directed = TRUE, curves = TRUE,
                              edge_ci = ci_vals, edge_ci_color = "purple"))
    expect_true(result$success, info = paste("splot curved CI underlay failed:", result$error))
  }
})

# =============================================================================
# LINES 1508-1514: edge_label_fontface string-to-number conversion in render_edges_splot
# =============================================================================

test_that("splot with edge_label_fontface='bold' (line 1508)", {
  mat <- create_test_matrix(4, weighted = TRUE)
  result <- safe_plot(splot(mat, edge_labels = TRUE, edge_label_fontface = "bold"))
  expect_true(result$success, info = paste("splot bold edge labels failed:", result$error))
})

test_that("splot with edge_label_fontface='italic' (line 1509)", {
  mat <- create_test_matrix(4, weighted = TRUE)
  result <- safe_plot(splot(mat, edge_labels = TRUE, edge_label_fontface = "italic"))
  expect_true(result$success, info = paste("splot italic edge labels failed:", result$error))
})

test_that("splot with edge_label_fontface='bold.italic' (line 1510)", {
  mat <- create_test_matrix(4, weighted = TRUE)
  result <- safe_plot(splot(mat, edge_labels = TRUE, edge_label_fontface = "bold.italic"))
  expect_true(result$success, info = paste("splot bold.italic edge labels failed:", result$error))
})

test_that("splot with numeric edge_label_fontface passes through (line 1513-1514)", {
  mat <- create_test_matrix(4, weighted = TRUE)
  result <- safe_plot(splot(mat, edge_labels = TRUE, edge_label_fontface = 2))
  expect_true(result$success, info = paste("splot numeric fontface failed:", result$error))
})

# =============================================================================
# LINE 1576: render_nodes_splot returns invisibly for 0 nodes
# =============================================================================

test_that("render_nodes_splot returns invisibly for 0 nodes (line 1576)", {
  layout <- matrix(nrow = 0, ncol = 2)

  result <- with_temp_png({
    plot.new()
    plot.window(xlim = c(-2, 2), ylim = c(-2, 2))
    cograph:::render_nodes_splot(
      layout = layout,
      node_size = numeric(0), node_size2 = numeric(0),
      node_shape = character(0), node_fill = character(0),
      node_border_color = character(0), node_border_width = numeric(0),
      pie_values = NULL, pie_colors = NULL, pie_border_width = NULL,
      donut_values = NULL, donut_colors = NULL,
      donut_border_color = NULL, donut_border_width = NULL,
      donut_inner_ratio = 0.8, donut_bg_color = "gray90",
      donut_shape = "circle",
      donut_show_value = FALSE, donut_value_size = 0.8,
      donut_value_color = "black",
      donut2_values = NULL, donut2_colors = NULL, donut2_inner_ratio = 0.4,
      labels = character(0), label_size = numeric(0),
      label_color = character(0), label_position = "center"
    )
  })
  expect_null(result)
})

# =============================================================================
# LINE 1661: donut renders default 1.0 when node_shape="donut" but no value
# =============================================================================

test_that("splot donut defaults to 1.0 fill when shape is donut (line 1661)", {
  mat <- create_test_matrix(3)
  # Use donut_fill with an NA for one node to trigger default to 1.0
  result <- safe_plot(splot(mat, node_shape = "donut",
                            donut_fill = list(0.5, NA, 0.8)))
  expect_true(result$success, info = paste("splot donut default 1.0 failed:", result$error))
})

# =============================================================================
# LINES 1873-1876: legend with groups and node_names
# =============================================================================

test_that("splot legend with groups and node_names (lines 1873-1876)", {
  mat <- create_test_matrix(4, weighted = TRUE)
  result <- safe_plot(splot(mat,
                            legend = TRUE,
                            groups = c("A", "A", "B", "B"),
                            node_names = c("Node1", "Node2", "Node3", "Node4"),
                            legend_edge_colors = TRUE))
  expect_true(result$success, info = paste("splot legend groups+names failed:", result$error))
})

# =============================================================================
# LINES 1927-1955: legend with node sizes
# =============================================================================

test_that("splot legend shows node sizes (lines 1927-1955)", {
  mat <- create_test_matrix(4, weighted = TRUE)
  # legend_node_sizes = TRUE and different node sizes triggers the full
  # node size legend section
  result <- safe_plot(splot(mat,
                            legend = TRUE,
                            legend_node_sizes = TRUE,
                            node_size = c(2, 4, 6, 8),
                            groups = c("X", "X", "Y", "Y"),
                            legend_edge_colors = TRUE))
  expect_true(result$success, info = paste("splot legend node sizes failed:", result$error))
})

test_that("splot legend with node sizes but no groups (no separator)", {
  mat <- create_test_matrix(4, weighted = TRUE)
  result <- safe_plot(splot(mat,
                            legend = TRUE,
                            legend_node_sizes = TRUE,
                            node_size = c(1, 3, 5, 7)))
  expect_true(result$success, info = paste("splot legend sizes only failed:", result$error))
})

# =============================================================================
# LINE 1962: legend returns invisible when no entries
# =============================================================================

test_that("splot legend returns invisible when no entries (line 1962)", {
  mat <- create_test_matrix(4)
  # legend = TRUE but no groups, no edge colors, no node sizes
  result <- safe_plot(splot(mat,
                            legend = TRUE,
                            legend_edge_colors = FALSE,
                            legend_node_sizes = FALSE))
  expect_true(result$success, info = paste("splot empty legend failed:", result$error))
})

# =============================================================================
# ADDITIONAL COVERAGE: edge_label_shadow rendering
# =============================================================================

test_that("splot with edge_label_shadow enabled", {
  mat <- create_test_matrix(4, weighted = TRUE)
  result <- safe_plot(splot(mat,
                            edge_labels = TRUE,
                            edge_label_shadow = TRUE,
                            edge_label_shadow_color = "gray50",
                            edge_label_shadow_offset = 0.3,
                            edge_label_shadow_alpha = 0.4))
  expect_true(result$success, info = paste("splot edge label shadow failed:", result$error))
})

# =============================================================================
# ADDITIONAL COVERAGE: file output to PNG and PDF via filetype param
# =============================================================================

test_that("splot saves to PNG via filetype param", {
  mat <- create_test_matrix(4)
  tmp_dir <- tempdir()
  tmp_base <- file.path(tmp_dir, paste0("splot_test_png_", format(Sys.time(), "%H%M%S")))

  tryCatch({
    splot(mat, filetype = "png", filename = tmp_base, width = 4, height = 4, res = 72)
    expect_true(file.exists(paste0(tmp_base, ".png")))
  }, finally = {
    unlink(paste0(tmp_base, ".png"))
  })
})

test_that("splot saves to PDF via filetype param", {
  mat <- create_test_matrix(4)
  tmp_dir <- tempdir()
  tmp_base <- file.path(tmp_dir, paste0("splot_test_pdf_", format(Sys.time(), "%H%M%S")))

  tryCatch({
    splot(mat, filetype = "pdf", filename = tmp_base, width = 4, height = 4)
    expect_true(file.exists(paste0(tmp_base, ".pdf")))
  }, finally = {
    unlink(paste0(tmp_base, ".pdf"))
  })
})

# =============================================================================
# ADDITIONAL COVERAGE: as_cograph input and splot with new format
# =============================================================================

test_that("splot with as_cograph (new format) network object", {
  mat <- create_test_matrix(4, weighted = TRUE)
  net <- as_cograph(mat)
  # as_cograph has no layout, so splot will compute one
  result <- safe_plot(splot(net))
  expect_true(result$success, info = paste("splot with as_cograph failed:", result$error))
})

test_that("splot with edge list data frame input", {
  el <- create_test_edgelist(8, 5, weighted = TRUE)
  result <- safe_plot(splot(el))
  expect_true(result$success, info = paste("splot with edgelist failed:", result$error))
})

# =============================================================================
# ADDITIONAL COVERAGE: render_legend_splot directly for comprehensive paths
# =============================================================================

test_that("render_legend_splot with groups but no node_names uses as.character", {
  with_temp_png({
    plot.new()
    plot.window(xlim = c(-2, 2), ylim = c(-2, 2))
    cograph:::render_legend_splot(
      groups = c("A", "A", "B", "B"),
      node_names = NULL,
      nodes = data.frame(id = 1:4, label = paste0("N", 1:4)),
      node_colors = c("red", "red", "blue", "blue"),
      show_edge_colors = TRUE,
      has_pos_edges = TRUE,
      has_neg_edges = TRUE,
      show_node_sizes = TRUE,
      node_size = c(0.02, 0.04, 0.06, 0.08)
    )
  })
  expect_true(TRUE)
})

test_that("render_legend_splot empty (no groups, no edges, no sizes) returns invisible", {
  result <- with_temp_png({
    plot.new()
    plot.window(xlim = c(-2, 2), ylim = c(-2, 2))
    cograph:::render_legend_splot(
      groups = NULL,
      node_names = NULL,
      nodes = data.frame(id = 1:3, label = paste0("N", 1:3)),
      node_colors = rep("gray", 3),
      show_edge_colors = FALSE,
      has_pos_edges = FALSE,
      has_neg_edges = FALSE,
      show_node_sizes = FALSE,
      node_size = NULL
    )
  })
  expect_null(result)
})

test_that("render_legend_splot with only node sizes (no separator needed)", {
  with_temp_png({
    plot.new()
    plot.window(xlim = c(-2, 2), ylim = c(-2, 2))
    cograph:::render_legend_splot(
      groups = NULL,
      node_names = NULL,
      nodes = data.frame(id = 1:4, label = paste0("N", 1:4)),
      node_colors = rep("gray", 4),
      show_edge_colors = FALSE,
      has_pos_edges = FALSE,
      has_neg_edges = FALSE,
      show_node_sizes = TRUE,
      node_size = c(0.02, 0.04, 0.06, 0.08)
    )
  })
  expect_true(TRUE)
})

test_that("render_legend_splot with groups + sizes (needs separator line 1927-1933)", {
  with_temp_png({
    plot.new()
    plot.window(xlim = c(-2, 2), ylim = c(-2, 2))
    cograph:::render_legend_splot(
      groups = c("A", "B", "A", "B"),
      node_names = c("N1", "N2", "N3", "N4"),
      nodes = data.frame(id = 1:4, label = paste0("N", 1:4)),
      node_colors = c("red", "blue", "red", "blue"),
      show_edge_colors = FALSE,
      has_pos_edges = FALSE,
      has_neg_edges = FALSE,
      show_node_sizes = TRUE,
      node_size = c(0.02, 0.04, 0.06, 0.08)
    )
  })
  expect_true(TRUE)
})

# =============================================================================
# ADDITIONAL: splot with edge_ci on straight (non-curved) edges
# =============================================================================

test_that("splot draws CI underlay on straight edges (lines 1436-1446)", {
  # Undirected network = straight edges
  mat <- create_test_matrix(4, weighted = TRUE, symmetric = TRUE)
  net <- cograph(mat, layout = "circle")
  n_edges <- net$network$n_edges
  if (n_edges > 0) {
    ci_vals <- rep(0.2, n_edges)
    result <- safe_plot(splot(mat, edge_ci = ci_vals))
    expect_true(result$success, info = paste("splot straight CI underlay failed:", result$error))
  }
})

# =============================================================================
# ADDITIONAL: splot with "jpg" filetype alias
# =============================================================================

test_that("splot saves to JPG file (filetype='jpg' alias for jpeg)", {
  mat <- create_test_matrix(4)
  tmp_dir <- tempdir()
  tmp_base <- file.path(tmp_dir, paste0("splot_test_jpg_", format(Sys.time(), "%H%M%S")))

  tryCatch({
    splot(mat, filetype = "jpg", filename = tmp_base, width = 4, height = 4, res = 72)
    expect_true(file.exists(paste0(tmp_base, ".jpg")))
  }, finally = {
    unlink(paste0(tmp_base, ".jpg"))
  })
})

# =============================================================================
# DEFENSIVE CODE PATHS: render_edges_splot with NA/zero-length curvature
# Lines 1304, 1308, 1322 - calc_curve_direction internal defensive paths
# =============================================================================

test_that("render_edges_splot handles NA curvature gracefully (line 1308)", {
  # Edge with curvature = NA triggers line 1307-1308 in calc_curve_direction
  edges_df <- data.frame(from = c(1L, 2L), to = c(2L, 3L), weight = c(0.5, 0.8))
  layout <- matrix(c(-1, 0, 1, 0, 1, 0), 3, 2)

  with_temp_png({
    plot.new()
    plot.window(xlim = c(-2, 2), ylim = c(-2, 2))
    cograph:::render_edges_splot(
      edges = edges_df, layout = layout,
      node_sizes = c(0.05, 0.05, 0.05), shapes = c("circle", "circle", "circle"),
      edge_color = c("green", "blue"), edge_width = c(1, 1),
      edge_style = c(1, 1), curvature = c(NA_real_, 0.3),
      curve_shape = c(0, 0), curve_pivot = c(0.5, 0.5),
      show_arrows = c(FALSE, FALSE), arrow_size = c(1, 1),
      bidirectional = c(FALSE, FALSE), loop_rotation = c(0, 0),
      edge_labels = NULL, edge_label_size = 0.8,
      edge_label_color = "gray30", edge_label_bg = "white",
      edge_label_position = 0.5, edge_label_fontface = 1
    )
  })
  expect_true(TRUE)
})

test_that("render_edges_splot handles edges with NA in layout coords (line 1304)", {
  # Edge between nodes where one has NA coords triggers line 1352-1357 skip
  # AND edges at same position trigger line 1322
  edges_df <- data.frame(from = c(1L, 2L), to = c(2L, 3L), weight = c(0.5, 0.8))
  # Nodes 1 and 2 at same position (zero-length edge)
  layout <- matrix(c(0, 0, 1, 0, 0, 1), 3, 2)

  with_temp_png({
    plot.new()
    plot.window(xlim = c(-2, 2), ylim = c(-2, 2))
    cograph:::render_edges_splot(
      edges = edges_df, layout = layout,
      node_sizes = c(0.05, 0.05, 0.05), shapes = c("circle", "circle", "circle"),
      edge_color = c("green", "blue"), edge_width = c(1, 1),
      edge_style = c(1, 1), curvature = c(0.3, 0.3),
      curve_shape = c(0, 0), curve_pivot = c(0.5, 0.5),
      show_arrows = c(FALSE, FALSE), arrow_size = c(1, 1),
      bidirectional = c(FALSE, FALSE), loop_rotation = c(0, 0),
      edge_labels = NULL, edge_label_size = 0.8,
      edge_label_color = "gray30", edge_label_bg = "white",
      edge_label_position = 0.5, edge_label_fontface = 1
    )
  })
  expect_true(TRUE)
})

test_that("render_edges_splot with NA layout coords skips edge (line 1352-1357)", {
  # One node has NA coords - edge should be skipped
  edges_df <- data.frame(from = c(1L), to = c(2L), weight = c(0.5))
  layout <- matrix(c(0, NA, 0, NA), 2, 2)

  with_temp_png({
    plot.new()
    plot.window(xlim = c(-2, 2), ylim = c(-2, 2))
    cograph:::render_edges_splot(
      edges = edges_df, layout = layout,
      node_sizes = c(0.05, 0.05), shapes = c("circle", "circle"),
      edge_color = c("green"), edge_width = c(1),
      edge_style = c(1), curvature = c(0),
      curve_shape = c(0), curve_pivot = c(0.5),
      show_arrows = c(FALSE), arrow_size = c(1),
      bidirectional = c(FALSE), loop_rotation = c(0),
      edge_labels = NULL, edge_label_size = 0.8,
      edge_label_color = "gray30", edge_label_bg = "white",
      edge_label_position = 0.5, edge_label_fontface = 1
    )
  })
  expect_true(TRUE)
})

# =============================================================================
# DEFENSIVE: Layout fallback paths (lines 560-567, 615) via direct testing
# These paths are defensive code inside splot() but are bypassed by
# ensure_cograph_network. Test them by verifying splot handles various
# cograph_network formats gracefully.
# =============================================================================

test_that("splot handles cograph_network with attr-based layout", {
  # Construct a network with layout stored as attr (old format compatibility)
  mat <- create_test_matrix(4)
  net <- cograph(mat, layout = "circle")
  # The R6 format stores layout via get_layout(), testing that path
  result <- safe_plot(splot(net))
  expect_true(result$success, info = paste("splot attr layout failed:", result$error))
})

# =============================================================================
# ADDITIONAL: edge with NA indices via render_edges_splot (line 1340-1344)
# =============================================================================

test_that("render_edges_splot skips edges with NA indices (line 1340-1344)", {
  edges_df <- data.frame(from = c(1L, NA_integer_), to = c(2L, 1L), weight = c(0.5, 0.3))
  layout <- matrix(c(0, 1, 0, 1), 2, 2)

  with_temp_png({
    plot.new()
    plot.window(xlim = c(-2, 2), ylim = c(-2, 2))
    cograph:::render_edges_splot(
      edges = edges_df, layout = layout,
      node_sizes = c(0.05, 0.05), shapes = c("circle", "circle"),
      edge_color = c("green", "red"), edge_width = c(1, 1),
      edge_style = c(1, 1), curvature = c(0, 0),
      curve_shape = c(0, 0), curve_pivot = c(0.5, 0.5),
      show_arrows = c(FALSE, FALSE), arrow_size = c(1, 1),
      bidirectional = c(FALSE, FALSE), loop_rotation = c(0, 0),
      edge_labels = NULL, edge_label_size = 0.8,
      edge_label_color = "gray30", edge_label_bg = "white",
      edge_label_position = 0.5, edge_label_fontface = 1
    )
  })
  expect_true(TRUE)
})

# =============================================================================
# ADDITIONAL: edge_label_fontface unknown string defaults to 1 (line 1511)
# =============================================================================

test_that("splot with unknown edge_label_fontface string defaults to 1 (line 1511)", {
  mat <- create_test_matrix(4, weighted = TRUE)
  result <- safe_plot(splot(mat, edge_labels = TRUE, edge_label_fontface = "unknown_face"))
  expect_true(result$success, info = paste("splot unknown fontface failed:", result$error))
})

# =============================================================================
# ADDITIONAL: splot with dotdash edge_style (line 789)
# =============================================================================

test_that("splot with edge_style='dotdash' (line 789)", {
  mat <- create_test_matrix(4, weighted = TRUE)
  result <- safe_plot(splot(mat, edge_style = "dotdash"))
  expect_true(result$success, info = paste("splot edge_style=dotdash failed:", result$error))
})