import 'package:audio_service/audio_service.dart';
import 'package:flutter/material.dart';
import 'package:provider/provider.dart';

import '../library/database.dart';
import '../library/song_media.dart';
import '../player/audio_handler.dart';
import '../services/download_service.dart';
import '../services/navidrome_service.dart';
import '../shared/cover.dart';
import '../shared/lauf_balken.dart';
import '../shared/theme.dart';

/// Die Titel eines Albums oder Künstlers vom Server.
///
/// Vorher spielte ein Tipp auf ein Album sofort das ganze Album ab — es gab
/// keine Möglichkeit, hineinzusehen oder einen einzelnen Titel zu wählen.
/// Das ist der Unterschied zwischen „abspielen" und „öffnen", und jede andere
/// Musik-App trennt ihn.
class ServerTitelScreen extends StatefulWidget {
  const ServerTitelScreen({
    super.key,
    required this.titel,
    required this.navidrome,
    required this.holeTitel,
    this.untertitel,
    this.coverId,
  });

  final String titel;
  final String? untertitel;
  final String? coverId;
  final NavidromeService navidrome;
  final Future<List<SubsonicSong>> Function() holeTitel;

  @override
  State<ServerTitelScreen> createState() => _ServerTitelScreenState();
}

class _ServerTitelScreenState extends State<ServerTitelScreen> {
  List<SubsonicSong>? _songs;
  Set<String> _geladen = const {};
  String? _fehler;

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

  Future<void> _laden() async {
    final db = context.read<MeloDb>();
    setState(() => _fehler = null);
    try {
      final songs = await widget.holeTitel();
      // Einmal für den ganzen Bildschirm, nicht je Zeile.
      final geladen = await db.downloadIds();
      if (mounted) {
        setState(() {
          _songs = songs;
          _geladen = geladen;
        });
      }
    } catch (e) {
      if (mounted) {
        setState(() => _fehler = e is NavidromeException
            ? e.message
            : 'Titel nicht abrufbar');
      }
    }
  }

  /// Nach Laden oder Entfernen ist der Einmal-Schnappschuss [_geladen] veraltet
  /// — hier wird er nachgezogen.
  Future<void> _aktualisiereGeladen() async {
    final geladen = await context.read<MeloDb>().downloadIds();
    if (mounted) setState(() => _geladen = geladen);
  }

  Future<void> _offlineNehmen(SubsonicSong song) async {
    final dienst = context.read<DownloadService>();
    final messenger = ScaffoldMessenger.of(context);
    if (dienst.laeuft) {
      messenger.showSnackBar(
        const SnackBar(content: Text('Es läuft schon ein Download')),
      );
      return;
    }
    final neu = await dienst.ladeEinzelnenTitel(song);
    await _aktualisiereGeladen();
    if (!mounted) return;
    messenger.showSnackBar(SnackBar(
      content: Text(neu
          ? 'Offline: ${song.titel}'
          : (dienst.fehler ?? 'War schon heruntergeladen')),
    ));
  }

  Future<void> _offlineEntfernen(SubsonicSong song) async {
    final dienst = context.read<DownloadService>();
    final messenger = ScaffoldMessenger.of(context);
    final weg = await dienst.entferne(song.id);
    await _aktualisiereGeladen();
    if (!mounted) return;
    messenger.showSnackBar(SnackBar(
      content: Text(weg
          ? 'Vom Gerät entfernt: ${song.titel}'
          : (dienst.fehler ?? 'Ließ sich nicht entfernen')),
    ));
  }

  Future<void> _spiele(List<SubsonicSong> songs, int ab) async {
    final handler = context.read<MeloAudioHandler>();
    final messenger = ScaffoldMessenger.of(context);
    final items = [
      for (final s in songs) subsonicToMediaItem(s, widget.navidrome)
    ];
    try {
      final uebersprungen = await handler.loadPlaylist(items, startIndex: ab);
      if (uebersprungen > 0) {
        messenger.showSnackBar(
          SnackBar(content: Text(offlineHinweis(uebersprungen))),
        );
      }
    } on NichtsOfflineVerfuegbar catch (e) {
      messenger.showSnackBar(SnackBar(content: Text('$e')));
    } catch (e) {
      messenger.showSnackBar(
        SnackBar(content: Text('Wiedergabe fehlgeschlagen: $e')),
      );
    }
  }

  Future<void> _zufaellig(List<SubsonicSong> songs) {
    final gemischt = [...songs]..shuffle();
    return _spiele(gemischt, 0);
  }

  @override
  Widget build(BuildContext context) {
    final songs = _songs;
    return Scaffold(
      appBar: AppBar(title: Text(widget.titel)),
      body: _fehler != null
          ? _Fehler(text: _fehler!, onNochmal: _laden)
          : songs == null
              ? const Center(
                  child: CircularProgressIndicator(color: MeloTheme.red))
              : songs.isEmpty
                  ? const Center(
                      child: Text('Keine Titel',
                          style: TextStyle(color: MeloTheme.text2)))
                  : ListView.builder(
                      itemCount: songs.length + 1,
                      itemBuilder: (context, i) {
                        if (i == 0) {
                          return _Kopf(
                            titel: widget.titel,
                            untertitel: widget.untertitel,
                            coverId: widget.coverId,
                            navidrome: widget.navidrome,
                            songs: songs,
                            onAbspielen: () => _spiele(songs, 0),
                            onZufaellig: () => _zufaellig(songs),
                          );
                        }
                        final song = songs[i - 1];
                        return _Zeile(
                          song: song,
                          nummer: i,
                          geladen: _geladen.contains(song.id),
                          onTap: () => _spiele(songs, i - 1),
                          onOffline: () => _offlineNehmen(song),
                          onEntfernen: () => _offlineEntfernen(song),
                        );
                      },
                    ),
    );
  }
}

/// Cover, Anzahl, Gesamtdauer und die beiden Wiedergabe-Knöpfe.
class _Kopf extends StatelessWidget {
  const _Kopf({
    required this.titel,
    required this.untertitel,
    required this.coverId,
    required this.navidrome,
    required this.songs,
    required this.onAbspielen,
    required this.onZufaellig,
  });

  final String titel;
  final String? untertitel;
  final String? coverId;
  final NavidromeService navidrome;
  final List<SubsonicSong> songs;
  final VoidCallback onAbspielen;
  final VoidCallback onZufaellig;

  static String _dauer(int sekunden) {
    final stunden = sekunden ~/ 3600;
    final minuten = (sekunden % 3600) ~/ 60;
    if (stunden > 0) return '$stunden Std. $minuten Min.';
    return '$minuten Min.';
  }

  @override
  Widget build(BuildContext context) {
    final gesamt = songs.fold<int>(0, (s, e) => s + e.dauerSekunden);
    final bild = coverId;
    return Padding(
      padding: const EdgeInsets.fromLTRB(
          MeloSpace.md, MeloSpace.sm, MeloSpace.md, MeloSpace.sm),
      child: Column(
        crossAxisAlignment: CrossAxisAlignment.center,
        children: [
          if (bild != null)
            CoverImage(
              artUri: navidrome.coverUrl(bild),
              size: 180,
              radius: MeloRadius.card,
            ),
          const SizedBox(height: MeloSpace.sm + MeloSpace.xs),
          Text(titel,
              style: Theme.of(context).textTheme.headlineSmall,
              textAlign: TextAlign.center),
          const SizedBox(height: MeloSpace.xs),
          Text(
            [
              ?untertitel,
              '${songs.length} Titel',
              _dauer(gesamt),
            ].join(' · '),
            style: const TextStyle(color: MeloTheme.text2, fontSize: 13),
            textAlign: TextAlign.center,
          ),
          const SizedBox(height: MeloSpace.md),
          Row(
            children: [
              Expanded(
                child: FilledButton.icon(
                  icon: const Icon(Icons.play_arrow),
                  label: const Text('Abspielen'),
                  onPressed: onAbspielen,
                ),
              ),
              const SizedBox(width: MeloSpace.sm),
              Expanded(
                child: OutlinedButton.icon(
                  icon: const Icon(Icons.shuffle),
                  label: const Text('Zufällig'),
                  onPressed: onZufaellig,
                ),
              ),
            ],
          ),
          const SizedBox(height: MeloSpace.sm),
          const Divider(height: 1),
        ],
      ),
    );
  }
}

/// Eine Titelzeile: Nummer, Name, Dauer — und die Lauf-Markierung, wenn
/// dieser Titel gerade spielt.
class _Zeile extends StatelessWidget {
  const _Zeile({
    required this.song,
    required this.nummer,
    required this.geladen,
    required this.onTap,
    required this.onOffline,
    required this.onEntfernen,
  });

  final SubsonicSong song;
  final int nummer;
  final bool geladen;
  final VoidCallback onTap;
  final VoidCallback onOffline;
  final VoidCallback onEntfernen;

  static String _dauer(int sekunden) {
    final m = (sekunden ~/ 60).toString();
    final s = (sekunden % 60).toString().padLeft(2, '0');
    return '$m:$s';
  }

  @override
  Widget build(BuildContext context) {
    final handler = context.read<MeloAudioHandler>();
    return StreamBuilder<MediaItem?>(
      stream: handler.mediaItem,
      initialData: handler.mediaItem.valueOrNull,
      builder: (context, laufSnap) {
        // Server-Titel tragen keine Bibliotheks-UUID; erkannt werden sie an
        // der Navidrome-ID.
        final aktuell = laufSnap.data;
        final markiert =
            aktuell != null && navidromeIdOf(aktuell) == song.id;
        return StreamBuilder<PlaybackState>(
          stream: markiert ? handler.playbackState : null,
          initialData: handler.playbackState.valueOrNull,
          builder: (context, zustandSnap) => ListTile(
            leading: SizedBox(
              width: 32,
              child: markiert
                  ? LaufBalken(
                      laeuft: zustandSnap.data?.playing ?? false,
                      farbe: MeloTheme.red,
                    )
                  : Text('$nummer',
                      textAlign: TextAlign.center,
                      style: const TextStyle(color: MeloTheme.text3)),
            ),
            title: Text(
              song.titel,
              maxLines: 1,
              overflow: TextOverflow.ellipsis,
              style: markiert
                  ? const TextStyle(
                      color: MeloTheme.red, fontWeight: FontWeight.w600)
                  : null,
            ),
            subtitle: song.kuenstler.isEmpty
                ? null
                : Text(song.kuenstler,
                    maxLines: 1, overflow: TextOverflow.ellipsis),
            trailing: Row(
              mainAxisSize: MainAxisSize.min,
              children: [
                // Bisher gab es den Lade-Knopf nur je Album — einen einzelnen
                // Titel mitzunehmen ging gar nicht.
                geladen
                    ? IconButton(
                        tooltip: 'Vom Gerät entfernen',
                        icon: const Icon(Icons.download_done,
                            size: 20, color: MeloTheme.red),
                        onPressed: onEntfernen,
                      )
                    : IconButton(
                        tooltip: 'Offline nehmen',
                        icon: const Icon(Icons.download_outlined,
                            size: 20, color: MeloTheme.text3),
                        onPressed: onOffline,
                      ),
                Text(_dauer(song.dauerSekunden),
                    style: const TextStyle(color: MeloTheme.text3)),
              ],
            ),
            onTap: onTap,
          ),
        );
      },
    );
  }
}


class _Fehler extends StatelessWidget {
  const _Fehler({required this.text, required this.onNochmal});

  final String text;
  final VoidCallback onNochmal;

  @override
  Widget build(BuildContext context) {
    return Center(
      child: Column(
        mainAxisSize: MainAxisSize.min,
        children: [
          const Icon(Icons.error_outline, size: 48, color: MeloTheme.red),
          const SizedBox(height: MeloSpace.sm + MeloSpace.xs),
          Text(text, style: const TextStyle(color: MeloTheme.text2)),
          const SizedBox(height: MeloSpace.md),
          FilledButton.icon(
            icon: const Icon(Icons.refresh),
            label: const Text('Erneut versuchen'),
            onPressed: onNochmal,
          ),
        ],
      ),
    );
  }
}