import 'package:download_groups/download_groups.dart';

// Using dependency injection (recommended)
class MyService {
  MyService(this.downloadHandler);
  
  final DownloadGroupsHandler downloadHandler;
}

// Register with your DI container
..registerSingleton<DownloadGroupsHandler>(
  DioDownloadGroupsHandler(
    logger: AssetDownloaderLogger((msg) => debugPrint(msg)),
  ),
)

// Or create directly
DownloadGroupsHandler downloadHandler = DioDownloadGroupsHandler(
  logger: AssetDownloaderLogger(debugPrint),
);

// Define a collection of download groups
Map<String, DownloadGroup> get downloadGroups {
  return {
    'animals': AnimalImages(),
    'icons': UIIcons(),
    'sounds': SoundEffects(),
  };
}

// Example: Animal Images Download Group
class AnimalImages implements DownloadGroup {
  @override
  String get name => 'Animal Images';
  
  @override
  Map<String, AssetGroup> assets = {};
  
  var _initialized = false;
  
  @override
  void init(String domain) {
    if (!_initialized) {
      _initialized = true;
      assets.addAll({
        'mammals': MammalAssetGroup(domain),
        'birds': BirdAssetGroup(domain),
        'reptiles': ReptileAssetGroup(domain),
      });
    }
  }
}

// Example: Specific Asset Group for Dogs
class DogAssetGroup extends ImageAssetGroup {
  DogAssetGroup(String domain)
    : super(
        groupName: 'dogs',
        baseUrl: domain,
        assets: [
          'assets/images/animals/dog/husky.png',
          'assets/images/animals/dog/poodle.png',
          'assets/images/animals/dog/beagle.png',
          'assets/images/animals/dog/labrador.png',
        ],
        width: 120,
        height: 120,
      );
}

final areDownloaded = await downloadHandler.areAssetsDownloaded(
  downloadGroups.values,
  ['https://cdn1.example.com', 'https://cdn2.example.com'],
);

if (areDownloaded) {
  alreadyDownloadedActions();
} else {
  downloadActions();
}

try {
  final result = await downloadHandler.syncDownloadGroups(
    groups: downloadGroups.values,
    appDomains: [
      'https://cdn1.example.com',
      'https://cdn2.example.com',
      'https://cdn3.example.com',
    ],
    onProgress: (completed, total) {
      final percentage = (completed / total * 100).toStringAsFixed(1);
      print('Download progress: $percentage% ($completed/$total)');
    },
    id: 'main_asset_download',
  );
  
  if (result.status is DownloadGroupsSuccess) {
    print('Download completed successfully!');
  } else {
    print('Download failed: ${result.status.name}');
  }
} catch (e, stackTrace) {
  await logger.exception(e, stackTrace);
  print('Download failed with exception: $e');
}

class CachedAssetImage extends StatefulWidget {
  const CachedAssetImage(
    this.asset, {
    this.width,
    this.height,
    this.fit = BoxFit.fitWidth,
    super.key,
  });
  
  final String asset;
  final double? width;
  final double? height;
  final BoxFit? fit;

  @override
  State<CachedAssetImage> createState() => _CachedAssetImageState();
}

class _CachedAssetImageState extends State<CachedAssetImage> {
  late final Image cachedImage;

  @override
  void initState() {
    super.initState();
    
    // Get the local path for the downloaded asset
    final path = downloadHandler.getAssetPath('/${widget.asset}')
      ?.replaceAll('//', '/');
    
    if (path == null) {
      // Fallback to bundled asset if download failed
      cachedImage = Image.asset(
        'assets/images/placeholder.png',
        width: widget.width,
        height: widget.height,
        fit: widget.fit,
      );
    } else {
      // Use downloaded file
      cachedImage = Image.file(
        File(path),
        width: widget.width,
        height: widget.height,
        fit: widget.fit,
      );
    }
  }

  @override
  Future<void> didChangeDependencies() async {
    super.didChangeDependencies();
    await precacheImage(cachedImage.image, context);
  }

  @override
  Widget build(BuildContext) => cachedImage;
}

// For audio files with metadata
class AudioAssetGroup extends DefaultAssetGroup {
  AudioAssetGroup({
    required super.groupName,
    required super.baseUrl,
    required super.assets,
    this.duration,
    this.bitrate,
  });

  final Duration? duration;
  final int? bitrate;
}

// For SVG icons with size specifications
class IconAssetGroup extends DefaultAssetGroup {
  IconAssetGroup({
    required super.groupName,
    required super.baseUrl,
    required super.assets,
    this.size = 24.0,
  });

  final double size;
}

switch (result.status) {
  case DownloadGroupsSuccess():
    print('All downloads successful');
    
  case NoUrlsProvidedInAssetGroupError():
    print('No URLs provided in asset group');
    
  case DomainsNotReachableError():
    print('Domains not reachable: ${(result.status as DomainsNotReachableError).domains}');
    
  case SomeFilesWereNotDownloadedError():
    final failedUrls = (result.status as SomeFilesWereNotDownloadedError).urls;
    print('Some files failed to download: $failedUrls');
    
  case NoFilesWereDownloadedSuccessfullyError():
    print('No files were downloaded successfully');
    
  case DownloadGroupWasNotInitialized():
    print('Download group was not initialized');
    
  case EventLoopOverflowError():
    print('Event loop overflow occurred');
}

// With a custom logger
final logger = AssetDownloaderLogger((message) {
  MyCustomLogger.log('DownloadGroups: $message', level: LogLevel.info);
});

// With structured logging
final logger = AssetDownloaderLogger((message) {
  final structured = {
    'timestamp': DateTime.now().toIso8601String(),
    'component': 'download_groups',
    'message': message,
  };
  StructuredLogger.log(structured);
});

// Silent logging (for production)
final logger = AssetDownloaderLogger((message) {});