import 'dart:async';
import 'package:flutter_riverpod/flutter_riverpod.dart';
import 'package:mirror_protocol/mirror_protocol.dart';
import 'package:mirror_core/mirror_core.dart';
import '../services/ws_server.dart';
import 'player_provider.dart';

final displayStateProvider =
    NotifierProvider<DisplayStateNotifier, DisplayState>(DisplayStateNotifier.new);

final youtubeServiceProvider = Provider<YouTubeService>((ref) {
  final service = YouTubeService();
  ref.onDispose(() => service.dispose());
  return service;
});

final plexServiceProvider = Provider<PlexService>((ref) {
  const host = String.fromEnvironment('PLEX_HOST', defaultValue: '192.168.86.172');
  const port = int.fromEnvironment('PLEX_PORT', defaultValue: 32400);
  const token = String.fromEnvironment('PLEX_TOKEN', defaultValue: '');
  return PlexService(host: host, port: port, token: token);
});

final spotifyServiceProvider = Provider<SpotifyService>((ref) {
  return SpotifyService();
});

class DisplayStateNotifier extends Notifier<DisplayState> {
  Timer? _programTimer;

  @override
  DisplayState build() => DisplayState.initial();

  void navigate(ScreenType target) {
    state = state.copyWith(activeScreen: target);
    _broadcast();
  }

  // --- Program handling ---

  void handleProgram(ProgramAction action, Map<String, dynamic>? payload) {
    switch (action) {
      case ProgramAction.playWorkout:
        _startProgramWorkout(payload);
      case ProgramAction.skipExercise:
        _advanceProgramExercise(1);
      case ProgramAction.previousExercise:
        _advanceProgramExercise(-1);
      case ProgramAction.pauseExercise:
        _pauseProgramExercise();
      case ProgramAction.resumeExercise:
        _resumeProgramExercise();
      case ProgramAction.stopProgram:
        _stopProgram();
      case ProgramAction.browse:
        break;
    }
    _broadcast();
  }

  void _startProgramWorkout(Map<String, dynamic>? payload) {
    if (payload == null) return;

    final programId = payload['programId'] as String? ?? '';
    final programName = payload['programName'] as String? ?? '';
    final workoutName = payload['workoutName'] as String? ?? '';
    final rawExercises = payload['exercises'] as List<dynamic>? ?? [];

    final exercises = rawExercises
        .map((e) => ProgramExercise.fromJson(e as Map<String, dynamic>))
        .toList();

    if (exercises.isEmpty) return;

    state = state.copyWith(
      activeScreen: ScreenType.workout,
      program: ProgramSessionState(
        programId: programId,
        programName: programName,
        workoutName: workoutName,
        exercises: exercises.map((e) => e.id).toList(),
        currentExerciseIndex: 0,
        phase: 'playing',
        currentSet: 1,
        totalSets: exercises.first.sets,
      ),
    );

    _playProgramExercise(exercises.first);
  }

  void _playProgramExercise(ProgramExercise exercise) {
    _programTimer?.cancel();

    switch (exercise.type) {
      case 'video':
        if (exercise.videoPath != null) {
          final client = ref.read(workoutApiClientProvider);
          final streamUrl = client.streamUrl(exercise.videoPath!);
          final duration = exercise.durationSeconds ?? 0;

          state = state.copyWith(
            playback: PlaybackState(
              mediaId: exercise.id,
              title: exercise.instructionTitle ?? 'Exercise',
              source: MediaSource.workout,
              position: Duration.zero,
              duration: Duration(seconds: duration),
              isPlaying: true,
            ),
          );

          ref.read(playerProvider).play(streamUrl);
        }
      case 'youtube':
        // YouTube exercises show an instruction card with countdown
        final duration = exercise.setDurationSeconds ?? exercise.durationSeconds ?? 30;
        final program = state.program;
        if (program != null) {
          state = state.copyWith(
            program: program.copyWith(
              phase: 'youtube',
              timerRemaining: duration,
            ),
            clearPlayback: true,
          );
          _startProgramCountdown(duration);
        }
      case 'instruction':
        final duration = exercise.setDurationSeconds ?? exercise.durationSeconds ?? 30;
        final program = state.program;
        if (program != null) {
          state = state.copyWith(
            program: program.copyWith(
              phase: 'instruction',
              timerRemaining: duration,
            ),
            clearPlayback: true,
          );
          _startProgramCountdown(duration);
        }
    }
  }

  void _startProgramCountdown(int seconds) {
    _programTimer?.cancel();
    var remaining = seconds;
    _programTimer = Timer.periodic(const Duration(seconds: 1), (timer) {
      remaining--;
      final program = state.program;
      if (program == null || remaining <= 0) {
        timer.cancel();
        if (program != null) {
          _onProgramSetCompleted();
        }
        return;
      }
      state = state.copyWith(
        program: program.copyWith(timerRemaining: remaining),
      );
      _broadcast();
    });
  }

  void _onProgramSetCompleted() {
    final program = state.program;
    if (program == null) return;

    if (program.currentSet < program.totalSets) {
      // More sets remaining
      state = state.copyWith(
        program: program.copyWith(currentSet: program.currentSet + 1),
      );
      // Restart the same exercise
      _replayCurrentProgramExercise();
    } else {
      // All sets done, advance to next exercise
      _advanceProgramExercise(1);
    }
  }

  void _replayCurrentProgramExercise() {
    final program = state.program;
    if (program == null) return;
    // Re-fetch exercises from payload stored as IDs — we need to get fresh exercise data
    // For now, re-trigger the timer for instruction/youtube types
    final phase = program.phase;
    if (phase == 'youtube' || phase == 'instruction') {
      // Restart countdown (we'd need exercise duration, use timerRemaining as template)
      // This is a simplified restart — ideally we store exercises in program state
      _startProgramCountdown(program.timerRemaining > 0 ? program.timerRemaining : 30);
    }
  }

  void _advanceProgramExercise(int direction) {
    final program = state.program;
    if (program == null) return;

    _programTimer?.cancel();
    ref.read(playerProvider).stop();

    final nextIndex = program.currentExerciseIndex + direction;
    if (nextIndex < 0 || nextIndex >= program.exercises.length) {
      state = state.copyWith(
        program: program.copyWith(phase: 'completed'),
        clearPlayback: true,
      );
      return;
    }

    state = state.copyWith(
      program: program.copyWith(
        currentExerciseIndex: nextIndex,
        currentSet: 1,
        phase: 'playing',
      ),
    );
    // Note: the remote sends exercises in playWorkout payload.
    // For skip/previous we broadcast state and let the remote re-send
    // the exercise data if needed, or we handle it via a stored exercises list.
    // For simplicity, we update the index and broadcast — the remote can
    // send a new playWorkout if complex exercise data is needed.
  }

  void _pauseProgramExercise() {
    _programTimer?.cancel();
    final program = state.program;
    if (program != null) {
      if (program.phase == 'playing') {
        ref.read(playerProvider).pause();
        final current = state.playback;
        if (current != null) {
          state = state.copyWith(playback: current.copyWith(isPlaying: false));
        }
      }
      // For timer-based exercises, stopping the timer is enough
    }
  }

  void _resumeProgramExercise() {
    final program = state.program;
    if (program != null) {
      if (program.phase == 'playing') {
        ref.read(playerProvider).resume();
        final current = state.playback;
        if (current != null) {
          state = state.copyWith(playback: current.copyWith(isPlaying: true));
        }
      } else if (program.phase == 'youtube' || program.phase == 'instruction') {
        _startProgramCountdown(program.timerRemaining);
      }
    }
  }

  void _stopProgram() {
    _programTimer?.cancel();
    ref.read(playerProvider).stop();
    state = state.copyWith(clearProgram: true, clearPlayback: true);
  }

  // --- Media handling ---

  void handleMedia(MediaAction action, Map<String, dynamic>? payload) {
    switch (action) {
      case MediaAction.searchYouTube:
        _searchYouTube(payload);
      case MediaAction.playYouTube:
        _playYouTube(payload);
      case MediaAction.browsePlex:
        _browsePlex(payload);
      case MediaAction.playPlex:
        _playPlex(payload);
      case MediaAction.spotifyPlay:
        _spotifyPlay(payload);
      case MediaAction.spotifyPause:
        _spotifyPause();
      case MediaAction.spotifyNext:
        _spotifyNext();
      case MediaAction.spotifyPrevious:
        _spotifyPrevious();
      case MediaAction.spotifyTransfer:
        _spotifyTransfer(payload);
    }
    _broadcast();
  }

  Future<void> _searchYouTube(Map<String, dynamic>? payload) async {
    final query = payload?['query'] as String?;
    if (query == null || query.isEmpty) return;

    try {
      final yt = ref.read(youtubeServiceProvider);
      final results = await yt.search(query);
      final data = results
          .map((v) => {
                'id': v.id,
                'title': v.title,
                'author': v.author,
                'durationMs': v.duration.inMilliseconds,
                'thumbnailUrl': v.thumbnailUrl,
              })
          .toList();
      // Broadcast search results as an event
      ref.read(wsServerProvider).broadcast(
            EventMessage(event: 'youtubeResults', data: {'results': data}),
          );
    } catch (e) {
      print('YouTube search failed: $e');
    }
  }

  Future<void> _playYouTube(Map<String, dynamic>? payload) async {
    final videoId = payload?['videoId'] as String?;
    final title = payload?['title'] as String? ?? 'YouTube';
    if (videoId == null) return;

    try {
      final yt = ref.read(youtubeServiceProvider);
      final streamUrl = await yt.getStreamUrl(videoId);

      state = state.copyWith(
        activeScreen: ScreenType.media,
        playback: PlaybackState(
          mediaId: videoId,
          title: title,
          source: MediaSource.youtube,
          position: Duration.zero,
          duration: Duration.zero,
          isPlaying: true,
        ),
        clearSpotify: true,
      );

      ref.read(playerProvider).play(streamUrl);
    } catch (e) {
      print('YouTube playback failed: $e');
    }
  }

  Future<void> _browsePlex(Map<String, dynamic>? payload) async {
    try {
      final plex = ref.read(plexServiceProvider);
      final libraryId = payload?['libraryId'] as String?;
      final itemId = payload?['itemId'] as String?;

      List<Map<String, dynamic>> items;
      if (itemId != null) {
        final children = await plex.fetchChildren(itemId);
        items = children.map((c) => c.toJson()).toList();
      } else if (libraryId != null) {
        final results = await plex.fetchItems(libraryId);
        items = results.map((r) => r.toJson()).toList();
      } else {
        final libraries = await plex.fetchLibraries();
        items = libraries.map((l) => l.toJson()).toList();
      }

      ref.read(wsServerProvider).broadcast(
            EventMessage(event: 'plexBrowse', data: {'items': items}),
          );
    } catch (e) {
      print('Plex browse failed: $e');
    }
  }

  Future<void> _playPlex(Map<String, dynamic>? payload) async {
    final streamUrl = payload?['streamUrl'] as String?;
    final title = payload?['title'] as String? ?? 'Plex';
    if (streamUrl == null || streamUrl.isEmpty) return;

    try {
      state = state.copyWith(
        activeScreen: ScreenType.media,
        playback: PlaybackState(
          mediaId: streamUrl,
          title: title,
          source: MediaSource.plex,
          position: Duration.zero,
          duration: Duration.zero,
          isPlaying: true,
        ),
        clearSpotify: true,
      );

      ref.read(playerProvider).play(streamUrl);
    } catch (e) {
      print('Plex playback failed: $e');
    }
  }

  Future<void> _spotifyPlay(Map<String, dynamic>? payload) async {
    try {
      final spotify = ref.read(spotifyServiceProvider);
      final token = payload?['token'] as String?;
      if (token != null) spotify.setToken(token);

      final deviceId = payload?['deviceId'] as String?;
      await spotify.play(deviceId: deviceId);

      // Fetch current state
      final playback = await spotify.getCurrentPlayback();
      if (playback != null) {
        state = state.copyWith(
          activeScreen: ScreenType.media,
          spotify: SpotifyState(
            isPlaying: playback.isPlaying,
            trackName: playback.trackName,
            artistName: playback.artistName,
            albumImageUrl: playback.albumArt,
            progressMs: playback.progressMs,
            durationMs: playback.durationMs,
          ),
          clearPlayback: true,
        );
      }
    } catch (e) {
      print('Spotify play failed: $e');
    }
  }

  Future<void> _spotifyPause() async {
    try {
      final spotify = ref.read(spotifyServiceProvider);
      await spotify.pause();
      final current = state.spotify;
      if (current != null) {
        state = state.copyWith(
          spotify: current.copyWith(isPlaying: false),
        );
      }
    } catch (e) {
      print('Spotify pause failed: $e');
    }
  }

  Future<void> _spotifyNext() async {
    try {
      final spotify = ref.read(spotifyServiceProvider);
      await spotify.next();
      // Brief delay for Spotify to update
      await Future.delayed(const Duration(milliseconds: 500));
      final playback = await spotify.getCurrentPlayback();
      if (playback != null) {
        state = state.copyWith(
          spotify: SpotifyState(
            isPlaying: playback.isPlaying,
            trackName: playback.trackName,
            artistName: playback.artistName,
            albumImageUrl: playback.albumArt,
            progressMs: playback.progressMs,
            durationMs: playback.durationMs,
          ),
        );
      }
    } catch (e) {
      print('Spotify next failed: $e');
    }
  }

  Future<void> _spotifyPrevious() async {
    try {
      final spotify = ref.read(spotifyServiceProvider);
      await spotify.previous();
      await Future.delayed(const Duration(milliseconds: 500));
      final playback = await spotify.getCurrentPlayback();
      if (playback != null) {
        state = state.copyWith(
          spotify: SpotifyState(
            isPlaying: playback.isPlaying,
            trackName: playback.trackName,
            artistName: playback.artistName,
            albumImageUrl: playback.albumArt,
            progressMs: playback.progressMs,
            durationMs: playback.durationMs,
          ),
        );
      }
    } catch (e) {
      print('Spotify previous failed: $e');
    }
  }

  Future<void> _spotifyTransfer(Map<String, dynamic>? payload) async {
    final deviceId = payload?['deviceId'] as String?;
    if (deviceId == null) return;

    try {
      final spotify = ref.read(spotifyServiceProvider);
      await spotify.transferPlayback(deviceId);
    } catch (e) {
      print('Spotify transfer failed: $e');
    }
  }

  void handlePlayback(PlaybackAction action, dynamic value) {
    final player = ref.read(playerProvider);
    switch (action) {
      case PlaybackAction.pause:
        final current = state.playback;
        if (current != null) {
          player.pause();
          state = state.copyWith(playback: current.copyWith(isPlaying: false));
        }
      case PlaybackAction.resume:
        final current = state.playback;
        if (current != null) {
          player.resume();
          state = state.copyWith(playback: current.copyWith(isPlaying: true));
        }
      case PlaybackAction.seek:
        final current = state.playback;
        if (current != null && value is num) {
          final pos = Duration(milliseconds: value.toInt());
          player.seek(pos);
          state = state.copyWith(playback: current.copyWith(position: pos));
        }
      case PlaybackAction.stop:
        player.stop();
        state = state.copyWith(clearPlayback: true);
      case PlaybackAction.setVolume:
        final current = state.playback;
        if (current != null && value is num) {
          player.setVolume(value.toDouble());
          state = state.copyWith(playback: current.copyWith(volume: value.toDouble()));
        }
      default:
        break;
    }
    _broadcast();
  }

  void handleWorkout(WorkoutAction action, Map<String, dynamic>? payload) {
    final session = state.workout ?? const WorkoutSessionState(phase: WorkoutPhase.idle);

    switch (action) {
      case WorkoutAction.browse:
        final path = payload?['path'] as String?;
        final filter = payload?['filter'] != null
            ? WorkoutFilter.fromJson(payload!['filter'] as String)
            : session.filter;
        state = state.copyWith(
          activeScreen: ScreenType.workout,
          workout: session.copyWith(
            phase: WorkoutPhase.browsing,
            currentPath: path,
            clearCurrentPath: path == null || path.isEmpty,
            filter: filter,
          ),
        );
        _fetchVideos(path, filter);
      case WorkoutAction.playVideo:
        final payload2 = payload;
        if (payload2 != null && payload2.containsKey('path')) {
          _playFromPayload(payload2);
        } else {
          final videoId = payload?['videoId'] as String?;
          if (videoId != null) _startVideo(videoId);
        }
      case WorkoutAction.playFolder:
        if (payload != null && payload.containsKey('videos')) {
          _playFolderFromPayload(payload);
        } else {
          _playFolder(payload?['unwatchedOnly'] as bool? ?? false);
        }
      case WorkoutAction.pauseWorkout:
        handlePlayback(PlaybackAction.pause, null);
      case WorkoutAction.resumeWorkout:
        handlePlayback(PlaybackAction.resume, null);
      case WorkoutAction.skipVideo:
        _advanceQueue();
      case WorkoutAction.skipRest:
        _skipRest();
      case WorkoutAction.previousVideo:
        _previousVideo();
      case WorkoutAction.stopSession:
        ref.read(playerProvider).stop();
        state = state.copyWith(
          workout: session.copyWith(phase: WorkoutPhase.idle),
          clearPlayback: true,
        );
      default:
        break;
    }
    _broadcast();
  }

  void updatePlaybackPosition(Duration position) {
    final current = state.playback;
    if (current != null) {
      state = state.copyWith(playback: current.copyWith(position: position));
      _broadcast();
    }
  }

  void onMediaCompleted() {
    final session = state.workout;
    if (session != null && session.phase == WorkoutPhase.playing) {
      _advanceQueue();
    } else {
      state = state.copyWith(clearPlayback: true);
    }
    _broadcast();
  }

  Future<void> _fetchVideos(String? path, WorkoutFilter filter) async {
    try {
      final client = ref.read(workoutApiClientProvider);
      final result = await client.fetchVideos(folder: path, filter: filter);
      final stats = await client.fetchStats();
      final session = state.workout;
      if (session != null) {
        state = state.copyWith(
          workout: session.copyWith(
            videos: result.videos,
            folders: result.folders,
            stats: stats,
          ),
        );
        _broadcast();
      }
    } catch (e) {
      print('Failed to fetch videos: $e');
    }
  }

  void _startVideo(String videoId) {
    final session = state.workout;
    if (session == null) return;

    final video = session.videos.firstWhere(
      (v) => v.id == videoId,
      orElse: () => session.videos.first,
    );

    final client = ref.read(workoutApiClientProvider);
    final streamUrl = client.streamUrl(video.path);
    final startPosition = video.lastPosition > 0 ? video.lastPosition : video.trimStart;

    state = state.copyWith(
      workout: session.copyWith(
        phase: WorkoutPhase.playing,
        queue: [
          QueueItemState(
            videoId: video.id,
            title: video.title,
            path: video.path,
            duration: video.duration,
            trimStart: video.trimStart,
            trimEnd: video.trimEnd,
            restSeconds: video.restSeconds,
          ),
        ],
        currentIndex: 0,
      ),
      playback: PlaybackState(
        mediaId: video.id,
        title: video.title,
        source: MediaSource.workout,
        position: Duration(seconds: startPosition),
        duration: Duration(seconds: video.duration),
        isPlaying: true,
      ),
    );

    ref.read(playerProvider).play(
      streamUrl,
      startPosition: startPosition > 0 ? Duration(seconds: startPosition) : null,
    );
  }

  void _playFolder(bool unwatchedOnly) {
    final session = state.workout;
    if (session == null) return;

    final videos = unwatchedOnly
        ? session.videos.where((v) => v.percentCompleted < 95).toList()
        : session.videos;

    if (videos.isEmpty) return;

    final queue = videos
        .map((v) => QueueItemState(
              videoId: v.id,
              title: v.title,
              path: v.path,
              duration: v.duration,
              trimStart: v.trimStart,
              trimEnd: v.trimEnd,
              restSeconds: v.restSeconds,
            ))
        .toList();

    final first = videos.first;
    final client = ref.read(workoutApiClientProvider);
    final streamUrl = client.streamUrl(first.path);
    final startPos = first.lastPosition > 0 ? first.lastPosition : first.trimStart;

    state = state.copyWith(
      workout: session.copyWith(
        phase: WorkoutPhase.playing,
        queue: queue,
        currentIndex: 0,
      ),
      playback: PlaybackState(
        mediaId: first.id,
        title: first.title,
        source: MediaSource.workout,
        position: Duration(seconds: startPos),
        duration: Duration(seconds: first.duration),
        isPlaying: true,
      ),
    );

    ref.read(playerProvider).play(
      streamUrl,
      startPosition: startPos > 0 ? Duration(seconds: startPos) : null,
    );
  }

  void _advanceQueue() {
    final session = state.workout;
    if (session == null) return;

    final nextIndex = session.currentIndex + 1;
    if (nextIndex >= session.queue.length) {
      state = state.copyWith(
        workout: session.copyWith(phase: WorkoutPhase.completed),
        clearPlayback: true,
      );
      return;
    }

    final next = session.queue[nextIndex];
    if (next.restSeconds > 0) {
      state = state.copyWith(
        workout: session.copyWith(
          phase: WorkoutPhase.resting,
          currentIndex: nextIndex,
          restRemaining: next.restSeconds,
        ),
        clearPlayback: true,
      );
      _startRestCountdown(next.restSeconds);
    } else {
      _playQueueItem(nextIndex);
    }
  }

  void _previousVideo() {
    final session = state.workout;
    if (session == null || session.currentIndex <= 0) return;
    _playQueueItem(session.currentIndex - 1);
  }

  void _skipRest() {
    final session = state.workout;
    if (session == null) return;
    _playQueueItem(session.currentIndex);
  }

  void _playQueueItem(int index) {
    final session = state.workout;
    if (session == null || index >= session.queue.length) return;

    final item = session.queue[index];
    final client = ref.read(workoutApiClientProvider);
    final streamUrl = client.streamUrl(item.path);

    state = state.copyWith(
      workout: session.copyWith(
        phase: WorkoutPhase.playing,
        currentIndex: index,
      ),
      playback: PlaybackState(
        mediaId: item.videoId,
        title: item.title,
        source: MediaSource.workout,
        position: Duration(seconds: item.trimStart),
        duration: Duration(seconds: item.duration),
        isPlaying: true,
      ),
    );

    ref.read(playerProvider).play(
      streamUrl,
      startPosition: item.trimStart > 0 ? Duration(seconds: item.trimStart) : null,
    );
  }

  Timer? _restTimer;

  void _playFromPayload(Map<String, dynamic> payload) {
    final videoId = payload['videoId'] as String;
    final title = payload['title'] as String? ?? '';
    final path = payload['path'] as String;
    final duration = (payload['duration'] as num?)?.toInt() ?? 0;
    final trimStart = (payload['trimStart'] as num?)?.toInt() ?? 0;
    final trimEnd = (payload['trimEnd'] as num?)?.toInt() ?? 0;
    final restSeconds = (payload['restSeconds'] as num?)?.toInt() ?? 0;
    final lastPosition = (payload['lastPosition'] as num?)?.toInt() ?? 0;

    final client = ref.read(workoutApiClientProvider);
    final streamUrl = client.streamUrl(path);
    final startPos = lastPosition > 0 ? lastPosition : trimStart;

    final session = state.workout ?? const WorkoutSessionState(phase: WorkoutPhase.idle);

    state = state.copyWith(
      activeScreen: ScreenType.workout,
      workout: session.copyWith(
        phase: WorkoutPhase.playing,
        queue: [
          QueueItemState(
            videoId: videoId,
            title: title,
            path: path,
            duration: duration,
            trimStart: trimStart,
            trimEnd: trimEnd,
            restSeconds: restSeconds,
          ),
        ],
        currentIndex: 0,
      ),
      playback: PlaybackState(
        mediaId: videoId,
        title: title,
        source: MediaSource.workout,
        position: Duration(seconds: startPos),
        duration: Duration(seconds: duration),
        isPlaying: true,
      ),
    );

    ref.read(playerProvider).play(
      streamUrl,
      startPosition: startPos > 0 ? Duration(seconds: startPos) : null,
    );
    _broadcast();
  }

  void _playFolderFromPayload(Map<String, dynamic> payload) {
    final rawVideos = payload['videos'] as List<dynamic>;
    if (rawVideos.isEmpty) return;

    final queue = rawVideos.map((v) {
      final m = v as Map<String, dynamic>;
      return QueueItemState(
        videoId: m['videoId'] as String,
        title: m['title'] as String? ?? '',
        path: m['path'] as String,
        duration: (m['duration'] as num?)?.toInt() ?? 0,
        trimStart: (m['trimStart'] as num?)?.toInt() ?? 0,
        trimEnd: (m['trimEnd'] as num?)?.toInt() ?? 0,
        restSeconds: (m['restSeconds'] as num?)?.toInt() ?? 0,
      );
    }).toList();

    final first = queue.first;
    final lastPosition = (rawVideos.first as Map<String, dynamic>)['lastPosition'] as num?;
    final startPos = (lastPosition?.toInt() ?? 0) > 0
        ? lastPosition!.toInt()
        : first.trimStart;

    final client = ref.read(workoutApiClientProvider);
    final streamUrl = client.streamUrl(first.path);

    final session = state.workout ?? const WorkoutSessionState(phase: WorkoutPhase.idle);

    state = state.copyWith(
      activeScreen: ScreenType.workout,
      workout: session.copyWith(
        phase: WorkoutPhase.playing,
        queue: queue,
        currentIndex: 0,
      ),
      playback: PlaybackState(
        mediaId: first.videoId,
        title: first.title,
        source: MediaSource.workout,
        position: Duration(seconds: startPos),
        duration: Duration(seconds: first.duration),
        isPlaying: true,
      ),
    );

    ref.read(playerProvider).play(
      streamUrl,
      startPosition: startPos > 0 ? Duration(seconds: startPos) : null,
    );
    _broadcast();
  }

  void _startRestCountdown(int seconds) {
    _restTimer?.cancel();
    var remaining = seconds;
    _restTimer = Timer.periodic(const Duration(seconds: 1), (timer) {
      remaining--;
      final session = state.workout;
      if (session == null || remaining <= 0) {
        timer.cancel();
        if (session != null) _playQueueItem(session.currentIndex);
        return;
      }
      state = state.copyWith(
        workout: session.copyWith(restRemaining: remaining),
      );
      _broadcast();
    });
  }

  void _broadcast() {
    ref.read(wsServerProvider).broadcastState(state);
  }
}

final workoutApiClientProvider = Provider<WorkoutApiClient>((ref) {
  const url = String.fromEnvironment('WORKOUT_PLAYER_URL',
      defaultValue: 'http://192.168.86.172:8091');
  return WorkoutApiClient(baseUrl: url);
});