import 'dart:async';
import 'package:flutter_riverpod/flutter_riverpod.dart';

enum CameraConnectionState {
  disconnected,
  connecting,
  connected,
  recording,
  error,
}

enum CameraTriggerEventType {
  crashDetected,
  hardBraking,
  highGForce,
  highLeanAngle,
  topSpeedExceeded,
  manualBookmark,
}

class CameraTriggerEvent {
  final CameraTriggerEventType type;
  final DateTime timestamp;
  final double? peakValue;
  final String description;

  const CameraTriggerEvent({
    required this.type,
    required this.timestamp,
    this.peakValue,
    required this.description,
  });
}

abstract class CameraProvider {
  String get name;
  CameraConnectionState get connectionState;
  Stream<CameraConnectionState> get stateStream;

  Future<bool> connect();
  Future<void> disconnect();
  Future<bool> startRecording();
  Future<bool> stopRecording();
  Future<void> onTelemetryEvent(CameraTriggerEvent event);
}

/// Fallback / Mock provider for development and testing
class MockCameraProvider implements CameraProvider {
  @override
  String get name => 'MockActionCamera';

  CameraConnectionState _state = CameraConnectionState.disconnected;
  final _stateController = StreamController<CameraConnectionState>.broadcast();

  @override
  CameraConnectionState get connectionState => _state;

  @override
  Stream<CameraConnectionState> get stateStream => _stateController.stream;

  final List<CameraTriggerEvent> capturedEvents = [];

  @override
  Future<bool> connect() async {
    _state = CameraConnectionState.connected;
    _stateController.add(_state);
    return true;
  }

  @override
  Future<void> disconnect() async {
    _state = CameraConnectionState.disconnected;
    _stateController.add(_state);
  }

  @override
  Future<bool> startRecording() async {
    if (_state == CameraConnectionState.connected) {
      _state = CameraConnectionState.recording;
      _stateController.add(_state);
      return true;
    }
    return false;
  }

  @override
  Future<bool> stopRecording() async {
    if (_state == CameraConnectionState.recording) {
      _state = CameraConnectionState.connected;
      _stateController.add(_state);
      return true;
    }
    return false;
  }

  @override
  Future<void> onTelemetryEvent(CameraTriggerEvent event) async {
    capturedEvents.add(event);
  }

  void dispose() {
    _stateController.close();
  }
}

final cameraProvider = Provider<CameraProvider>((ref) {
  return MockCameraProvider();
});