//设置package包名称以及导入依赖的类
package com.packt.chapter10

import akka.actor.{Actor, ActorLogging}
import com.typesafe.akka.extension.quartz.QuartzSchedulerExtension

object MessageQuartzScheduler {
  case object Every2Seconds
}

class MessageQuartzScheduler extends Actor with ActorLogging {
  import MessageQuartzScheduler._

  override def preStart() = {
    QuartzSchedulerExtension(context.system).schedule("Every2Seconds", self, Every2Seconds)
  }

  override def postStop() = {
    QuartzSchedulerExtension(context.system).cancelJob("Every2Seconds")
  }

  def receive = {
    case x => log.info(s"Received $x")
  }
} 

//设置package包名称以及导入依赖的类
package controllers

import javax.inject._
import akka.actor.{Props, ActorSystem}
import com.typesafe.akka.extension.quartz.QuartzSchedulerExtension
import play.api.inject.ApplicationLifecycle
import play.api.mvc._


  def index = Action {
    onStart()
    Ok(views.html.index("Your new application is ready."))
  }

  def onStart(): Unit = {
    val system = ActorSystem("SampleSystem")
    val scheduler = QuartzSchedulerExtension(actorSystem)
    val actor = system.actorOf(Props(classOf[SampleActor]))
    QuartzSchedulerExtension(system).schedule("Every1Second", actor, "1?")
    QuartzSchedulerExtension(system).schedule("Every5Seconds", actor, "5?")
  }
} 

//设置package包名称以及导入依赖的类
package modules

import play.api.db.slick.DatabaseConfigProvider
import play.api.inject.ApplicationLifecycle
import play.api.{Environment, Logger, Mode}

import actors.{AlertMail, SplashPost}
import akka.actor.{ActorRef, ActorSystem, Props}
import com.google.inject.{AbstractModule, Inject}
import com.typesafe.akka.extension.quartz.QuartzSchedulerExtension

import scala.concurrent.Future


class GlobalModule extends AbstractModule {
  override def configure() = {
    bind(classOf[GlobalSetting]).asEagerSingleton()
  }
}

class GlobalSetting @Inject()(lifecycle: ApplicationLifecycle, env: Environment, dbConfigProvider: DatabaseConfigProvider) {
  Logger.info("Start application...")

  if (!env.mode.equals(Mode.Dev)) startActor

  lifecycle.addStopHook { () =>
    Future.successful(null)
  }

  def startActor = {
    val system: ActorSystem = ActorSystem("BatchSystem")
    val alertMailActor: ActorRef = system.actorOf(Props(classOf[AlertMail], dbConfigProvider))
    val splashPostActor: ActorRef = system.actorOf(Props(classOf[SplashPost], dbConfigProvider))

    // TODO: send sns search result mail function
    // QuartzSchedulerExtension(system).schedule("AlertMailEveryHour", alertMailActor, "send sns alert mail")
    QuartzSchedulerExtension(system).schedule("SplashPostEveryHour", splashPostActor, "splash posts")

  }

} 

//设置package包名称以及导入依赖的类
package com.mpakhomov

import java.net.InetSocketAddress

import akka.actor.ActorSystem
import com.mpakhomov.actors.CandlestickAggregatorActor.GetDataForLastNMinutes
import com.mpakhomov.actors.ServerActor.SendDataForLastMinute
import com.mpakhomov.actors.{CandlestickAggregatorActor, EventProcessorActor, ServerActor, UpstreamClientActor}
import com.typesafe.config.ConfigFactory

object ServerApp {

  val cronJobName = "EveryMinute"

  def main(args: Array[String]): Unit = {
    val config = ConfigFactory.load()
    val system = ActorSystem("akka-io-demo")
    val candlestickAggregator = system.actorOf(CandlestickAggregatorActor.props(config.getInt("app.keep-data-minutes")))
    val eventProcessor = system.actorOf(EventProcessorActor.props(candlestickAggregator))
    val inetSocketAddress = new InetSocketAddress(
      config.getString("app.upstream.hostname"),
      config.getInt("app.upstream.port"))
    val upstreamClient = system.actorOf(UpstreamClientActor.props(inetSocketAddress, eventProcessor))
    val server = system.actorOf(ServerActor.props(
      new InetSocketAddress(config.getInt("app.server.port")),
      candlestickAggregator
    ))


    // schedule a job that runs at the beginning of every minute
    import com.typesafe.akka.extension.quartz.QuartzSchedulerExtension
    val scheduler = QuartzSchedulerExtension(system)
    scheduler.schedule(cronJobName, server, SendDataForLastMinute)
  }
} 

//设置package包名称以及导入依赖的类
package com.knoldus.scheduler

import com.knoldus.actors.LocalActorRefFactory
import com.knoldus.configuration.Configuration._
import com.knoldus.messages.{Message1, Message2}
import com.typesafe.akka.extension.quartz.QuartzSchedulerExtension

trait Scheduler {

  val localActorRefFactory: LocalActorRefFactory

  def schedule: Unit = {
    val _system = localActorRefFactory.system
    val firstReceiver = localActorRefFactory getReceiver NAME_FIRST_ACTOR
    val secondReceiver = localActorRefFactory getReceiver NAME_SECOND_ACTOR

    QuartzSchedulerExtension(_system).schedule(CRON_FIRST_EXPRESSION, firstReceiver, Message1)
    QuartzSchedulerExtension(_system).schedule(CRON_SECOND_EXPRESSION, secondReceiver, Message2)
  }

}

object Scheduler extends Scheduler{
  val localActorRefFactory: LocalActorRefFactory = LocalActorRefFactory
}