Base Show

function Base.show(io::IO, ::MIME"text/plain", x::MyProcess)
    if get(io, :compact, false)
        show(io, x)
    else
        println(io, "MyProcess")
        # ... full multi-line body ...
    end
end

function Base.show(io::IO, x::MyProcess)
    print(io, "MyProcess (", nameof(typeof(x.process)), ", N_ens=", x.N_ens, ")")
end

function Base.show(io::IO, ::MIME"text/plain", x::ParameterDistribution)
    n = length(x.name)
    println(io, "ParameterDistribution with ", n, " entr", n == 1 ? "y" : "ies")
    max_show = 8
    for i in 1:min(n, max_show)
        println(io, "  '", x.name[i], "': ", sprint(summary, x.distribution[i]))
    end
    n > max_show && println(io, "  … and ", n - max_show, " more")
end

if !isnothing(x.prior_mean)
    println(io, "  prior_dim: ", length(x.prior_mean))
end

print(io, "Observation (", n, " block", n == 1 ? "" : "s", ", dim=", dim, ")")

print(io, "PairedDataContainer (", m_in, "×", n_in, " → ", m_out, "×", n_out, ")")

# Constraint summary: Constraint{NoConstraint} (−∞, ∞)
lb = get(bounds, "lower_bound", "-∞")
ub = get(bounds, "upper_bound", "∞")
print(io, "Constraint{$(T)} ($(lb), $(ub))")

# Sampler{Float64} (prior_dim=12) — not the raw Sampler{Float64, ...} dump
print(io, "Sampler{", nameof(get_sampler_type(x)), "} (prior_dim=", length(x.prior_mean), ")")

# ── DataContainers ────────────────────────────────────────────────────────────
# ── Observations ─────────────────────────────────────────────────────────────
# ── EnsembleKalmanProcess ────────────────────────────────────────────────────

# Scenario: a type wraps a parameter matrix and a forward-model output matrix.

# Before (default Julia show — prints the full matrix)
julia> pdc
PairedDataContainer{Float64}(inputs=DataContainer{Float64}(data=[...50×100 matrix...]),
  outputs=DataContainer{Float64}(data=[...30×100 matrix...]))

# After — custom show (two overloads)
function Base.show(io::IO, ::MIME"text/plain", x::PairedDataContainer)
    if get(io, :compact, false)
        show(io, x)
    else
        m_in,  n_in  = size(x.inputs.data)
        m_out, n_out = size(x.outputs.data)
        println(io, "PairedDataContainer")
        println(io, "  inputs : ", m_in,  " × ", n_in,  " params × samples")
        println(io, "  outputs: ", m_out, " × ", n_out, " obs × samples")
    end
end

function Base.show(io::IO, x::PairedDataContainer)
    m_in, n_in   = size(x.inputs.data)
    m_out, n_out = size(x.outputs.data)
    print(io, "PairedDataContainer (", m_in, "×", n_in, " → ", m_out, "×", n_out, ")")
end

# julia> pdc
# PairedDataContainer
#   inputs : 50 × 100  params × samples
#   outputs: 30 × 100  obs × samples

# julia> [pdc, pdc]
# 2-element Vector{PairedDataContainer{Float64}}:
#  PairedDataContainer (50×100 → 30×100)
#  PairedDataContainer (50×100 → 30×100)

# After — custom summary (arrow notation for a mapping type; matches 2-arg show)
function Base.summary(io::IO, x::PairedDataContainer)
    m_in, n_in   = size(x.inputs.data)
    m_out, n_out = size(x.outputs.data)
    print(io, "PairedDataContainer (", m_in, "×", n_in, " → ", m_out, "×", n_out, ")")
end

# Scenario: a type holds N named parameter distributions; N can be large.

# Before (default Julia show — prints every distribution in full)
julia> prior
ParameterDistribution{Parameterized, Constraint{NoConstraint}, String}(
  distribution=[Parameterized(Normal{Float64}(μ=0.0, σ=1.0)), ...],
  constraint=[[Constraint{NoConstraint}(bounds=nothing)], ...],
  name=["amplitude", "length_scale", "noise_var", ...])

# After — custom show (two overloads)
function Base.show(io::IO, ::MIME"text/plain", x::ParameterDistribution)
    if get(io, :compact, false)
        show(io, x)
    else
        n = length(x.name)
        println(io, "ParameterDistribution with ", n, " entr", n == 1 ? "y" : "ies")
        max_show = 8
        for i in 1:min(n, max_show)
            n_con = length(batch(x)[i])
            println(io, "  '", x.name[i], "': ", sprint(summary, x.distribution[i]),
                    " [", n_con, " constraint", n_con == 1 ? "" : "s", "]")
        end
        n > max_show && println(io, "  … and ", n - max_show, " more")
    end
end

function Base.show(io::IO, x::ParameterDistribution)
    n = length(x.name)
    print(io, "ParameterDistribution (", n, " entr", n == 1 ? "y" : "ies", ")")
end

# julia> prior
# ParameterDistribution with 3 entries
#   'amplitude'   : Parameterized (Normal) [1 constraint]
#   'length_scale': Parameterized (LogNormal) [1 constraint]
#   'noise_var'   : Parameterized (Uniform) [1 constraint]

# julia> [prior, prior]
# 2-element Vector{ParameterDistribution{...}}:
#  ParameterDistribution (3 entries)
#  ParameterDistribution (3 entries)

# After — summary (matches 2-arg show)
function Base.summary(io::IO, x::ParameterDistribution)
    n = length(x.name)
    print(io, "ParameterDistribution (", n, " entr", n == 1 ? "y" : "ies", ")")
end

# Scenario: a mutable struct accumulates state across EKI iterations.

# Before (default Julia show — dumps every matrix stored in the struct)
julia> ekp
EnsembleKalmanProcess{Float64, ...}(u=[50×100 matrix, 50×100 matrix, ...],
  g=[...], Δt=[0.5, 0.5], rng=MersenneTwister(...), N_ens=100, ...)

# After — custom show (two overloads)
function Base.show(io::IO, ::MIME"text/plain", x::EnsembleKalmanProcess)
    if get(io, :compact, false)
        show(io, x)
    else
        n_iter = length(x.u) - 1
        n_par  = size(x.u[1].data, 1)
        println(io, "EnsembleKalmanProcess")
        println(io, "  process    : ", nameof(typeof(x.process)))
        println(io, "  N_ens      : ", x.N_ens)
        println(io, "  N_par      : ", n_par)
        println(io, "  n_iter     : ", n_iter)
        println(io, "  scheduler  : ", nameof(typeof(x.scheduler)))
        println(io, "  accelerator: ", nameof(typeof(x.accelerator)))
    end
end

function Base.show(io::IO, x::EnsembleKalmanProcess)
    n_iter = length(x.u) - 1
    print(io, "EnsembleKalmanProcess (", nameof(typeof(x.process)),
          ", N_ens=", x.N_ens, ", ", n_iter, " iter)")
end

# julia> ekp
# EnsembleKalmanProcess
#   process    : Inversion
#   N_ens      : 100
#   N_par      : 50
#   n_iter     : 5
#   scheduler  : DefaultScheduler
#   accelerator: DefaultAccelerator

# julia> [ekp, ekp]
# 2-element Vector{EnsembleKalmanProcess{...}}:
#  EnsembleKalmanProcess (Inversion, N_ens=100, 5 iter)
#  EnsembleKalmanProcess (Inversion, N_ens=100, 5 iter)

# After — summary (matches 2-arg show)
function Base.summary(io::IO, x::EnsembleKalmanProcess)
    n_iter = length(x.u) - 1
    print(io, "EnsembleKalmanProcess (", nameof(typeof(x.process)),
          ", N_ens=", x.N_ens, ", ", n_iter, " iter)")
end

@testset "PairedDataContainer show" begin
    pdc = PairedDataContainer(rand(50, 100), rand(30, 100))
    out = sprint(show, MIME("text/plain"), pdc)
    @test occursin("PairedDataContainer", out)
    @test count(==('\n'), out) <= 10
end

@testset "PairedDataContainer show compact" begin
    pdc = PairedDataContainer(rand(50, 100), rand(30, 100))
    # exercise via the 2-arg method directly
    out2 = sprint(show, pdc)
    @test occursin("PairedDataContainer", out2)
    @test !occursin('\n', out2)
    # exercise via the MIME method with compact context
    out3 = sprint(show, MIME("text/plain"), pdc; context=:compact => true)
    @test out2 == out3   # both paths must agree
end

@testset "PairedDataContainer summary" begin
    pdc = PairedDataContainer(rand(50, 100), rand(30, 100))
    out = sprint(summary, pdc)
    @test occursin("PairedDataContainer", out)
    @test !occursin('\n', out)    # must be exactly one line
end