import 'dart:io';
import 'dart:async';
import 'dart:typed_data';
import 'package:tutorials/custom_code/download_globals.dart';

Future downloadFile(
  String? fileId,
  String? url,
  String? savePath,
) async {
  if (fileId == null || url == null || savePath == null) return;

  print("downloadFile START fileId=$fileId");

  // ---------------------------------------------
  // PARALLEL DOWNLOAD LIMIT CONTROL (FIXED)
  // ---------------------------------------------
  final maxParallel = FFAppState().parallelDownloads ?? 0;

  if (maxParallel > 0) {
    while (activeDownloads >= maxParallel) {
      print(
          "Parallel limit reached ($activeDownloads/$maxParallel). Waiting...");
      await Future.delayed(Duration(milliseconds: 300));
    }
  }

  // Reserve slot
  activeDownloads++;
  print("Slot taken. Active Downloads = $activeDownloads");

  // ---------------------------------------------
  // LOAD ITEM
  // ---------------------------------------------
  var list = FFAppState().downloadsList.toList();
  var index = list.indexWhere((d) => d.id == fileId);
  if (index == -1) {
    activeDownloads--;
    return;
  }

  var item = list[index];

  // ---------------------------------------------
  // AUTO FILENAME USING item.fileName + NO DUPLICATE
  // ---------------------------------------------
  String fileName = item.fileName ?? url.split("/").last;

  // Split base + extension
  String base = fileName;
  String? ext;
  int dotIndex = fileName.lastIndexOf(".");
  if (dotIndex != -1) {
    base = fileName.substring(0, dotIndex);
    ext = fileName.substring(dotIndex);
  }

  // Build file path
  String finalPath = "$savePath/$fileName";
  int counter = 1;

  // If file exists → append _1, _2, _3...
  while (File(finalPath).existsSync()) {
    finalPath = "$savePath/${base}_$counter${ext ?? ''}";
    counter++;
  }

  // Update state before download
  item.status = "downloading";
  item.downloaded = 0;
  item.speed = 0;
  item.savePath = finalPath;

  list[index] = item;
  FFAppState().downloadsList = list;
  FFAppState().update(() {});

  try {
    final file = File(finalPath);
    if (!file.parent.existsSync()) {
      file.parent.createSync(recursive: true);
    }

    final sink = file.openWrite(mode: FileMode.write);

    final client = HttpClient();
    final req = await client.getUrl(Uri.parse(url));
    final res = await req.close();

    int totalSize = res.contentLength;
    int downloaded = 0;

    // REAL SPEED VARIABLES
    int lastDownloaded = 0;
    int lastCheck = DateTime.now().millisecondsSinceEpoch;

    // ---------------------------------------------
    // MAIN DOWNLOAD LOOP
    // ---------------------------------------------
    await for (final chunk in res) {
      sink.add(chunk);
      downloaded += chunk.length;

      // REAL SPEED (bytes/sec)
      int now = DateTime.now().millisecondsSinceEpoch;
      int elapsed = now - lastCheck;

      if (elapsed >= 1000) {
        item.speed = downloaded - lastDownloaded;
        lastDownloaded = downloaded;
        lastCheck = now;
      }

      // SPEED LIMIT
      final limit = FFAppState().downloadSpeedLimit;
      if (!(limit == null || limit == 0)) {
        if (item.speed > limit) {
          int delayMs =
              (((item.speed - limit) / limit) * 1000).clamp(5, 300).toInt();
          await Future.delayed(Duration(milliseconds: delayMs));
        }
      }

      // REFRESH STATE
      list = FFAppState().downloadsList.toList();
      index = list.indexWhere((d) => d.id == fileId);
      if (index == -1) break;

      item = list[index];

      // PAUSE
      if (item.status == "paused") {
        await sink.flush();
        await sink.close();
        client.close(force: true);

        activeDownloads = (activeDownloads - 1).clamp(0, 9999);
        print("Paused. Active = $activeDownloads");

        return;
      }

      // CANCEL
      if (item.status == "cancelled") {
        await sink.flush();
        await sink.close();
        client.close(force: true);

        if (file.existsSync()) file.deleteSync();

        activeDownloads = (activeDownloads - 1).clamp(0, 9999);
        print("Cancelled. Active = $activeDownloads");

        return;
      }

      // UPDATE
      item.totalSize = totalSize;
      item.downloaded = downloaded;
      item.status = "downloading";

      list[index] = item;
      FFAppState().downloadsList = list;
      FFAppState().update(() {});
    }

    // FINISH DOWNLOAD
    await sink.flush();
    await sink.close();
    client.close(force: true);

    list = FFAppState().downloadsList.toList();
    index = list.indexWhere((d) => d.id == fileId);

    if (index != -1) {
      item = list[index];
      item.status = "completed";
      item.speed = 0;

      list[index] = item;
      FFAppState().downloadsList = list;
      FFAppState().update(() {});
    }

    activeDownloads = (activeDownloads - 1).clamp(0, 9999);
    print("Completed. Active = $activeDownloads");
  } catch (e, st) {
    print("downloadFile ERROR: $e");
    print(st);

    activeDownloads = (activeDownloads - 1).clamp(0, 9999);
    print("Error. Active = $activeDownloads");
  }
}