BadNote/lib/editor/canvas/ink_painters.dart

// lib/editor/canvas/ink_painters.dart
//
// CustomPainters for the ink layers. Strokes are stored in normalized page
// coordinates; both painters receive the on-screen page [Size] and scale
// points into pixels at paint time. perfect_freehand produces the outline.

import 'package:flutter/foundation.dart';
import 'package:flutter/material.dart';
import 'package:perfect_freehand/perfect_freehand.dart' as pf;

import '../engine/brush.dart';
import '../engine/stroke_geometry.dart'
    show freehandOutlinePoints, kDefaultPenThinning;
import 'pen_stroke.dart';

/// Builds a filled outline [Path] for one stroke (already scaled to pixels).
///
/// [pageSize] maps normalized coords to pixels. [isComplete] should be false
/// for the in-progress live stroke so freehand tapers correctly. [thinning] is
/// the pressure→width response (shared default [kDefaultPenThinning]); the
/// SAME value drives the export path so screen and PDF never diverge.
Path buildStrokePath(
  PenStroke stroke,
  Size pageSize, {
  required bool isComplete,
  double thinning = kDefaultPenThinning,
}) {
  final pixelWidth = stroke.width * pageSize.width;

  final hasRealPressure = stroke.points.any((p) => p.pressure != null);
  final isHighlighter = stroke.kind == PenStrokeKind.highlighter;

  final pfPoints = stroke.points
      .map(
        (p) => pf.PointVector(
          p.x * pageSize.width,
          p.y * pageSize.height,
          p.pressure ?? 0.5,
        ),
      )
      .toList();

  // Route through THE shared recipe (stroke_geometry.freehandOutlinePoints) so
  // this PDF-overlay path and the note/slide path can never diverge (R7), and
  // resolve the stroke's brush so each brush renders with its own
  // thinning/streamline/smoothing/caps (spec §4). Pressure was already
  // pre-warped by the brush's gamma at capture, so it is baked into pfPoints.
  final outline = freehandOutlinePoints(
    pfPoints: pfPoints,
    size: pixelWidth,
    isHighlighter: isHighlighter,
    hasRealPressure: hasRealPressure,
    isComplete: isComplete,
    thinning: thinning,
    brush: brushProfileFor(stroke.brush),
  );

  final path = Path();
  if (outline.isEmpty) return path;
  path.moveTo(outline.first.dx, outline.first.dy);
  for (var i = 1; i < outline.length; i++) {
    path.lineTo(outline[i].dx, outline[i].dy);
  }
  path.close();
  return path;
}

/// Mean point pressure (`pressure ?? 0.5`) of a [PenStroke], for the per-stroke
/// opacity resolution (spec §3/§4 tie ballpoint/pencil opacity to pressure).
double _avgPressure(PenStroke stroke) {
  if (stroke.points.isEmpty) return 0.5;
  var sum = 0.0;
  for (final p in stroke.points) {
    sum += p.pressure ?? 0.5;
  }
  return sum / stroke.points.length;
}

/// THE single fill [Paint] for a committed/live stroke, with the brush's
/// resolved opacity (multiplied into the color's alpha) and blend mode applied
/// — closes TODO(brush-opacity). Shared by [StaticInkPainter]/[LiveInkPainter]
/// and the PDF overlay painter so both render paths composite identically.
Paint paintForStroke(PenStroke stroke) {
  final resolved = resolveStrokePaint(
    stroke.brush,
    stroke.color,
    pressureAvg: _avgPressure(stroke),
  );
  return Paint()
    ..color = resolved.color
    ..blendMode = resolved.blendMode
    ..style = PaintingStyle.fill
    ..isAntiAlias = true;
}

/// Paints all committed strokes for the page. Repaints only when the stroke
/// list identity or page size changes (kept behind a RepaintBoundary).
class StaticInkPainter extends CustomPainter {
  StaticInkPainter({
    required this.strokes,
    required this.pageSize,
    this.thinning = kDefaultPenThinning,
  });

  final List<PenStroke> strokes;
  final Size pageSize;

  /// Pressure→width response shared with the live/export paths.
  final double thinning;

  @override
  void paint(Canvas canvas, Size size) {
    for (final stroke in strokes) {
      final path =
          buildStrokePath(stroke, pageSize, isComplete: true, thinning: thinning);
      if (path.getBounds().isEmpty) continue;
      // Single drawPath per stroke ⇒ a highlighter's own self-overlap never
      // darkens; cross-stroke overlap darkens via BlendMode.multiply (marker).
      canvas.drawPath(path, paintForStroke(stroke));
    }
  }

  @override
  bool shouldRepaint(StaticInkPainter old) =>
      !identical(old.strokes, strokes) ||
      old.strokes.length != strokes.length ||
      old.pageSize != pageSize ||
      old.thinning != thinning;
}

/// Eraser preview: shows the eraser circle and faintly highlights the committed
/// strokes the eraser would delete, so the user can see what is about to go.
/// Mounted only while the eraser is the active mode and the pen is near the
/// page; kept behind its own RepaintBoundary so it never dirties the ink layers.
class EraserPreviewPainter extends CustomPainter {
  EraserPreviewPainter({
    required this.strokes,
    required this.cursor,
    required this.radius,
    required this.aspect,
    required this.pageSize,
  }) : super(repaint: cursor);

  final List<PenStroke> strokes;

  /// Eraser center in normalized page coords (null = no preview). A listenable
  /// so the painter repaints on cursor moves WITHOUT rebuilding the canvas.
  final ValueListenable<PenPoint?> cursor;

  /// Eraser radius as a fraction of page width (matches the live erase test).
  final double radius;

  /// Page aspect (height / width) so the on-screen circle stays round.
  final double aspect;

  final Size pageSize;

  @override
  void paint(Canvas canvas, Size size) {
    final c = cursor.value;
    if (c == null) return;

    // CHEAP, ACCURATE highlight: trace ONLY the point-runs inside the eraser
    // radius — i.e. exactly what splitStrokeByCircle will remove — as a plain
    // polyline (no perfect_freehand getStroke; that was the eraser lag source).
    // So what turns red is exactly what gets deleted.
    final r2 = radius * radius;
    final highlight = Paint()
      ..color = const Color(0xFFFF5252).withValues(alpha: 0.85)
      ..style = PaintingStyle.stroke
      ..strokeWidth = 3.0
      ..strokeCap = StrokeCap.round
      ..strokeJoin = StrokeJoin.round
      ..isAntiAlias = true;
    for (final stroke in strokes) {
      Path? run;
      void flush() {
        if (run != null) {
          canvas.drawPath(run!, highlight);
          run = null;
        }
      }

      for (final pt in stroke.points) {
        final dx = pt.x - c.x;
        final dy = (pt.y - c.y) * aspect;
        if (dx * dx + dy * dy < r2) {
          final o = Offset(pt.x * pageSize.width, pt.y * pageSize.height);
          (run ??= Path()..moveTo(o.dx, o.dy)).lineTo(o.dx, o.dy);
        } else {
          flush();
        }
      }
      flush();
    }

    // The eraser circle itself (radius is a page-width fraction → px = r * w).
    final center = Offset(c.x * pageSize.width, c.y * pageSize.height);
    final rPx = radius * pageSize.width;
    canvas.drawCircle(
      center,
      rPx,
      Paint()
        ..color = const Color(0xFF757575).withValues(alpha: 0.7)
        ..style = PaintingStyle.stroke
        ..strokeWidth = 1.0
        ..isAntiAlias = true,
    );
    canvas.drawCircle(
      center,
      rPx,
      Paint()..color = const Color(0x14000000),
    );
  }

  @override
  bool shouldRepaint(EraserPreviewPainter old) =>
      !identical(old.cursor, cursor) ||
      old.radius != radius ||
      old.aspect != aspect ||
      !identical(old.strokes, strokes) ||
      old.strokes.length != strokes.length ||
      old.pageSize != pageSize;
}

/// Paints the SELECT tool's selection: a dashed-ish bounding box around the
/// selected stroke(s) so the user sees what is selected and draggable. The box
/// is given in normalized page coords and scaled to pixels at paint time.
class SelectionOverlayPainter extends CustomPainter {
  SelectionOverlayPainter({
    required this.boundsNorm,
    required this.pageSize,
  });

  /// Selection bounding box in normalized page coords (null = nothing selected).
  final Rect? boundsNorm;
  final Size pageSize;

  @override
  void paint(Canvas canvas, Size size) {
    final b = boundsNorm;
    if (b == null) return;
    // Inflate slightly so the box doesn't clip the stroke's rendered width.
    const padPx = 6.0;
    final rect = Rect.fromLTRB(
      b.left * pageSize.width - padPx,
      b.top * pageSize.height - padPx,
      b.right * pageSize.width + padPx,
      b.bottom * pageSize.height + padPx,
    );
    canvas.drawRRect(
      RRect.fromRectAndRadius(rect, const Radius.circular(4)),
      Paint()
        ..color = const Color(0xFF2962FF).withValues(alpha: 0.12)
        ..style = PaintingStyle.fill,
    );
    canvas.drawRRect(
      RRect.fromRectAndRadius(rect, const Radius.circular(4)),
      Paint()
        ..color = const Color(0xFF2962FF)
        ..style = PaintingStyle.stroke
        ..strokeWidth = 1.5
        ..isAntiAlias = true,
    );
  }

  @override
  bool shouldRepaint(SelectionOverlayPainter old) =>
      old.boundsNorm != boundsNorm || old.pageSize != pageSize;
}

/// Paints just the in-progress stroke (the live layer), kept behind its own
/// RepaintBoundary so committed strokes don't repaint on every move.
class LiveInkPainter extends CustomPainter {
  LiveInkPainter({
    required this.stroke,
    required this.pageSize,
    this.thinning = kDefaultPenThinning,
  });

  /// Current in-progress stroke, or null when nothing is being drawn.
  final PenStroke? stroke;
  final Size pageSize;

  /// Pressure→width response shared with the static/export paths.
  final double thinning;

  @override
  void paint(Canvas canvas, Size size) {
    final s = stroke;
    if (s == null || s.points.isEmpty) return;
    final path =
        buildStrokePath(s, pageSize, isComplete: false, thinning: thinning);
    if (path.getBounds().isEmpty) return;
    canvas.drawPath(path, paintForStroke(s));
  }

  @override
  bool shouldRepaint(LiveInkPainter old) =>
      !identical(old.stroke, stroke) ||
      old.pageSize != pageSize ||
      old.thinning != thinning;
}