import 'dart:io';
import 'dart:math';
import 'package:convert/convert.dart';
import 'package:crypto/crypto.dart';
import 'package:path/path.dart' as path;
import 'package:file_selector/file_selector.dart' as file_selector;
import 'package:path_provider/path_provider.dart';
import 'logger.dart';



bool isDirectory(String filePath) {
  return FileSystemEntity.isDirectorySync(filePath);
}

Future<bool> isDirectoryExists(String filePath) {
  return Directory(filePath).exists();
}

bool isFile(String filePath) {
  return FileSystemEntity.isFileSync(filePath);
}

String getDirectoryName(String filePath) {
  return path.dirname(filePath);
}

Future<bool> isFileExists(String filePath) {
  return File(filePath).exists();
}

String getFileName(String filePath) {
  return path.basename(filePath);
}

String getFileNameWithoutExtension(String filePath) {
  return path.basenameWithoutExtension(filePath);
}

String getFileExtension(String filePath, {int level = 1}) {
  return path.extension(filePath, level);
}

Future<int> fileSizeOf(filePath) async {
  final file = File(filePath);
  final size = await file.length();
  return size;
}

String formatFileSize(int bytes) {
  if (bytes <= 0) return "0 B";
  const suffixes = ["B", "KB", "MB", "GB", "TB", "PB", "EB"];
  var i = (log(bytes) / log(1024)).floor();
  return '${(bytes / pow(1024, i)).toStringAsFixed(2)} ${suffixes[i]}';
}

// MD5
Future<String> getFileMd5(String filePath) async {
  final fileExists = File(filePath).existsSync();
  if (!fileExists) throw FileSystemException("File does not exist", filePath);
  final file = File(filePath);
  final digest = await file.openRead().transform(md5).first;
  return hex.encode(digest.bytes);
}

Future<File?> createFile(String filePath) async {
  try {
    if (!await isFileExists(filePath)) {
      File file = await File(filePath).create(recursive: true);
      return file;
    } else {
      return File(filePath);
    }
  } catch (error) {
    return null;
  }
}

bool deleteFile(String filePath) {
  try {
    final file = File(filePath);
    file.deleteSync();
    return true;
  } catch (error) {
    return false;
  }
}


createFolder(String folderPath) async {
  // 创建文件夹
  final Directory folder = Directory(folderPath);
  // 如果文件夹不存在，则创建
  if (!await folder.exists()) {
    await folder.create(recursive: true);
  } else {
    Log.d("Folder already exists");
  }
}

copyDirectory(Directory source, Directory destination) async {
  await for (var entity in source.list(recursive: false)) {
    if (entity is Directory) {
      var newDirectory = Directory(
          path.join(destination.absolute.path, path.basename(entity.path)));
      await newDirectory.create(recursive: true);
      await copyDirectory(entity.absolute, newDirectory);
    } else if (entity is File) {
      await entity.copy(
          path.join(destination.path, path.basename(entity.path)));
    }
  }
}

clearDirectory(Directory directory) async {
  // 列出所有文件和文件夹
  var files = directory.listSync();

  // 遍历文件和文件夹
  for (var fileEntity in files) {
    if (fileEntity is File) {
      // 文件直接删除
      await fileEntity.delete();
    } else if (fileEntity is Directory) {
      // 文件夹则递归删除
      await clearDirectory(fileEntity);
      await fileEntity.delete();
    }
  }
}

deleteDirectory(String dirPath) async {
  final directory = Directory(dirPath);
  await directory.delete(recursive: true);
}