// 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/material.dart';
import 'package:perfect_freehand/perfect_freehand.dart' as pf;

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.
Path buildStrokePath(PenStroke stroke, Size pageSize, {required bool isComplete}) {
  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.Point(
          p.x * pageSize.width,
          p.y * pageSize.height,
          p.pressure ?? 0.5,
        ),
      )
      .toList();

  final outline = pf.getStroke(
    pfPoints,
    size: pixelWidth,
    // Highlighter keeps a constant width (no thinning); pen thins like the
    // existing ink_canvas (_drawFreehand uses 0.7).
    thinning: isHighlighter ? 0.0 : 0.7,
    smoothing: 0.5,
    streamline: 0.5,
    // Real stylus pressure → don't simulate; no pressure → let freehand fake
    // it based on velocity (matches ink_canvas behavior).
    simulatePressure: !hasRealPressure && !isHighlighter,
    isComplete: isComplete,
  );

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

/// 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});

  final List<PenStroke> strokes;
  final Size pageSize;

  @override
  void paint(Canvas canvas, Size size) {
    for (final stroke in strokes) {
      final path = buildStrokePath(stroke, pageSize, isComplete: true);
      if (path.getBounds().isEmpty) continue;
      canvas.drawPath(
        path,
        Paint()
          ..color = Color(stroke.color)
          ..style = PaintingStyle.fill
          ..isAntiAlias = true,
      );
    }
  }

  @override
  bool shouldRepaint(StaticInkPainter old) =>
      !identical(old.strokes, strokes) ||
      old.strokes.length != strokes.length ||
      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});

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

  @override
  void paint(Canvas canvas, Size size) {
    final s = stroke;
    if (s == null || s.points.isEmpty) return;
    final path = buildStrokePath(s, pageSize, isComplete: false);
    if (path.getBounds().isEmpty) return;
    canvas.drawPath(
      path,
      Paint()
        ..color = Color(s.color)
        ..style = PaintingStyle.fill
        ..isAntiAlias = true,
    );
  }

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