///|
/// Generates a Geometric Poster pattern using Rectangular Grid + Dihedral Point Symmetry
fn generate_poster_pattern() -> String {
  let doc = @generative_patterns.SvgDocument::new(800.0, 800.0)

  // Base grid
  let grid = @generative_patterns.Grid::new(
    Rectangular,
    800.0,
    800.0,
    5,
    5,
    120.0,
  )
  let cells = grid.generate_cells()

  for cell in cells {
    // Symmetries for each cell
    let syms = @generative_patterns.dihedral_symmetries(5, cell.x, cell.y)
    let child_elements = []

    // Draw a small star inside each cell
    let star_path = @generative_patterns.Path::star(
      cell.x,
      cell.y,
      5,
      15.0,
      35.0,
    )
    let style = @generative_patterns.SvgStyle::new(
      fill="none",
      stroke="indigo",
      stroke_width=2.0,
      opacity=0.8,
    )

    // Apply point symmetry
    for m in syms {
      let sym_path = star_path.transform(m)
      child_elements.push(
        @generative_patterns.SvgElement::SvgPath(sym_path, style),
      )
    }

    // Add cell group
    doc.add(
      @generative_patterns.SvgElement::SvgGroup(
        child_elements,
        transform=cell.transform,
      ),
    )
  }

  doc.to_svg_string()
}

///|
/// Generates a Wallpaper Tiling pattern using Wallpaper Group p4m
fn generate_wallpaper_pattern() -> String {
  let doc = @generative_patterns.SvgDocument::new(800.0, 800.0)

  // Tiling transforms for p4m wallpaper group (8-fold symmetry per cell)
  let transforms = @generative_patterns.generate_wallpaper_transforms(
    "p4m", 800.0, 800.0, 160.0, 160.0,
  )

  // A base motif (flower shape) to tile
  let flower_path = @generative_patterns.Path::flower(80.0, 80.0, 6, 10.0, 45.0)
  let style = @generative_patterns.SvgStyle::new(
    fill="rgba(255, 100, 150, 0.2)",
    stroke="#ff3366",
    stroke_width=1.5,
    opacity=0.9,
  )

  for m in transforms {
    let tiled_path = flower_path.transform(m)
    doc.add(@generative_patterns.SvgElement::SvgPath(tiled_path, style))
  }

  doc.to_svg_string()
}

///|
/// Generates an Organic Procedural Pattern using Hexagonal Grid + Noise Domain Warping
fn generate_organic_pattern() -> String {
  let doc = @generative_patterns.SvgDocument::new(800.0, 800.0)

  let grid = @generative_patterns.Grid::new(
    Hexagonal,
    800.0,
    800.0,
    12,
    12,
    45.0,
  )
  let cells = grid.generate_cells()

  // Create our pseudo-noise sampler
  let sampler = @generative_patterns.TrigNoise::new(0.05)

  for cell in cells {
    // Warp the center coordinates of the cell using noise domain warping
    let (wx, wy) = @generative_patterns.warp_point(
      sampler,
      cell.x,
      cell.y,
      15.0,
      0.08,
    )

    // Modulate circle radius using noise value
    let noise_val = sampler.sample_2d(cell.x, cell.y)
    let radius = 10.0 + (noise_val + 1.0) * 12.0

    let path = @generative_patterns.Path::circle(radius, cx=wx, cy=wy)
    let style = @generative_patterns.SvgStyle::new(
      fill="none",
      stroke="teal",
      stroke_width=1.0 + noise_val.abs() * 2.0,
      opacity=0.7,
    )

    doc.add(@generative_patterns.SvgElement::SvgPath(path, style))
  }

  doc.to_svg_string()
}

///|
fn main {
  println("====================================================")
  println("   MoonBit Generative Pattern Showcase Generator    ")
  println("====================================================")
  println("Generating patterns...")

  let poster_svg = generate_poster_pattern()
  let wallpaper_svg = generate_wallpaper_pattern()
  let organic_svg = generate_organic_pattern()

  println("Patterns successfully generated programmatically!")
  println("Poster Pattern:    \{poster_svg.length()} chars of SVG data.")
  println("Wallpaper Pattern: \{wallpaper_svg.length()} chars of SVG data.")
  println("Organic Pattern:   \{organic_svg.length()} chars of SVG data.")
  let scene_benchmark = @generative_patterns.benchmark_scene(
    3, 320.0, 320.0, 12, 12,
  )
  let noise_benchmark = @generative_patterns.benchmark_noise(200, 4096)
  let pipeline_benchmark = @generative_patterns.benchmark_pipeline(
    3, 320.0, 320.0,
  )
  let production_benchmark = @generative_patterns.benchmark_production_suite(
    2, 128, 128,
  )
  println("Benchmark (deterministic, scenes + noise + export pipeline):")
  println(
    @generative_patterns.benchmark_report_full(
      scene_benchmark, noise_benchmark, pipeline_benchmark, production_benchmark,
    ),
  )
  println("====================================================")
  println("Run standard output redirection to export files:")
  println("  moon run cmd/main > output.svg (prints stdout)")
}