//注意,这两个actor会并行执行,当其中一个for循环结束后,actor结束

object ActorDemo01 {

  def main(args: Array[String]): Unit = {

    MyActor1.start()

    MyActor2.start()

  }

}

object MyActor1 extends Actor{

  override def act(): Unit = {

    for (i <- 1 to 10){

      println(s"actor => $i")

      Thread.sleep(2000)

    }

  }

  object MyActor2 extends Actor{

    override def act(): Unit = {

      for (i <- 1 to 5){

        println(s"actor2 => $i")

        Thread.sleep(2000)

      }

    }

  }

}

object ActorDemo02 {

  def main(args: Array[String]): Unit = {

    val actor: MyActor = new MyActor

    actor.start()

    //并行执行

    actor ! "start"  // !->异步

    actor ! "stop"

    println("发送完成")

  }

}

class MyActor extends Actor{

  override def act(): Unit = {

    while (true){   //死循环

      receive {   //接收

        case "start" => {

          println("starting")

          Thread.sleep(1000)

          println("started")

        }

        case "stop" => {

          println("stopping")

          Thread.sleep(1000)

          println("stopped")

        }

      }

    }

  }

}

object ActorDemo03 {

  def main(args: Array[String]): Unit = {

    val actor: MyActor3 = new MyActor3

    actor.start()

    actor ! "start"

    actor ! "stop"

    println("成功了")

  }

}

class MyActor3 extends Actor{

  override def act(): Unit = {

    loop {

      react{

        case "start" =>{

          println("starting")

          Thread.sleep(1000)

          println("sarted")

        }

        case "stop" =>{

          println("stoppting")

          Thread.sleep(1000)

          println("stopped")

        }

      }

    }

  }

}

//创建样例类

case class AsyncMsg(id: Int, msg: String)

case class SyncMsg(id: Int, msg: String)

case class ReplyMsg(id: Int, msg: String)

object ActorDemo01 extends Actor {

  override def act(): Unit = {

    while (true) {

      receive {

        case "start" => println("starting...")

        case AsyncMsg(id, msg) =>

        {

          println(s"id:$id,msg:$msg")

          sender ! ReplyMsg(1,"sucess")  //接收到消息后返回响应消息

        }

        case SyncMsg(id,msg) => {

          println(s"id:$id,msg:$msg")

          sender ! ReplyMsg(2,"sucess")

        }

      }

    }

  }

}

object ActorTest{

  def main(args: Array[String]): Unit = {

    val actor: Actor = ActorDemo01.start()

//    //异步发送消息,没有返回值

//    actor ! AsyncMsg(3,"heihei")

//    println("异步消息发送完成,没有返回值")

//    //同步发送消息,有返回值

//    val text: Any = actor !? SyncMsg(4,"OK")

//    println(text)

//    println("同步消息发送成功")

    //异步发送消息,有返回值,返回类型为Future[Any]

    val reply: Future[Any] = actor !! SyncMsg(5,"OK is 不存在的")

    Thread.sleep(2000)

    if (reply.isSet){

      val applyMsg: Any = reply.apply()

      println(applyMsg)

    }else{

      println("Nothing")

    }

  }

}

class Task extends Actor {

  override def act(): Unit = {

    loop {

      react {

        case SubmitTask(fileName) => {

          val contents = Source.fromFile(new File(fileName)).mkString

          val arr = contents.split("\r\n")

          val result = arr.flatMap(_.split(" ")).map((_, 1)).groupBy(_._1).mapValues(_.length)

          //val result = arr.flatMap(_.split(" ")).map((_, 1)).groupBy(_._1).mapValues(_.foldLeft(0)(_ + _._2))

          sender ! ResultTask(result)

        }

        case StopTask => {

          exit()

        }

      }

    }

  }

}

object WorkCount {

  def main(args: Array[String]) {

    val files = Array("c://words.txt", "c://words.log")

    val replaySet = new mutable.HashSet[Future[Any]]

    val resultList = new mutable.ListBuffer[ResultTask]

    for(f <- files) {

      val t = new Task

      val replay = t.start() !! SubmitTask(f)

      replaySet += replay

    }

    while(replaySet.size > 0){

      val toCumpute = replaySet.filter(_.isSet)

      for(r <- toCumpute){

        val result = r.apply()

        resultList += result.asInstanceOf[ResultTask]

        replaySet.remove(r)

      }

      Thread.sleep(100)

    }

    val finalResult = resultList.map(_.result).flatten.groupBy(_._1).mapValues(x => x.foldLeft(0)(_ + _._2))

    println(finalResult)

  }

}

case class SubmitTask(fileName: String)

case object StopTask

case class ResultTask(result: Map[String, Int])