void futureUse1() {
  print('1');

  Future(() {
    print('异步任务');
  });

  print('2');

  /*
    flutter: 1
    flutter: 2
    flutter: 异步任务
  */
}

void futureUse3() {
  print('1');

  Future f = Future(() {
    print('异步任务');
    throw Exception('抛出异常');
  });

  Future f1 = f.then((result) {
    print('result = ${result}');
  });

  Future f2 = f.catchError((error) {
    print('error = ${error}');
  });

  print(f == f1); // false
  print(f1 == f2); // false

  print('2');

  /*
    flutter: 1
    flutter: false
    flutter: false
    flutter: 2
    flutter: 异步任务
    flutter: error = Exception: 抛出异常
  */

  /**
    * //f.then其实可以传递两个参数，一个是成功的回调，一个是失败的回调
    * //所以，我们也可以通过下面的方式来执行失败回调
    * f.then((result){}, onError:(error){})
    */

  // f.then((result){
  //   print('result1 = ${result}');
  // },onError:(error){
  //   print('error1 = ${error}');
  // });
}

void futureUse5() {
  print('1');

  Future(() {
    print('异步任务');
    return '异步任务完成';
  }).then((result) {
    print('result = ${result}');
  }).catchError((error) {
    print('error = ${error}');
  }).whenComplete(() {
    print('complete');
  });

  print('2');

  /**
    flutter: 1
    flutter: 2
    flutter: 异步任务
    flutter: result = 异步任务完成
    flutter: complete
    */
}

//1、async 和 await 的使用
void awaitUse1() async {
  print('1');

  var result = await Future(() {
    print('异步任务');
    return '异步任务完成';
  });

  print('result = ${result}');

  print('2');

  /**
    flutter: 1
    flutter: 调用结束，执行外部代码
    flutter: 异步任务
    flutter: result = 异步任务完成
    flutter: 2
  */

  /**
    1、后面的操作必须是异步才能用await
    2、当前函数必须是异步函数
    3、await的作用范围是其后所有的代码（也就是说await后边的代码是同步执行）；
  */
}

//2、分析代码执行顺序
void awaitUse2() {
  Future<int> testFunc2() async {
    print('4');
    Future f1 = Future(() {
      print('5');
    });
    print('6');
    await f1;
    print('7');
    return 5;
  }

  void testFunc1() async {
    print('1');
    Future<int> f2 = testFunc2();
    print('2 - ${f2}');
    int reuslt = await f2;
    print("f2 value: $reuslt");
    print('3');
  }

  print('0');
  testFunc1();
  print('8');

  /**
    flutter: 0
    flutter: 1
    flutter: 4
    flutter: 6
    flutter: 2 - Instance of 'Future<int>'
    flutter: 8
    flutter: 调用结束，执行外部代码
    flutter: 5
    flutter: 7
    flutter: f2 value: 5
    flutter: 3     
  */


  /**
    * var f = Future((){}) 这是Future的一个构造函数，返回一个Future的实例对象f，f包装的是一个异步任务。
    * 要想拿到f的异步任务的结果有两种方式：
    * f.then((result){}); 和 var result = await f;
    * 
    * 注意：var f1 = f.then((result){}); 返回的是另外一个Future实例对象f1。
  */
}

// 3_1、任务依赖及异常捕获_拆开分析
void addTaskShow3_1() {
  var f = Future(() {
    return '第一次回调'; //该匿名函数执行完成调用callBack
  });

  var callBack = (value) {
    debugPrint('f.then:$value');
    return '第二次回调'; //该匿名函数执行完成调用callBack1
  };
  var f1 = f.then(callBack);

  var callBack1 = (value) {
    debugPrint('f1.then:$value');
  };
  f1.then(callBack1);
}

// 3_2、任务依赖及异常捕获_拆开分析
void addTaskShow3_2() {
  var f = Future(() {
    return '第一次回调'; //该匿名函数执行完成调用callBack
  });

  var callBack = (value) {
    debugPrint('f.then:$value');

    var inF = Future.delayed(Duration(seconds: 2), () {
      return '第二次回调'; //该匿名函数执行完成调用callBack1
    });
    return inF; //如果返回的是一个Future的实例对象，不会立即调用callBack1
  };
  var f1 = f.then(callBack);

  var callBack1 = (value) {
    debugPrint('f1.then:$value');
  };
  f1.then(callBack1);
}

Future<String> getUserInfo() {
  // 假设这是获取用户信息的异步任务
  return Future.delayed(
    const Duration(seconds: 2),
    () => "John Doe",
  );
}

Future<List<String>> getOrderList(String username) {
  // 假设这是根据用户名获取订单列表的异步任务
  return Future.delayed(
    const Duration(seconds: 3),
    () => ["Order #1", "Order #2", "Order #3"],
  );
}

Future<double> getTotalOrderAmount(List<String> orders) {
  // 假设这是根据订单列表获取总订单金额的异步任务
  return Future.delayed(
    const Duration(seconds: 2),
    () => orders.length * 50.0,
  );
}

getUserInfo().then((username) {
  debugPrint('第1个回调: $username');
  return getOrderList(username); //注意：返回的是Future的实例对象
}).then((orders) {
  debugPrint('第2个回调: $orders');
  return getTotalOrderAmount(orders);
}).then((totalAmount) {
  debugPrint('第3个回调: $totalAmount');
  debugPrint("Total order amount: \$$totalAmount");
}).catchError((error) {
  debugPrint("Error: $error");
});

/**
  flutter: 调用结束，执行外部代码
  flutter: 第1个回调: John Doe
  flutter: 第2个回调: [Order #1, Order #2, Order #3]
  flutter: 第3个回调: 150.0
  flutter: Total order amount: $150.0    
*/

try {
  var userName = await getUserInfo();
  debugPrint('username = $userName');
  var orders = await getOrderList(userName);
  debugPrint('orders = $orders');
  var total = await getTotalOrderAmount(orders);
  debugPrint('total = $total');
} catch (e) {
  debugPrint('error = $e');
}

void addTaskShow6() {
  Future.wait([
    Future(() {
      sleep(Duration(seconds: 1));
      print('执行任务1');
      return '任务1';
    }),
    Future(() {
      print('执行任务2');
      return '任务2';
    })
  ]).then((values) {
    print(values[0] + values[1]);
  });

/**
  执行效率没有任何区别。执行顺序也没有区别，先执行1再执行2。区别就是then会在两个任务都执行完之后才会调用。
  flutter: 调用结束，执行外部代码
  flutter: 执行任务1
  flutter: 执行任务2
  flutter: 任务1任务2
*/
}

void microtaskTest4() {
  Future f = Future(() => null);
  f.then((value) {
    debugPrint('1');
    scheduleMicrotask(() => debugPrint('2'));
  }).then(
    (value) => debugPrint('3'),
  );

  Future f1 = Future(() => debugPrint('4'));
  f1.then((value) {
    debugPrint('5');
    Future(() => debugPrint('6'));
  }).then(
    (value) => debugPrint('7'),
  );

  Future(() => debugPrint('8'));

  scheduleMicrotask(() {
    debugPrint('9');
  });

  /**
    flutter: 调用结束，执行外部代码
    flutter: 9
    flutter: 1
    flutter: 3
    flutter: 2
    flutter: 4
    flutter: 5
    flutter: 7
    flutter: 8
    flutter: 6    
  */
}