import 'dart:async';
import 'dart:convert';
import 'dart:io';
import 'dart:typed_data';

import 'package:dart_framework/utils/path.dart';
import 'package:yaml/yaml.dart';
import 'package:path/path.dart' as path;

const int intMax = 0x7FFFFFFFFFFFFFFF;
const int intMin = -0x8000000000000000;

bool isDebug = true;
String userPath = '';
String dataPath = '';
String scriptPath = '';
String executablePath = '';
String appIdendifier = '';
String appName = '';

Future initialize(String name, String appID) async {
  appIdendifier = appID;
  appName = name;
  scriptPath = Platform.script.toFilePath(windows: Platform.isWindows);
  executablePath = Platform.executable;
  isDebug =
      path.basenameWithoutExtension(Platform.resolvedExecutable) == 'dart';
  userPath = await Path.userPath;
  dataPath = await Path.dataPath;
}

Map<String, List<String>?> envArguments(List<String> arguments) {
  var dic = <String, List<String>?>{};
  var list = <String>[];
  var length = arguments.length;
  for (var i = 0; i < length; ++i) {
    var value = arguments[i];
    var key = _getKey(value);
    if (key != null) {
      var index = i + 1;
      list.clear();
      while (index < length) {
        var arg = arguments[index];
        if (_getKey(arg) == null) {
          list.add(arg);
          index++;
        } else {
          i = index - 1;
          break;
        }
      }
      List<String>? arr = List<String>.from(list);
      if (arr.isEmpty) arr = null;
      dic[key] = arr;
    }
  }
  return dic;
}

String? _getKey(String value) {
  String? key;
  if (value.indexOf('-') == 0) {
    key = value.substring(1, value.length);
  }
  return key;
}

Map<String, dynamic>? getMapFromJson(String jsonStr) {
  Map<String, dynamic>? map;
  if (jsonStr.length > 5) {
    JsonCodec codec = JsonCodec();
    try {
      map = codec.decode(jsonStr);
    } on Exception catch (e, stacktace) {
      print('Error: $e\n\n$stacktace');
    }
  }
  return map;
}

Map<String, dynamic>? getMapFromYaml(String yamlStr) {
  Map<String, dynamic>? map;
  if (yamlStr.length > 5) {
    try {
      map = jsonDecode(jsonEncode(loadYaml(yamlStr)));
    } on Exception catch (e, stacktace) {
      throw Exception('Yaml Pasing error.\n\n$stacktace');
    }
  }
  return map;
}

Future<String> getIPAddress(String domain) async {
  var c = Completer<String>();
  late String ipAddress;
  var regEx = RegExp(r'(://)([a-zA-Z0-9-.]+)(/|:)');
  var match = regEx.firstMatch(domain);
  if (match != null && match.groupCount > 2) {
    domain = match.group(2)!;
    var list = await InternetAddress.lookup(domain);
    for (var address in list) {
      ipAddress = address.address;
      break;
    }
  }
  c.complete(ipAddress);
  return c.future;
}

Future get simpleFuture {
  var c = Completer();
  c.complete();
  return c.future;
}

Future<T> dataFutrue<T>(T data) {
  var c = Completer<T>();
  c.complete(data);
  return c.future;
}

Future<Uint8List?> readFileByte(String filePath) async {
  var c = Completer<Uint8List>();
  Uri myUri = Uri.parse(filePath);
  File audioFile = File.fromUri(myUri);
  Uint8List? bytes;
  await audioFile.readAsBytes().then((value) {
    bytes = Uint8List.fromList(value);
    print('reading of bytes is completed');
  }).catchError((onError) {
    print('Exception Error while reading audio from path:$onError');
  });
  c.complete(bytes);
  return c.future;
}