CFG <- list(
  # --- Dữ liệu ---------------------------------------------------------
  data_start    = as.Date("2010-01-01"),  # tải sớm hơn eval_start để có dữ liệu "khởi động" cho signal
  data_end      = Sys.Date(),
  price_field   = "price_adjusted",       # hoặc "price_close" (bản nháp cũ dùng price_close)

  # --- Cửa sổ đánh giá -------------------------------------------------
  eval_start    = as.Date("2010-01-01"),  # mọi chiến lược được đánh giá trên CÙNG cửa sổ này
  warmup_obs    = 260,                    # >= (lookback/window lớn nhất trong mọi grid) + 1

  # --- Giả định giao dịch ----------------------------------------------
  trading_days  = 252,
  risk_free     = 0,
  cost_bps      = 10,                     # chi phí trên mỗi 1 đơn vị turnover (10 bps = 0.10%)
  cost_grid_bps = c(0, 5, 10, 20, 30, 50),# dùng cho phân tích độ nhạy chi phí

  # --- Kiểm định ngoài mẫu ---------------------------------------------
  train_end     = as.Date("2024-12-31"),  # hold-out: train <= train_end < test_start <= test
  test_start    = as.Date("2025-01-01"),
  wf_years      = 2011:2025,              # các năm test của walk-forward
  min_train_obs = 200,                    # số quan sát tối thiểu để chọn tham số

  # --- Regime ----------------------------------------------------------
  regime_ma     = 200                     # Bull nếu giá > MA(200) của ngày hôm trước
)
CFG$cost <- CFG$cost_bps / 1e4

UNIVERSE <- tribble(
  ~ticker, ~yahoo,   ~name,             ~sector,  ~asset_class,
  "HPG",   "HPG.VN", "Hoa Phat Group",  "Steel",  "Equity",
  "FPT",   "FPT.VN", "FPT Corp",   "Technology",  "Equity",
  # Ví dụ thêm mã (bỏ comment, thêm dấu "," sau dòng NKG, kiểm tra symbol trên Yahoo Finance):
  # "VNM",   "VNM.VN",       "Vinamilk",        "Consumer Staples", "Equity",
  # "FPT",   "FPT.VN",       "FPT Corp",        "Technology",       "Equity",
  # "GOLD",  "GC=F",         "Gold futures",    "Commodity",        "Commodity"
)

kable(UNIVERSE, caption = "Asset universe")

# ---- Rolling helpers (an toàn khi chuỗi ngắn hơn cửa sổ) --------------------
roll_mean <- function(x, k) {
  if (length(x) < k) return(rep(NA_real_, length(x)))
  zoo::rollmeanr(x, k, fill = NA)
}
roll_sd <- function(x, k) {
  if (length(x) < k) return(rep(NA_real_, length(x)))
  zoo::rollapplyr(x, k, sd, fill = NA)
}

# ---- Khai báo chiến lược ----------------------------------------------------
strategy <- function(id, label, fn, params = list(), grid = NULL, family = "signal") {
  if (is.null(grid)) grid <- params          # không có grid => grid chỉ gồm tham số mặc định
  stopifnot(is.function(fn), is.list(params), is.list(grid))
  list(id = id, label = label, fn = fn, params = params, grid = grid, family = family)
}

register_strategies <- function(...) {
  s <- list(...)
  setNames(s, purrr::map_chr(s, "id"))
}

param_text <- function(p) paste(names(p), unlist(p), sep = "=", collapse = ", ")

param_label <- function(id, p) {
  if (length(p) == 0) return(id)
  paste0(id, "(", param_text(p), ")")
}

# Bảng "spec" = mỗi dòng là một (chiến lược + bộ tham số)
#   use_grid = FALSE: chỉ tham số mặc định | TRUE: toàn bộ lưới tham số
make_specs <- function(strategies, use_grid = FALSE) {
  purrr::map_dfr(strategies, function(s) {
    param_sets <- if (use_grid && length(s$grid) > 0) {
      purrr::pmap(do.call(tidyr::expand_grid, s$grid), list)
    } else {
      list(s$params)
    }
    tibble(
      strategy = s$id,
      label    = s$label,
      family   = s$family,
      spec     = purrr::map_chr(param_sets, \(p) param_label(s$id, p)),
      params   = param_sets
    )
  })
}

# ---- Hàm tín hiệu ---------------------------------------------------------

# Benchmark: luôn nắm giữ
sig_buy_hold <- function(price) rep(1, length(price))

# Momentum: long nếu lợi suất L phiên gần nhất > 0, ngược lại cash
sig_momentum <- function(price, lookback = 60) {
  mom <- price / dplyr::lag(price, lookback) - 1
  as.numeric(mom > 0)
}

# Mean reversion: z-score của giá so với trung bình/độ lệch chuẩn cuộn
#   long khi z < -threshold, short khi z > +threshold, thoát khi z cắt qua 0
sig_mean_reversion <- function(price, window = 20, threshold = 2) {
  z <- (price - roll_mean(price, window)) / roll_sd(price, window)
  position <- numeric(length(z))
  state <- 0

  for (i in seq_along(z)) {
    if (is.na(z[i])) {
      position[i] <- 0
      next
    }
    if (state == 0) {
      if (z[i] < -threshold) {
        state <- 1
      } else if (z[i] > threshold) {
        state <- -1
      }
    } else if (state == 1 && z[i] >= 0) {
      state <- 0
    } else if (state == -1 && z[i] <= 0) {
      state <- 0
    }
    position[i] <- state
  }
  position
}

# ---- Đăng ký chiến lược ----------------------------------------------------
STRATEGIES <- register_strategies(

  strategy(
    id = "buy_hold", label = "Buy & Hold", family = "benchmark",
    fn = sig_buy_hold
  ),

  strategy(
    id = "momentum", label = "Momentum", family = "trend",
    fn = sig_momentum,
    params = list(lookback = 60),
    grid   = list(lookback = c(20, 40, 60, 90, 120, 180, 252))
  ),

  strategy(
    id = "mean_reversion", label = "Mean Reversion", family = "mean-reversion",
    fn = sig_mean_reversion,
    params = list(window = 20, threshold = 2),
    grid   = list(window = c(10, 20, 40, 60), threshold = c(1.5, 2, 2.5))
  )

  # ---- MẪU: thêm chiến lược mới -------------------------------------------
  # 1) Viết hàm tín hiệu (nhớ dùng roll_mean / roll_sd nếu cần cửa sổ cuộn):
  #      sig_ma_cross <- function(price, fast = 20, slow = 100) {
  #        as.numeric(roll_mean(price, fast) > roll_mean(price, slow))
  #      }
  # 2) Thêm một khai báo vào danh sách (nhớ dấu phẩy):
  #      , strategy(
  #          id = "ma_cross", label = "MA Crossover", family = "trend",
  #          fn = sig_ma_cross,
  #          params = list(fast = 20, slow = 100),
  #          grid   = list(fast = c(10, 20, 50), slow = c(100, 150, 200))
  #        )
  # 3) Đảm bảo CFG$warmup_obs >= tham số lớn nhất + 1. Xong: mọi bảng/biểu đồ tự cập nhật.
)

# Bảng màu cố định theo chiến lược (Buy & Hold luôn màu xám)
STRAT_PAL <- setNames(
  grDevices::hcl.colors(length(STRATEGIES), "Dark 3"),
  purrr::map_chr(STRATEGIES, "label")
)
STRAT_PAL[purrr::map_chr(STRATEGIES, "family") == "benchmark"] <- "grey40"

strategy_table <- purrr::map_dfr(STRATEGIES, function(s) {
  tibble(
    Strategy = s$label, Family = s$family,
    `Default parameters` = if (length(s$params)) param_text(s$params) else "-",
    `Grid size` = nrow(make_specs(list(s), use_grid = TRUE))
  )
})
kable(strategy_table, caption = "Strategy universe")

# Đổi nguồn dữ liệu (CSV, API khác...) chỉ cần sửa hàm này, miễn là trả về: ticker, ref_date, price
load_prices <- function(universe, cfg = CFG) {
  dir.create("data/yfr_cache", recursive = TRUE, showWarnings = FALSE)

  raw <- yfR::yf_get(
    tickers      = universe$yahoo,
    first_date   = cfg$data_start,
    last_date    = cfg$data_end,
    freq_data    = "daily",
    do_cache     = TRUE,
    cache_folder = "data/yfr_cache",
    be_quiet     = TRUE
  )

  prices <- raw |>
    inner_join(transmute(universe, symbol = ticker, ticker = yahoo), by = "ticker") |>
    transmute(ticker = symbol, ref_date, price = .data[[cfg$price_field]]) |>
    drop_na(price) |>
    arrange(ticker, ref_date)

  missing <- setdiff(universe$ticker, unique(prices$ticker))
  if (length(missing) > 0) {
    warning("No data returned for: ", paste(missing, collapse = ", "))
  }
  prices
}

backtest_one <- function(df, strat, params = strat$params, cost = CFG$cost, cfg = CFG) {
  # df: một mã (ref_date, price), đã sắp xếp theo thời gian
  signal   <- do.call(strat$fn, c(list(price = df$price), params))
  position <- dplyr::lag(signal)           # dịch 1 phiên: không dùng thông tin ngày t để ăn lợi suất ngày t
  position[is.na(position)] <- 0           # chưa đủ dữ liệu => cash

  tibble(
    ref_date = df$ref_date,
    obs      = seq_len(nrow(df)),
    position = position,
    ret_mkt  = df$price / dplyr::lag(df$price) - 1
  ) |>
    # cửa sổ đánh giá chung cho mọi chiến lược
    filter(ref_date >= cfg$eval_start, obs > cfg$warmup_obs) |>
    mutate(
      turnover  = abs(position - dplyr::lag(position, default = 0)),  # bắt đầu từ cash
      ret_gross = position * ret_mkt,
      ret_net   = ret_gross - turnover * cost
    )
}

run_backtests <- function(prices, specs, strategies = STRATEGIES, cost = CFG$cost) {
  purrr::imap_dfr(split(prices, prices$ticker), function(px, tk) {
    purrr::map_dfr(seq_len(nrow(specs)), function(i) {
      backtest_one(px, strategies[[specs$strategy[i]]], specs$params[[i]], cost) |>
        mutate(
          ticker = tk, strategy = specs$strategy[i], label = specs$label[i],
          family = specs$family[i], spec = specs$spec[i], .before = 1
        )
    })
  }) |>
    mutate(label = factor(label, levels = names(STRAT_PAL)))
}

PERF_KEYS <- c("ticker", "strategy", "label", "family")

perf_metrics <- function(r, turnover = NULL, position = NULL,
                         tdays = CFG$trading_days, rf = CFG$risk_free) {
  ok <- is.finite(r)
  r  <- r[ok]
  n  <- length(r)

  out <- list(n_obs = n, cum_return = NA_real_, ann_return = NA_real_, ann_vol = NA_real_,
              sharpe = NA_real_, sortino = NA_real_, max_dd = NA_real_)
  if (n >= 2) {
    wealth   <- cumprod(1 + r)
    cum      <- wealth[n] - 1
    ann_ret  <- (1 + cum)^(tdays / n) - 1
    ann_vol  <- sd(r) * sqrt(tdays)
    down_dev <- sqrt(mean(pmin(r, 0)^2)) * sqrt(tdays)

    out$cum_return <- cum
    out$ann_return <- ann_ret
    out$ann_vol    <- ann_vol
    out$sharpe     <- if (ann_vol > 0) (ann_ret - rf) / ann_vol else NA_real_
    out$sortino    <- if (down_dev > 0) (ann_ret - rf) / down_dev else NA_real_
    out$max_dd     <- min(wealth / pmax(1, cummax(wealth)) - 1)
  }
  if (!is.null(turnover)) out$annual_turnover <- mean(turnover[ok]) * tdays
  if (!is.null(position)) out$exposure <- mean(abs(position[ok]))
  as_tibble(out)
}

# Tổng hợp chỉ số theo nhóm bất kỳ (mặc định: mã x chiến lược)
summarise_perf <- function(bt, ret_col = "ret_net", by = PERF_KEYS) {
  bt |>
    group_by(across(all_of(by))) |>
    reframe(perf_metrics(.data[[ret_col]], turnover, position))
}

# Đường vốn & drawdown
add_wealth <- function(bt, ret_col = "ret_net", by = c("ticker", "strategy")) {
  bt |>
    arrange(ref_date) |>
    group_by(across(all_of(by))) |>
    mutate(
      wealth   = cumprod(1 + .data[[ret_col]]),
      drawdown = wealth / pmax(1, cummax(wealth)) - 1
    ) |>
    ungroup()
}

# Ma trận so sánh: hàng = chiến lược, cột = mã cổ phiếu
metric_matrix <- function(perf, metric, fmt = \(x) sprintf("%.2f", x)) {
  perf |>
    select(label, ticker, value = all_of(metric)) |>
    mutate(value = fmt(value)) |>
    pivot_wider(names_from = ticker, values_from = value) |>
    arrange(label)
}

fmt_pct <- \(x) sprintf("%.1f%%", 100 * x)

fmt_perf <- function(df) {
  df |>
    mutate(
      across(any_of(c("cum_return", "ann_return", "ann_vol", "max_dd", "exposure",
                      "return_drag", "test_return")), fmt_pct),
      across(any_of(c("sharpe", "sortino", "annual_turnover", "sharpe_drag",
                      "train_sharpe", "test_sharpe", "sharpe_retention")), \(x) sprintf("%.2f", x))
    )
}

signif_stars <- function(p) {
  as.character(cut(p, c(-Inf, 0.01, 0.05, 0.1, Inf), labels = c("***", "**", "*", "")))
}

# H0: lợi suất trung bình mỗi ngày = 0
t_test_stats <- function(r) {
  r <- r[is.finite(r)]
  tt <- tryCatch(t.test(r, mu = 0), error = function(e) NULL)
  tibble(
    mean_daily = mean(r),
    t_stat     = if (is.null(tt)) NA_real_ else unname(tt$statistic),
    p_value    = if (is.null(tt)) NA_real_ else tt$p.value
  )
}

# Hồi quy OLS: r_strategy = alpha + beta * r_asset + e
alpha_beta <- function(r, m, tdays = CFG$trading_days) {
  ok <- is.finite(r) & is.finite(m)
  empty <- tibble(alpha_ann = NA_real_, alpha_p = NA_real_, beta = NA_real_, r_squared = NA_real_)
  if (sum(ok) < 30 || sd(r[ok]) == 0) return(empty)

  fit <- lm(y ~ x, data = data.frame(y = r[ok], x = m[ok]))
  cf  <- summary(fit)$coefficients
  tibble(
    alpha_ann = unname(coef(fit)[1]) * tdays,
    alpha_p   = cf[1, 4],
    beta      = unname(coef(fit)[2]),
    r_squared = summary(fit)$r.squared
  )
}

# Thống kê phân phối (không dùng package moments để giảm phụ thuộc)
skewness <- function(x) { x <- x[is.finite(x)]; mean((x - mean(x))^3) / mean((x - mean(x))^2)^1.5 }
excess_kurtosis <- function(x) { x <- x[is.finite(x)]; mean((x - mean(x))^4) / mean((x - mean(x))^2)^2 - 3 }

asset_diagnostics <- function(r, lag = 10) {
  jb <- tseries::jarque.bera.test(r)
  lb <- Box.test(r, lag = lag, type = "Ljung-Box")
  tibble(
    jb_stat = unname(jb$statistic), jb_p = jb$p.value,
    lb_stat = unname(lb$statistic), lb_p = lb$p.value
  )
}

# Chọn bộ tham số có Sharpe (net) cao nhất trên dữ liệu <= end_date, theo từng (mã, chiến lược)
select_best <- function(grid_bt, end_date, min_obs = CFG$min_train_obs) {
  grid_bt |>
    filter(ref_date <= end_date) |>
    group_by(ticker, strategy, spec) |>
    filter(n() >= min_obs) |>
    summarise(train_sharpe = perf_metrics(ret_net)$sharpe, .groups = "drop_last") |>
    filter(is.finite(train_sharpe)) |>
    slice_max(train_sharpe, n = 1, with_ties = FALSE) |>
    ungroup()
}

# Walk-forward mở rộng: mỗi năm test dùng tham số chọn trên toàn bộ dữ liệu trước đó
walk_forward <- function(grid_bt, years) {
  selection <- purrr::map_dfr(years, function(y) {
    select_best(grid_bt, as.Date(paste0(y - 1, "-12-31"))) |> mutate(test_year = y)
  })
  returns <- grid_bt |>
    mutate(test_year = lubridate::year(ref_date)) |>
    inner_join(selection, by = c("ticker", "strategy", "spec", "test_year"))
  list(selection = selection, returns = returns)
}

# Tổng hợp theo nhóm (sector / asset class): chiến lược có khái quát hóa không?
cross_section_summary <- function(perf, universe = UNIVERSE, group_col = "sector") {
  bh <- perf |> filter(family == "benchmark") |> select(ticker, bh_sharpe = sharpe)
  perf |>
    filter(family != "benchmark") |>
    left_join(bh, by = "ticker") |>
    left_join(select(universe, ticker, all_of(group_col)), by = "ticker") |>
    group_by(across(all_of(group_col)), label) |>
    summarise(
      n_assets      = n(),
      mean_sharpe   = mean(sharpe, na.rm = TRUE),
      median_sharpe = median(sharpe, na.rm = TRUE),
      pct_positive  = mean(sharpe > 0, na.rm = TRUE),
      pct_beat_bh   = mean(sharpe > bh_sharpe, na.rm = TRUE),
      .groups = "drop"
    )
}

plot_lines <- function(df, y, title, ylab, log_y = FALSE, hline = NULL) {
  p <- ggplot(df, aes(ref_date, .data[[y]], colour = label, linewidth = family == "benchmark")) +
    geom_line() +
    facet_wrap(~ticker, ncol = 2, scales = "free_y") +
    scale_colour_manual(values = STRAT_PAL, name = NULL) +
    scale_linewidth_manual(values = c("TRUE" = 0.9, "FALSE" = 0.5), guide = "none") +
    labs(title = title, x = NULL, y = ylab)
  if (!is.null(hline)) p <- p + geom_hline(yintercept = hline, colour = "grey60", linewidth = 0.3)
  if (log_y) p <- p + scale_y_log10()
  p
}

prices |>
  filter(ref_date >= CFG$eval_start) |>
  group_by(ticker) |>
  mutate(index = price / first(price) * 100) |>
  ungroup() |>
  ggplot(aes(ref_date, index, colour = ticker)) +
  geom_line() +
  scale_y_log10() +
  labs(title = "Normalized prices (base = 100, log scale)", x = NULL, y = "Index", colour = NULL)

asset_stats <- asset_ret |>
  group_by(ticker) |>
  reframe(
    select(perf_metrics(ret), n_obs, ann_return, ann_vol, sharpe, max_dd),
    skewness        = skewness(ret),
    excess_kurtosis = excess_kurtosis(ret),
    min_daily       = min(ret),
    max_daily       = max(ret)
  )

asset_stats |>
  mutate(across(c(ann_return, ann_vol, max_dd, min_daily, max_daily), fmt_pct),
         across(c(sharpe, skewness, excess_kurtosis), \(x) sprintf("%.2f", x))) |>
  kable(caption = "Buy & Hold descriptive statistics (Sharpe with zero risk-free rate)")

ggplot(asset_ret, aes(ret)) +
  geom_histogram(aes(y = after_stat(density)), bins = 80, fill = "lightblue", colour = NA) +
  facet_wrap(~ticker, ncol = 2, scales = "free") +
  labs(title = "Daily return distribution", x = "Simple return", y = "Density")

asset_ret |>
  group_by(ticker) |>
  reframe(asset_diagnostics(ret)) |>
  mutate(across(c(jb_stat, lb_stat), \(x) round(x, 2)),
         across(c(jb_p, lb_p), \(x) signif(x, 3))) |>
  kable(caption = "Jarque-Bera and Ljung-Box tests on daily returns")

acf_tbl <- asset_ret |>
  group_by(ticker) |>
  reframe(
    lag = 1:10,
    acf = as.numeric(acf(ret, lag.max = 10, plot = FALSE)$acf)[-1],
    ci  = 1.96 / sqrt(n())
  )

ggplot(acf_tbl, aes(lag, acf)) +
  geom_col(fill = "steelblue", width = 0.6) +
  geom_line(aes(y = ci), linetype = "dashed", colour = "firebrick") +
  geom_line(aes(y = -ci), linetype = "dashed", colour = "firebrick") +
  facet_wrap(~ticker, ncol = 2) +
  scale_x_continuous(breaks = 1:10) +
  labs(title = "Autocorrelation of daily returns (95% bounds)", x = "Lag", y = "ACF")

scoreboard_net |>
  arrange(ticker, label) |>
  select(ticker, label, n_obs, cum_return, ann_return, ann_vol, sharpe, sortino,
         max_dd, annual_turnover, exposure) |>
  fmt_perf() |>
  kable(caption = sprintf("Net performance at %d bps per unit of turnover", CFG$cost_bps))

kable(metric_matrix(scoreboard_net, "sharpe"), caption = "Net Sharpe ratio")

kable(metric_matrix(scoreboard_net, "ann_return", fmt_pct), caption = "Net annualized return")

kable(metric_matrix(scoreboard_net, "max_dd", fmt_pct), caption = "Maximum drawdown")

kable(metric_matrix(scoreboard_net, "annual_turnover"), caption = "Annual turnover (units of position)")

ggplot(scoreboard_net, aes(label, ticker, fill = sharpe)) +
  geom_tile(colour = "white") +
  geom_text(aes(label = sprintf("%.2f", sharpe))) +
  scale_fill_gradient2(low = "firebrick", mid = "white", high = "steelblue", midpoint = 0) +
  labs(title = "Net Sharpe ratio heatmap", x = NULL, y = NULL, fill = "Sharpe")

scoreboard_net |>
  pivot_longer(c(ann_return, ann_vol, sharpe, max_dd), names_to = "metric") |>
  mutate(metric = factor(metric,
                         levels = c("ann_return", "ann_vol", "sharpe", "max_dd"),
                         labels = c("Ann. return", "Ann. volatility", "Sharpe", "Max drawdown"))) |>
  ggplot(aes(label, value, fill = label)) +
  geom_col() +
  facet_grid(metric ~ ticker, scales = "free_y") +
  scale_fill_manual(values = STRAT_PAL, name = NULL) +
  labs(title = "Net metrics by asset and strategy", x = NULL, y = NULL) +
  theme(axis.text.x = element_blank())

bt_wealth <- add_wealth(bt, "ret_net")

plot_lines(bt_wealth, "wealth", "Growth of 1 unit (net of costs, log scale)", "Wealth",
           log_y = TRUE, hline = 1)

plot_lines(bt_wealth, "drawdown", "Drawdown (net of costs)", "Drawdown") +
  scale_y_continuous(labels = scales::percent)

cost_drag <- scoreboard |>
  select(basis, ticker, label, family, ann_return, sharpe) |>
  pivot_wider(names_from = basis, values_from = c(ann_return, sharpe)) |>
  mutate(return_drag = ann_return_gross - ann_return_net,
         sharpe_drag = sharpe_gross - sharpe_net) |>
  left_join(select(scoreboard_net, ticker, label, annual_turnover), by = c("ticker", "label")) |>
  arrange(ticker, label) |>
  select(ticker, label, annual_turnover, ann_return_gross, ann_return_net, return_drag,
         sharpe_gross, sharpe_net, sharpe_drag)

cost_drag |>
  mutate(across(c(ann_return_gross, ann_return_net, return_drag), fmt_pct),
         across(c(annual_turnover, sharpe_gross, sharpe_net, sharpe_drag), \(x) sprintf("%.2f", x))) |>
  kable(caption = "Cost drag: gross minus net")

cost_sens <- purrr::map_dfr(CFG$cost_grid_bps, function(b) {
  bt |>
    mutate(ret_net = ret_gross - turnover * b / 1e4) |>
    summarise_perf("ret_net") |>
    mutate(cost_bps = b)
})

ggplot(cost_sens, aes(cost_bps, sharpe, colour = label, linetype = family == "benchmark")) +
  geom_line() +
  geom_point() +
  geom_hline(yintercept = 0, colour = "grey60", linewidth = 0.3) +
  facet_wrap(~ticker, ncol = 2) +
  scale_colour_manual(values = STRAT_PAL, name = NULL) +
  scale_linetype_manual(values = c("TRUE" = "dashed", "FALSE" = "solid"), guide = "none") +
  labs(title = "Sharpe ratio vs transaction cost", x = "Cost per unit of turnover (bps)", y = "Net Sharpe")

# Mức chi phí mà tại đó Sharpe (net) của mỗi chiến lược vẫn lớn hơn Buy & Hold cùng mức chi phí
cost_sens |>
  select(ticker, label, family, cost_bps, sharpe) |>
  group_by(ticker, cost_bps) |>
  mutate(bh_sharpe = sharpe[family == "benchmark"][1]) |>
  ungroup() |>
  filter(family != "benchmark") |>
  mutate(beats_bh = sharpe > bh_sharpe) |>
  group_by(ticker, label) |>
  summarise(
    `Highest cost still beating Buy & Hold (bps)` =
      if (any(beats_bh, na.rm = TRUE)) max(cost_bps[beats_bh], na.rm = TRUE) else NA_real_,
    .groups = "drop"
  ) |>
  kable(caption = "Cost tolerance (NA = never beats Buy & Hold in the tested cost range)")

ttest_tbl <- bt |>
  group_by(across(all_of(PERF_KEYS))) |>
  reframe(t_test_stats(ret_net)) |>
  mutate(signif = signif_stars(p_value)) |>
  arrange(ticker, label)

ttest_tbl |>
  transmute(ticker, label,
            `Mean daily return` = sprintf("%.4f%%", 100 * mean_daily),
            `t-stat` = round(t_stat, 2),
            `p-value` = signif(p_value, 3),
            signif) |>
  kable(caption = "One-sample t-test, H0: mean daily net return = 0 (*** p<0.01, ** p<0.05, * p<0.1)")

alpha_tbl <- bt |>
  filter(family != "benchmark") |>
  group_by(across(all_of(PERF_KEYS))) |>
  reframe(alpha_beta(ret_net, ret_mkt)) |>
  mutate(signif = signif_stars(alpha_p)) |>
  arrange(ticker, label)

alpha_tbl |>
  transmute(ticker, label,
            `Alpha (ann.)` = fmt_pct(alpha_ann),
            `Alpha p-value` = signif(alpha_p, 3),
            signif,
            Beta = round(beta, 3),
            `R-squared` = round(r_squared, 3)) |>
  kable(caption = "OLS: strategy return = alpha + beta x asset return")

sensitivity <- grid_bt |>
  filter(ref_date <= CFG$train_end) |>
  summarise_perf("ret_net", by = c(PERF_KEYS, "spec")) |>
  left_join(select(grid_specs, strategy, spec, params), by = c("strategy", "spec"))

plot_sensitivity <- function(id) {
  s  <- STRATEGIES[[id]]
  pn <- names(s$grid)[lengths(s$grid) > 1]          # các tham số thực sự thay đổi
  d  <- sensitivity |> filter(strategy == id) |> tidyr::unnest_wider(params)

  if (length(pn) == 1) {
    ggplot(d, aes(.data[[pn]], sharpe)) +
      geom_hline(yintercept = 0, linetype = "dashed") +
      geom_line() + geom_point() +
      facet_wrap(~ticker, ncol = 2) +
      labs(title = paste(s$label, "- parameter sensitivity (train period)"), x = pn, y = "Net Sharpe")
  } else if (length(pn) == 2) {
    ggplot(d, aes(factor(.data[[pn[1]]]), factor(.data[[pn[2]]]), fill = sharpe)) +
      geom_tile(colour = "white") +
      geom_text(aes(label = sprintf("%.2f", sharpe)), size = 3) +
      scale_fill_gradient2(low = "firebrick", mid = "white", high = "steelblue", midpoint = 0) +
      facet_wrap(~ticker, ncol = 2) +
      labs(title = paste(s$label, "- parameter sensitivity (train period)"),
           x = pn[1], y = pn[2], fill = "Sharpe")
  } else {
    NULL   # >2 tham số: xem bảng `sensitivity`
  }
}

tunable <- names(Filter(\(s) any(lengths(s$grid) > 1), STRATEGIES))

for (id in tunable) print(plot_sensitivity(id))

best_train <- select_best(grid_bt, CFG$train_end)

holdout_bt <- grid_bt |>
  inner_join(select(best_train, ticker, strategy, spec), by = c("ticker", "strategy", "spec"))

perf_train <- holdout_bt |>
  filter(ref_date <= CFG$train_end) |>
  summarise_perf("ret_net", by = c(PERF_KEYS, "spec")) |>
  select(all_of(PERF_KEYS), spec, train_sharpe = sharpe)

perf_test <- holdout_bt |>
  filter(ref_date >= CFG$test_start) |>
  summarise_perf("ret_net", by = c(PERF_KEYS, "spec")) |>
  select(all_of(PERF_KEYS), spec, test_return = ann_return, test_sharpe = sharpe, max_dd)

holdout_tbl <- perf_train |>
  inner_join(perf_test, by = c(PERF_KEYS, "spec")) |>
  mutate(sharpe_retention = if_else(train_sharpe > 0, test_sharpe / train_sharpe, NA_real_)) |>
  arrange(ticker, label)

holdout_tbl |>
  select(ticker, label, spec, train_sharpe, test_sharpe, sharpe_retention, test_return, max_dd) |>
  fmt_perf() |>
  kable(caption = "Train vs test (parameters selected on train only; retention = test Sharpe / train Sharpe)")

holdout_bt |>
  filter(ref_date >= CFG$test_start) |>
  add_wealth("ret_net") |>
  plot_lines("wealth", "Out-of-sample growth of 1 unit (hold-out period)", "Wealth", hline = 1)

wf <- walk_forward(grid_bt, CFG$wf_years)

wf_perf <- wf$returns |> summarise_perf("ret_net")

wf_perf |>
  arrange(ticker, label) |>
  select(ticker, label, n_obs, cum_return, ann_return, ann_vol, sharpe, sortino, max_dd, annual_turnover) |>
  fmt_perf() |>
  kable(caption = sprintf("Walk-forward out-of-sample performance (%d-%d)",
                          min(CFG$wf_years), max(CFG$wf_years)))

kable(metric_matrix(wf_perf, "sharpe"), caption = "Walk-forward Sharpe ratio (compare with the full-sample matrix above)")

wf$returns |>
  add_wealth("ret_net") |>
  plot_lines("wealth", "Walk-forward out-of-sample growth of 1 unit", "Wealth", hline = 1)

regimes <- prices |>
  arrange(ticker, ref_date) |>
  group_by(ticker) |>
  mutate(ma     = roll_mean(price, CFG$regime_ma),
         regime = if_else(dplyr::lag(price) > dplyr::lag(ma), "Bull", "Bear")) |>
  ungroup() |>
  select(ticker, ref_date, regime)

regime_perf <- bt |>
  inner_join(regimes, by = c("ticker", "ref_date")) |>
  filter(!is.na(regime)) |>
  group_by(across(all_of(c(PERF_KEYS, "regime")))) |>
  reframe(
    perf_metrics(ret_net, turnover, position),
    mean_daily = mean(ret_net),
    hit_rate   = mean(ret_net > 0)
  )

regime_perf |>
  arrange(ticker, label, desc(regime)) |>
  transmute(ticker, label, regime, days = n_obs,
            `Mean daily` = sprintf("%.3f%%", 100 * mean_daily),
            `Cumulative` = fmt_pct(cum_return),
            `Hit rate` = fmt_pct(hit_rate),
            Exposure = fmt_pct(exposure)) |>
  kable(caption = "Net performance by regime")

ggplot(regime_perf, aes(regime, mean_daily * CFG$trading_days, fill = label)) +
  geom_col(position = "dodge") +
  geom_hline(yintercept = 0, linetype = "dashed") +
  facet_wrap(~ticker, ncol = 2) +
  scale_fill_manual(values = STRAT_PAL, name = NULL) +
  scale_y_continuous(labels = scales::percent) +
  labs(title = "Annualized mean return by regime", x = NULL, y = "Mean daily return x 252")

gen_full <- cross_section_summary(scoreboard_net, group_col = "sector")
gen_wf   <- cross_section_summary(wf_perf, group_col = "sector")

fmt_gen <- \(d) d |>
  mutate(across(c(pct_positive, pct_beat_bh), fmt_pct),
         across(c(mean_sharpe, median_sharpe), \(x) sprintf("%.2f", x)))

kable(fmt_gen(gen_full), caption = "By sector, full sample (net Sharpe)")

kable(fmt_gen(gen_wf), caption = "By sector, walk-forward out-of-sample (net Sharpe)")

kable(fmt_gen(cross_section_summary(wf_perf, group_col = "asset_class")),
      caption = "By asset class, walk-forward out-of-sample (net Sharpe)")