ponshu-room-lite/lib/screens/camera_screen.dart

import 'dart:async'; // Timer
import 'dart:io'; // For File class
import 'package:camera/camera.dart';
import 'package:flutter/material.dart';
import 'package:flutter_riverpod/flutter_riverpod.dart';
import 'package:hive_flutter/hive_flutter.dart';
import 'package:path/path.dart' show join;
import 'package:path_provider/path_provider.dart';
import 'package:uuid/uuid.dart';
import 'package:gal/gal.dart';

import '../services/gemini_service.dart';
import '../services/image_compression_service.dart'; // Phase 4 Added
import '../widgets/analyzing_dialog.dart';
import '../models/sake_item.dart';
import '../theme/app_theme.dart';
import 'package:lucide_icons/lucide_icons.dart';
import 'package:image_picker/image_picker.dart'; // Gallery & Camera
import '../providers/theme_provider.dart'; // userProfileProvider


enum CameraMode {
  createItem,
  returnPath,
}

class CameraScreen extends ConsumerStatefulWidget {
  final CameraMode mode;
  const CameraScreen({super.key, this.mode = CameraMode.createItem});

  @override
  ConsumerState<CameraScreen> createState() => _CameraScreenState();
}

class _CameraScreenState extends ConsumerState<CameraScreen> with SingleTickerProviderStateMixin, WidgetsBindingObserver {
  CameraController? _controller;
  Future<void>? _initializeControllerFuture;
  bool _isTakingPicture = false;
  DateTime? _quotaLockoutTime;
  
  // Phase 3-B: Focus & Zoom
  double _minZoom = 1.0;
  double _maxZoom = 1.0;
  double _currentZoom = 1.0;
  double _baseScale = 1.0; // For pinch reference
  
  // Phase 3-B2: Exposure
  double _minExposure = 0.0;
  double _maxExposure = 0.0;
  double _currentExposureOffset = 0.0;
  
  Offset? _focusPoint;
  bool _showFocusRing = false;
  Timer? _focusRingTimer;
  DateTime? _lastExposureUpdate; // Throttling state

  @override
  void initState() {
    super.initState();
    _initializeCamera();
  }

  Future<void> _initializeCamera() async {
    final cameras = await availableCameras();
    final firstCamera = cameras.first;

    _controller = CameraController(
      firstCamera,
      ResolutionPreset.high, 
      enableAudio: false,
      imageFormatGroup: ImageFormatGroup.jpeg,
    );

    _initializeControllerFuture = _controller!.initialize().then((_) async {
       if (!mounted) return;
       // [Phase 3-B] Get Zoom Range
       _minZoom = await _controller!.getMinZoomLevel();
       _maxZoom = await _controller!.getMaxZoomLevel();
       // [Phase 3-B2] Get Exposure Range
       _minExposure = await _controller!.getMinExposureOffset();
       _maxExposure = await _controller!.getMaxExposureOffset();
       
       // [Phase 3-B] Set Auto Focus Mode
       await _controller!.setFocusMode(FocusMode.auto);
       setState(() {});
    });
  }

  @override
  void dispose() {
    _controller?.dispose();
    _focusRingTimer?.cancel();
    super.dispose();
  }

  // ... (Keep existing methods: _capturedImages, _takePicture, _analyzeImages)

  double? _pendingExposureValue;
  bool _isUpdatingExposure = false;

  Future<void> _setExposureSafe(double value) async {
    _pendingExposureValue = value;
    if (_isUpdatingExposure) return;

    _isUpdatingExposure = true;
    while (_pendingExposureValue != null) {
      final valueToSet = _pendingExposureValue!;
      _pendingExposureValue = null;
      try {
        if (_controller != null && _controller!.value.isInitialized) {
          await _controller!.setExposureOffset(valueToSet);
        }
      } catch (e) {
        debugPrint('Exposure update error: $e');
      }
    }
    _isUpdatingExposure = false;
  }

  void _onTapFocus(TapUpDetails details, BoxConstraints constraints) async {
    if (_controller == null || !_controller!.value.isInitialized) return;

    // Normalizing coordinates (0.0 - 1.0)
    final offset = Offset(
      details.localPosition.dx / constraints.maxWidth,
      details.localPosition.dy / constraints.maxHeight,
    );

    try {
      await _controller!.setFocusPoint(offset);
      await _controller!.setFocusMode(FocusMode.auto); 
    } catch (e) {
      // Some devices might not support focus point
      debugPrint('Focus failed: $e');
    }

    if (!mounted) return;

    setState(() {
      _focusPoint = details.localPosition;
      _showFocusRing = true;
    });

    _focusRingTimer?.cancel();
    _focusRingTimer = Timer(const Duration(milliseconds: 1000), () {
      if (mounted) setState(() => _showFocusRing = false);
    });
  }

  void _onScaleStart(ScaleStartDetails details) {
    _baseScale = _currentZoom;
  }

  Future<void> _onScaleUpdate(ScaleUpdateDetails details) async {
    if (_controller == null || !_controller!.value.isInitialized) return;

    // Calculate new zoom level
    final newZoom = (_baseScale * details.scale).clamp(_minZoom, _maxZoom);
    
    // Optimize: 0.1 increments (Prevent jitter)
    if ((newZoom - _currentZoom).abs() < 0.1) return;

    try {
      await _controller!.setZoomLevel(newZoom);
      setState(() => _currentZoom = newZoom);
    } catch (e) {
      debugPrint('Zoom failed: $e');
    }
  }

  final List<String> _capturedImages = [];

  Future<void> _takePicture() async {
    // Check Quota Lockout
    if (_quotaLockoutTime != null) {
      final remaining = _quotaLockoutTime!.difference(DateTime.now());
      if (remaining.isNegative) {
        setState(() => _quotaLockoutTime = null); // Reset
      } else {
        ScaffoldMessenger.of(context).showSnackBar(
          SnackBar(content: Text('AI利用制限中です。あと${remaining.inSeconds}秒お待ちください。')),
        );
        return;
      }
    }

    if (_isTakingPicture || _controller == null || !_controller!.value.isInitialized) {
      return;
    }

    setState(() {
      _isTakingPicture = true;
    });

    try {
      await _initializeControllerFuture;
      final image = await _controller!.takePicture();

      // Save image locally (App Sandbox)
      final directory = await getApplicationDocumentsDirectory();
      // Phase 4 Improvement: Apply Compression (Target Max 1MB)
      // 1. Save temp raw file
      final tempPath = join(directory.path, '${const Uuid().v4()}_temp.jpg');
      await image.saveTo(tempPath);

      // 2. Compress to final path
      final finalPath = join(directory.path, '${const Uuid().v4()}.jpg');
      final compressedPath = await ImageCompressionService.compressForGemini(tempPath, targetPath: finalPath);

      // 3. Clean up temp file
      try {
        await File(tempPath).delete();
      } catch (e) {
        debugPrint('Warning: Failed to delete temp file: $e');
      }

      final imagePath = compressedPath;

      // Save to Gallery (Public) - Phase 4: Data Safety
      try {
        await Gal.putImage(imagePath);
        debugPrint('Saved to Gallery: $imagePath');
      } catch (e) {
         debugPrint('Gallery Save Error: $e');
         // Don't block flow, but maybe notify?
         if (mounted) {
            ScaffoldMessenger.of(context).showSnackBar(
              SnackBar(content: Text('ギャラリー保存に失敗しました: $e'), duration: const Duration(seconds: 1)),
            );
         }
      }

      if (!mounted) return;
      
      _handleCapturedImage(imagePath);


    } catch (e) {
      debugPrint('Capture Error: $e');
    } finally {
      if (mounted) {
        setState(() {
          _isTakingPicture = false;
        });
      }
    }
  }



  Future<void> _pickFromGallery() async {
    final picker = ImagePicker();
    // Use standard image_picker (Updated to 1.1.2 for Android 13+)
    final List<XFile> images = await picker.pickMultiImage();

    if (images.isNotEmpty && mounted) {
      // IF RETURN PATH Mode (Only supports one)
      if (widget.mode == CameraMode.returnPath) {
        Navigator.of(context).pop(images.first.path);
        return;
      }

      setState(() {
         for (var img in images) {
           _capturedImages.add(img.path);
         }
      });
      
      // Batch handle - Notification only
      if (mounted) {
        ScaffoldMessenger.of(context).showSnackBar(
          SnackBar(
            content: Text('${images.length}枚の画像を読み込みました。\n右下のボタンから解析を開始してください。'),
            duration: const Duration(seconds: 3),
            action: SnackBarAction(
              label: '解析する',
              onPressed: _analyzeImages,
              textColor: Colors.yellow,
            ),
          ),
        );
      }
    }
  }

  Future<void> _handleCapturedImage(String imagePath, {bool fromGallery = false}) async {
      // IF RETURN PATH Mode
      if (widget.mode == CameraMode.returnPath) {
        Navigator.of(context).pop(imagePath);
        return;
      }

      setState(() {
         _capturedImages.add(imagePath);
      });

      // Show Confirmation Dialog
      await showDialog(
        context: context,
        barrierDismissible: false,
        builder: (ctx) => AlertDialog(
          title: Text(fromGallery ? '画像を読み込みました' : '写真を保存しました'),
          content: const Text('さらに別の面も撮影・追加すると、\nAI解析の精度がアップします！'),
          actions: [
            OutlinedButton(
              onPressed: () {
                // Start Analysis
                Navigator.of(context).pop();
                _analyzeImages();
              },
              child: const Text('解析開始'),
            ),
            FilledButton(
              onPressed: () {
                // Return to capture (Dismiss dialog)
                Navigator.of(context).pop();
              },
              style: FilledButton.styleFrom(
                backgroundColor: AppTheme.posimaiBlue,
                foregroundColor: Colors.white,
              ),
              child: const Text('さらに追加'),
            ),
          ],
        ),
      );
  }

  Future<void> _analyzeImages() async {
      if (_capturedImages.isEmpty) return;

      // Show AnalyzingDialog
      showDialog(
        context: context,
        barrierDismissible: false,
        builder: (context) => const AnalyzingDialog(),
      );

    try {
      // Direct Gemini Vision Analysis (OCR removed for app size reduction)
      debugPrint('📸 Starting Gemini Vision Direct Analysis for ${_capturedImages.length} images');
      final geminiService = GeminiService();
      final result = await geminiService.analyzeSakeLabel(_capturedImages);

      // Create SakeItem (Schema v2.0)
      final sakeItem = SakeItem(
        id: const Uuid().v4(),
        displayData: DisplayData(
          name: result.name ?? '不明な日本酒',
          brewery: result.brand ?? '不明',
          prefecture: result.prefecture ?? '不明',
          catchCopy: result.catchCopy,
          imagePaths: List.from(_capturedImages),
          rating: null,
        ),
        hiddenSpecs: HiddenSpecs(
          description: result.description,
          tasteStats: result.tasteStats,
          flavorTags: result.flavorTags,
        ),
        metadata: Metadata(
          createdAt: DateTime.now(),
          aiConfidence: result.confidenceScore,
        ),
      );

      // Save to Hive
      final box = Hive.box<SakeItem>('sake_items');
      await box.add(sakeItem);

      // Prepend new item to sort order so it appears at the top
      final settingsBox = Hive.box('settings');
      final List<String> currentOrder = (settingsBox.get('sake_sort_order') as List<dynamic>?)
          ?.cast<String>() ?? [];
      currentOrder.insert(0, sakeItem.id); // Insert at beginning
      await settingsBox.put('sake_sort_order', currentOrder);

      // --- v1.3 Gamification Hook ---
      // Award EXP
      final userProfileState = ref.read(userProfileProvider);
      final prevLevel = userProfileState.level;
      
      await ref.read(userProfileProvider.notifier).updateTotalExp(userProfileState.totalExp + 10);
      
      // Refetch updated state for level comparison
      final updatedProfile = ref.read(userProfileProvider);
      final newLevel = updatedProfile.level;
      final isLevelUp = newLevel > prevLevel;

      // Debug: Verify save
      debugPrint('✅ Saved to Hive: ${sakeItem.displayData.name} (ID: ${sakeItem.id})');
      debugPrint('📦 Total items in box: ${box.length}');
      debugPrint('📦 Prepended to sort order (now ${currentOrder.length} items)');
      debugPrint('🎮 Gamification: EXP +10 (Total: ${updatedProfile.totalExp}) Level: $prevLevel -> $newLevel');

      if (!mounted) return;

      // Close Dialog
      Navigator.of(context).pop();

      // Close Camera Screen (Return to Home)
      Navigator.of(context).pop();

      // Success Message (with EXP/Level Up info)
      ScaffoldMessenger.of(context).showSnackBar(
        SnackBar(
          content: Column(
            mainAxisSize: MainAxisSize.min,
            crossAxisAlignment: CrossAxisAlignment.start,
            children: [
              Text('${sakeItem.displayData.name} を登録しました！'),
              const SizedBox(height: 4),
              Row(
                children: [
                  const Icon(LucideIcons.sparkles, color: Colors.yellow, size: 16),
                  const SizedBox(width: 8),
                  Text(
                    '経験値 +10 GET! ${isLevelUp ? " (Level UP!)" : ""}',
                     style: const TextStyle(fontWeight: FontWeight.bold, color: Colors.yellowAccent),
                  ),
                ],
              ),
            ],
          ),
          duration: const Duration(seconds: 4), // Longer display for level up
        ),
      );

    } catch (e) {
      if (mounted) {
        Navigator.of(context).pop(); // Close AnalyzingDialog
        
        // Check for Quota Error to set Lockout
        if (e.toString().contains('Quota') || e.toString().contains('429')) {
             setState(() {
               _quotaLockoutTime = DateTime.now().add(const Duration(minutes: 1));
             });
        }

        ScaffoldMessenger.of(context).showSnackBar(
          SnackBar(content: Text('解析エラー: $e')),
        );
      }
    }
  }

  @override
  Widget build(BuildContext context) {
    return Scaffold(
      backgroundColor: Colors.black,
      body: FutureBuilder<void>(
        future: _initializeControllerFuture,
        builder: (context, snapshot) {
          if (snapshot.connectionState == ConnectionState.done) {
            // Camera Preview with Focus/Zoom
            return Stack(
              fit: StackFit.expand,
              children: [
                LayoutBuilder(
                  builder: (context, constraints) {
                    return GestureDetector(
                      onScaleStart: _onScaleStart,
                      onScaleUpdate: _onScaleUpdate,
                      onTapUp: (details) => _onTapFocus(details, constraints),
                      child: CameraPreview(_controller!),
                    );
                  }
                ),
                
                // Focus Ring Overlay
                if (_showFocusRing && _focusPoint != null)
                  Positioned(
                    left: _focusPoint!.dx - 40,
                    top: _focusPoint!.dy - 40,
                    child: Container(
                      width: 80,
                      height: 80,
                      decoration: BoxDecoration(
                        border: Border.all(color: Colors.yellow, width: 2),
                        borderRadius: BorderRadius.circular(40),
                      ),
                    ),
                  ),

                // Instagram-style Exposure Slider (REBUILT - No LayoutBuilder+Positioned)
                Positioned(
                  right: 0,
                  top: MediaQuery.of(context).size.height * 0.25,
                  child: GestureDetector(
                    behavior: HitTestBehavior.opaque,
                    onVerticalDragUpdate: (details) async {
                      // Throttling (30ms)
                      final now = DateTime.now();
                      if (_lastExposureUpdate != null && now.difference(_lastExposureUpdate!).inMilliseconds < 30) {
                        return;
                      }

                      // Drag Up = Brighter (+), Down = Darker (-)
                      final sensitivity = 0.12; // Perfect finger tracking!
                      final delta = -details.delta.dy * sensitivity;

                      if (_controller == null || !_controller!.value.isInitialized) return;

                      final newValue = (_currentExposureOffset + delta).clamp(_minExposure, _maxExposure);

                      // Debug: Check actual value changes
                      debugPrint('Exposure Update: delta=${delta.toStringAsFixed(3)}, old=${_currentExposureOffset.toStringAsFixed(2)}, new=${newValue.toStringAsFixed(2)}, range=$_minExposure~$_maxExposure');

                      // UI immediate update
                      setState(() => _currentExposureOffset = newValue);
                      // Async camera update
                      _setExposureSafe(newValue);

                      _lastExposureUpdate = now;
                    },
                    onVerticalDragEnd: (details) {
                      // Finalize value on drag end
                       _setExposureSafe(_currentExposureOffset);
                    },
                    onDoubleTap: () async {
                      // Reset
                      if (_controller == null) return;
                      setState(() => _currentExposureOffset = 0.0);
                      _setExposureSafe(0.0);
                    },
                    child: Container(
                      width: 80, // Wide touch area
                      padding: const EdgeInsets.symmetric(horizontal: 16, vertical: 20),
                      child: Column(
                        mainAxisSize: MainAxisSize.min,
                        children: [
                          // Sun Icon (Bright)
                          Icon(LucideIcons.sun, color: _currentExposureOffset > 0.5 ? Colors.yellow : Colors.white54, size: 24),
                          const SizedBox(height: 8),

                          // Vertical Track with Knob (NO LayoutBuilder)
                          SizedBox(
                            height: 180,
                            width: 48, // Wider for easier tapping
                            child: CustomPaint(
                              key: ValueKey(_currentExposureOffset), // Force repaint on value change
                              painter: _ExposureSliderPainter(
                                currentValue: _currentExposureOffset,
                                minValue: _minExposure,
                                maxValue: _maxExposure,
                              ),
                            ),
                          ),
                          const SizedBox(height: 8),

                          // Moon Icon (Dark)
                          Icon(LucideIcons.moon, color: _currentExposureOffset < -0.5 ? Colors.blue[200] : Colors.white54, size: 20),

                          // Value Text
                          if (_currentExposureOffset.abs() > 0.1)
                            Padding(
                              padding: const EdgeInsets.only(top: 4),
                              child: Text(
                                _currentExposureOffset > 0 ? '+${_currentExposureOffset.toStringAsFixed(1)}' : _currentExposureOffset.toStringAsFixed(1),
                                style: const TextStyle(color: Colors.white, fontSize: 12, fontWeight: FontWeight.bold, shadows: [Shadow(color: Colors.black, blurRadius: 2)]),
                              ),
                            ),
                        ],
                      ),
                    ),
                  ),
                ),

                // Overlay UI
                SafeArea(
                  child: Column(
                    mainAxisAlignment: MainAxisAlignment.spaceBetween,
                    children: [
                      // Top Bar
                      Padding(
                        padding: const EdgeInsets.all(8.0),
                        child: Row(
                          mainAxisAlignment: MainAxisAlignment.spaceBetween,
                          children: [
                            IconButton(
                              icon: const Icon(LucideIcons.x, color: Colors.white, size: 32),
                              onPressed: () => Navigator.of(context).pop(),
                            ),
                            // iOS-style Zoom Buttons
                             Container(
                               padding: const EdgeInsets.symmetric(horizontal: 8, vertical: 6),
                               decoration: BoxDecoration(
                                 color: Colors.black.withValues(alpha: 0.6),
                                 borderRadius: BorderRadius.circular(20),
                                 border: Border.all(color: Colors.white.withValues(alpha: 0.3), width: 1),
                               ),
                               child: Row(
                                 mainAxisSize: MainAxisSize.min,
                                 children: [
                                   _buildZoomButton('1.0', 1.0),
                                   const SizedBox(width: 8),
                                   _buildZoomButton('2.0', 2.0),
                                   const SizedBox(width: 8),
                                   _buildZoomButton('3.0', 3.0),
                                 ],
                               ),
                             ),
                          ],
                        ),
                      ),
                      // Bottom Control Area
                      Padding(
                        padding: const EdgeInsets.only(bottom: 32.0, left: 24, right: 24),
                        child: Row(
                          mainAxisAlignment: MainAxisAlignment.spaceEvenly,
                          crossAxisAlignment: CrossAxisAlignment.center,
                          children: [
                            // Gallery Button (Left)
                            IconButton(
                              icon: const Icon(LucideIcons.image, color: Colors.white, size: 32),
                              onPressed: _pickFromGallery,
                              tooltip: 'ギャラリーから選択',
                            ),
                            
                            // Shutter Button (Center)
                            GestureDetector(
                              onTap: _takePicture,
                              child: Container(
                                height: 80,
                                width: 80,
                                decoration: BoxDecoration(
                                  shape: BoxShape.circle,
                                  border: Border.all(
                                    color: _quotaLockoutTime != null ? Colors.red : Colors.white, 
                                    width: 4
                                  ),
                                  color: _isTakingPicture 
                                    ? Colors.white.withValues(alpha: 0.5) 
                                    : (_quotaLockoutTime != null ? Colors.red.withValues(alpha: 0.2) : Colors.transparent),
                                ),
                                child: Center(
                                  child: _quotaLockoutTime != null
                                    ? const Icon(LucideIcons.timer, color: Colors.white, size: 30)
                                    : Container(
                                        height: 60,
                                        width: 60,
                                        decoration: BoxDecoration(
                                          shape: BoxShape.circle,
                                          color: _quotaLockoutTime != null ? Colors.grey : Colors.white,
                                        ),
                                      ),
                                ),
                              ),
                            ),
                            
                            // Right Spacer -> Analyze Button if images exist
                            if (_capturedImages.isNotEmpty)
                              IconButton(
                                icon: Badge(
                                  label: Text('${_capturedImages.length}'),
                                  child: const Icon(LucideIcons.playCircle, color: Colors.greenAccent, size: 40),
                                ),
                                onPressed: _analyzeImages,
                                tooltip: '解析を開始',
                              )
                            else
                              const SizedBox(width: 48), 
                          ],
                        ),
                      ),
                    ],
                  ),
                ),
                if (_isTakingPicture)
                  Container(
                    color: Colors.black.withValues(alpha: 0.5),
                    child: const Center(
                      child: CircularProgressIndicator(),
                    ),
                  ),
              ],
            );
          } else {
            return const Center(child: CircularProgressIndicator());
          }
        },
      ),
    );
  }

  Widget _buildZoomButton(String label, double zoom) {
    // Current Zoom Logic: Highlight if close
    final isActive = (_currentZoom - zoom).abs() < 0.3;

    return GestureDetector(
      onTap: () async {
        if (_controller == null || !_controller!.value.isInitialized) return;
        final targetZoom = zoom.clamp(_minZoom, _maxZoom);

        try {
          await _controller!.setZoomLevel(targetZoom);
          setState(() => _currentZoom = targetZoom);
        } catch (e) {
          debugPrint('Zoom error: $e');
        }
      },
      child: Container(
        padding: const EdgeInsets.symmetric(horizontal: 12, vertical: 6),
        decoration: BoxDecoration(
          color: isActive ? Colors.white : Colors.transparent,
          borderRadius: BorderRadius.circular(16),
        ),
        child: Text(
          label,
          style: TextStyle(
            color: isActive ? Colors.black : Colors.white,
            fontSize: 14,
            fontWeight: isActive ? FontWeight.bold : FontWeight.normal,
          ),
        ),
      ),
    );
  }
}

// Custom Painter for Exposure Slider
class _ExposureSliderPainter extends CustomPainter {
  final double currentValue;
  final double minValue;
  final double maxValue;

  _ExposureSliderPainter({
    required this.currentValue,
    required this.minValue,
    required this.maxValue,
  });

  @override
  void paint(Canvas canvas, Size size) {
    final trackPaint = Paint()
      ..color = Colors.white.withValues(alpha: 0.3)
      ..strokeWidth = 4
      ..strokeCap = StrokeCap.round;

    final centerLinePaint = Paint()
      ..color = Colors.white54
      ..strokeWidth = 2;

    final knobPaint = Paint()
      ..color = Colors.white
      ..style = PaintingStyle.fill;

    final knobShadowPaint = Paint()
      ..color = Colors.black26
      ..maskFilter = const MaskFilter.blur(BlurStyle.normal, 4);

    // Draw vertical track (centered)
    final trackX = size.width / 2;
    canvas.drawLine(
      Offset(trackX, 10),
      Offset(trackX, size.height - 10),
      trackPaint,
    );

    // Draw center marker
    canvas.drawLine(
      Offset(trackX - 6, size.height / 2),
      Offset(trackX + 6, size.height / 2),
      centerLinePaint,
    );

    // Calculate knob position
    final range = maxValue - minValue;
    if (range > 0) {
      // Normalize currentValue to 0.0-1.0 range
      // minValue (e.g., -4.0) -> 0.0 (bottom)
      // 0.0 (center) -> 0.5 (middle)
      // maxValue (e.g., +4.0) -> 1.0 (top)
      final normalized = (currentValue - minValue) / range;

      // Debug
      debugPrint('CustomPainter: value=$currentValue, min=$minValue, max=$maxValue, range=$range, normalized=${normalized.toStringAsFixed(3)}');

      // Map to Y coordinate: 0.0 (normalized) -> bottom, 1.0 (normalized) -> top
      final knobY = (size.height - 20) * (1.0 - normalized) + 10;

      debugPrint('  -> knobY=${knobY.toStringAsFixed(1)} (height=${size.height})');

      // Draw knob shadow
      canvas.drawCircle(Offset(trackX, knobY), 7, knobShadowPaint);
      // Draw knob
      canvas.drawCircle(Offset(trackX, knobY), 6, knobPaint);
    }
  }

  @override
  bool shouldRepaint(_ExposureSliderPainter oldDelegate) {
    return oldDelegate.currentValue != currentValue ||
        oldDelegate.minValue != minValue ||
        oldDelegate.maxValue != maxValue;
  }
}