import scala.concurrent._
import scala.concurrent.duration._
import ExecutionContext.Implicits.global

// 创建 Future
val future = Future {
    Thread.sleep(1000)
    42
}

// 回调
future.onComplete {
    case Success(value) => println(s"Got: $value")
    case Failure(ex) => println(s"Error: ${ex.getMessage}")
}

// 转换
val doubled = future.map(_ * 2)
val filtered = future.filter(_ > 10)
val recovered = future.recover { case _ => 0 }

// 组合
val f1 = Future(1)
val f2 = Future(2)

// for 推导式
val result = for {
    a <- f1
    b <- f2
} yield a + b

// 或 zip
val zipped = f1.zip(f2).map { case (a, b) => a + b }

// 等待结果 (测试用)
val value = Await.result(future, 5.seconds)

// Promise: 手动完成 Future
val promise = Promise[Int]()
val future = promise.future

// 在另一个线程中完成
Future {
    Thread.sleep(1000)
    promise.success(42)
}

// 完成方式
// promise.success(value)
// promise.failure(exception)
// promise.trySuccess(value)  // 不抛异常
// promise.tryFailure(ex)

import akka.actor._

// 定义消息
case class Greet(name: String)
case class Reply(message: String)

// 定义 Actor
class Greeter extends Actor {
    def receive = {
        case Greet(name) =>
            println(s"Hello, $name!")
            sender() ! Reply(s"Hello, $name!")
        case msg =>
            println(s"Unknown message: $msg")
    }
}

// 创建和使用
val system = ActorSystem("MySystem")
val greeter = system.actorOf(Props[Greeter], "greeter")

greeter ! Greet("Alice")
greeter ! Greet("Bob")

// system.terminate()

import scala.concurrent._
import scala.concurrent.duration._
import ExecutionContext.Implicits.global

def fetchUrl(url: String): Future[String] = Future {
    // 模拟 HTTP 请求
    Thread.sleep(scala.util.Random.nextInt(1000))
    s"Response from $url"
}

val urls = List(
    "https://api1.example.com",
    "https://api2.example.com",
    "https://api3.example.com"
)

// 并发执行所有请求
val futures = urls.map(fetchUrl)
val allResults = Future.sequence(futures)

// 等待所有完成
val results = Await.result(allResults, 10.seconds)
results.foreach(println)

// 带超时的版本
val withTimeout = Future.firstCompletedOf(
    futures :+ Future.failed(new TimeoutException("Timeout"))
)