//设置package包名称以及导入依赖的类
import java.time.Clock

import com.google.inject.AbstractModule
import errorhandler.ErrorHandler
import helpers.{SemesterModeCache, SessionCache}
import logic.actors.database.DatabaseActor
import logic.actors.fakeactivity.FakeActivityActor
import logic.actors.rss.{DeleteNewsActor, NewsReaderActor, RSSParseActor}
import logic.actors.schedule._
import logic.actors.spread.TweetActor
import model.schedule.data.MSchedule
import play.api.libs.concurrent.AkkaGuiceSupport
import services.{DatabaseService, FakeActivity, NewsFeedReader, ScheduleParser}


class Module extends AbstractModule with AkkaGuiceSupport {

  override def configure() = {
    // Use the system clock as the default implementation of Clock
    bind(classOf[Clock]).toInstance(Clock.systemDefaultZone)
    // bind actors
    bindActor[RSSParseActor]("rssParser")
    bindActor[NewsReaderActor]("NewsReader")
    bindActor[DeleteNewsActor]("deleteNews")
    // Ask Guice to create an instance of NewsFeedReader when the
    // application starts.
    bind(classOf[NewsFeedReader]).asEagerSingleton()


    bindActor[CheckScheduleDateActor]("checkSchedule")
    bind(classOf[ScheduleParser]).asEagerSingleton()
    bind(classOf[FakeActivity]).asEagerSingleton()

    bindActor[ScheduleDownloadActor]("scheduleDownloader")
    bindActor[ShortCutParseActor]("shortcutParser")
    bindActor[ScheduleParseActor]("parseActor")
    bind(classOf[MSchedule])
    bindActor[GroupParseActor]("groupParseActor")
    bindActor[TweetActor]("tweetActor")
    bindActor[FakeActivityActor]("fakeActivityActor")

    bind(classOf[SemesterModeCache])
    bind(classOf[SessionCache])

    bindActor[DatabaseActor]("databaseActor")
    bind(classOf[DatabaseService]).asEagerSingleton()
  }

} 

//设置package包名称以及导入依赖的类
package au.id.tmm.senatedb.api

import java.nio.file.Paths

import au.id.tmm.senatedb.api.persistence.population.DbPopulationActor
import au.id.tmm.senatedb.core.engine.{ParsedDataStore, TallyEngine}
import au.id.tmm.senatedb.core.model.flyweights.PostcodeFlyweight
import au.id.tmm.senatedb.core.rawdata.{AecResourceStore, RawDataStore}
import com.google.inject.{AbstractModule, Provides, Singleton}
import play.api.libs.concurrent.AkkaGuiceSupport
import scalikejdbc.{ConnectionPool, ConnectionPoolContext, MultipleConnectionPoolContext}

class Module extends AbstractModule with AkkaGuiceSupport {

  override def configure(): Unit = {
    bindActor[DbPopulationActor]("dbPopulationActor")
  }

  @Provides
  def provideConnectionPoolContext(): ConnectionPoolContext =
    MultipleConnectionPoolContext(ConnectionPool.DEFAULT_NAME -> ConnectionPool())

  @Provides
  @Singleton
  def providePostcodeFlyweight: PostcodeFlyweight = PostcodeFlyweight()

  @Provides
  @Singleton
  def provideParsedDataStore(rawDataStore: RawDataStore): ParsedDataStore = ParsedDataStore(rawDataStore)

  @Provides
  @Singleton
  def provideRawDataStore(aecResourceStore: AecResourceStore): RawDataStore = RawDataStore(aecResourceStore)

  @Provides
  @Singleton
  def provideAecResourceStore: AecResourceStore = AecResourceStore.at(Paths.get("rawData"))

  @Provides
  def provideTallyEngine: TallyEngine = TallyEngine

} 

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


import play.api.{Configuration, Environment}
import play.api.inject.{Binding, Module}
import play.api.libs.concurrent.AkkaGuiceSupport

import actors.MailsendActor
import com.google.inject.AbstractModule
import schedulers.MailsendScheduler


class MailsendActorModule extends AbstractModule with AkkaGuiceSupport {
  override def configure() = {
    bindActor[MailsendActor]("mailsend-actor")
  }
}

class MailsendScheduleModule extends Module {
  override def bindings(environment: Environment, configuration: Configuration): Seq[Binding[_]] = {
    Seq(
      bind[MailsendScheduler].toSelf.eagerly
    )
  }
} 

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


import play.api.{Configuration, Environment}
import play.api.inject.{Binding, Module}
import play.api.libs.concurrent.AkkaGuiceSupport

import actors.HelloWorldActor
import com.google.inject.AbstractModule
import schedulers.HelloWorldScheduler


class HelloWorldActorModule extends AbstractModule with AkkaGuiceSupport {
  override def configure() = {
    bindActor[HelloWorldActor]("hello-world-actor")
  }
}

class HelloWorldScheduleModule extends Module {
  override def bindings(environment: Environment, configuration: Configuration): Seq[Binding[_]] = {
    Seq(
      bind[HelloWorldScheduler].toSelf.eagerly
    )
  }
} 

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


import play.api.{Configuration, Environment}
import play.api.inject.{Binding, Module}
import play.api.libs.concurrent.AkkaGuiceSupport

import actors.CustomerCountBatchActor
import com.google.inject.AbstractModule
import schedulers.CustomerCountBatchScheduler
import akka.actor.ActorSystem


class CustomerCountBatchActorModule extends AbstractModule with AkkaGuiceSupport {
  override def configure() = {
    bindActor[CustomerCountBatchActor]("CustomerCountBatch-actor")
  }
}

class CustomerCountBatchScheduleModule extends Module {

  override def bindings(environment: Environment, configuration: Configuration): Seq[Binding[_]] = {
    Seq(
      bind[CustomerCountBatchScheduler].toSelf.eagerly
    )
  }
} 

//设置package包名称以及导入依赖的类
import com.google.inject.AbstractModule
import java.time.Clock

import play.api.libs.concurrent.AkkaGuiceSupport
import services.actors.{UserFilesUpdateActor, NewUserActor}
import services.{ApplicationTimer, AtomicCounter, Counter, DropboxService}


class Module extends AbstractModule with AkkaGuiceSupport {

  override def configure() = {
    // Use the system clock as the default implementation of Clock
    bind(classOf[Clock]).toInstance(Clock.systemDefaultZone)
    // Ask Guice to create an instance of ApplicationTimer when the
    // application starts.
    bind(classOf[ApplicationTimer]).asEagerSingleton()
    bind(classOf[DropboxService]).asEagerSingleton()
    // Set AtomicCounter as the implementation for Counter.
    bind(classOf[Counter]).to(classOf[AtomicCounter])

    bindActor[NewUserActor]("new-user-actor")
    bindActor[UserFilesUpdateActor]("user-files-update-actor")
  }

} 

//设置package包名称以及导入依赖的类
import com.google.inject.AbstractModule
import java.time.Clock

import play.api.libs.concurrent.AkkaGuiceSupport
import services.{ApplicationTimer, AtomicCounter, Counter}


class Module extends AbstractModule with AkkaGuiceSupport {

  override def configure() = {
    // Use the system clock as the default implementation of Clock
    bind(classOf[Clock]).toInstance(Clock.systemDefaultZone)
    // Ask Guice to create an instance of ApplicationTimer when the
    // application starts.
    bind(classOf[ApplicationTimer]).asEagerSingleton()
    // Set AtomicCounter as the implementation for Counter.
    bind(classOf[Counter]).to(classOf[AtomicCounter])

//    bindActor[Character]("chatActor")
  }

} 

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

import javax.inject.{Inject, Named}

import actors.bots.IncidentActor
import actors.systems.ServiceManagerActor
import akka.actor.{ActorRef, ActorSystem}
import com.google.inject.AbstractModule
import play.api.libs.concurrent.AkkaGuiceSupport

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


class IncidentModule extends AbstractModule with AkkaGuiceSupport {
  def configure() = {
    bindActor[ServiceManagerActor]("ServiceManager-actor")
    bindActor[IncidentActor]("Incident-actor")
    bind(classOf[IncidentScheduler]).asEagerSingleton()
  }
}


class IncidentScheduler @Inject()(val system: ActorSystem, @Named("Incident-actor") val incidentActor: ActorRef)(implicit ec: ExecutionContext)
{
 // system.scheduler.schedule(   0.microseconds, 1.minutes, incidentActor,IncidentActor.Tick)

} 

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

import javax.inject.{Inject, Named}

import actors.systems.SlackTeamManager
import play.api.libs.concurrent.AkkaGuiceSupport
import akka.actor.{ActorRef, ActorSystem}
import com.google.inject.AbstractModule
import models.SlackSessionRepo
import play.api.Logger
import play.api.libs.concurrent.AkkaGuiceSupport

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


class SlackModule extends AbstractModule  with AkkaGuiceSupport {
  def configure() = {
    bindActor[SlackTeamManager]("SlackTeamManager-actor")
    bind(classOf[SlackTeamManagerLoader]).asEagerSingleton()
  }
}

class SlackTeamManagerLoader @Inject()(val system: ActorSystem,
                                       @Named("SlackTeamManager-actor") val teamManagerActor: ActorRef,
                                       @Named("DR-actor") val drActor: ActorRef,
                                       slackSessionRepo: SlackSessionRepo)(implicit ec: ExecutionContext)
{
  val logger = Logger.logger
  logger.warn("Slack Startup")
  //slackSessionRepo.createIt()

  teamManagerActor ! SlackTeamManager.Load(slackSessionRepo,drActor)

} 

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

import javax.inject.Inject

import akka.actor.{ActorRef, ActorSystem}
import com.google.inject.AbstractModule
import com.google.inject.name.Names
import com.yper.users.actors.UserActor
import play.api.libs.concurrent.AkkaGuiceSupport
import play.api.{Configuration, Environment}



class ActorFactoryModule @Inject() (
                                    environment: Environment,
                                    configuration: Configuration
                                   ) extends AbstractModule with AkkaGuiceSupport{

  override def configure(): Unit = {
    println(s"Configuring ActorFactoryModule!")
    val actorSystem = ActorSystem.create("YperActorSystem")

    lazy val userActor = actorSystem.actorOf(UserActor.props)
    bind(classOf[ActorRef])
      .annotatedWith(Names.named("userActor"))
      .toInstance(userActor);


    lazy val anotherUserActor = actorSystem.actorOf(UserActor.props)
    bind(classOf[ActorRef])
      .annotatedWith(Names.named("anotherUserActor"))
      .toInstance(anotherUserActor);

  }
} 

//设置package包名称以及导入依赖的类
import java.time.Clock

import com.google.inject.AbstractModule
import play.api.libs.concurrent.AkkaGuiceSupport
import modules.{Scheduler, SchedulerActor}
import services.{ApplicationTimer, AtomicCounter, Counter}

class Module extends AbstractModule with AkkaGuiceSupport{
  override def configure(): Unit = {
    // Use the system clock as the default implementation of Clock
    bind(classOf[Clock]).toInstance(Clock.systemDefaultZone)
    bind(classOf[ApplicationTimer]).asEagerSingleton()
    bind(classOf[Counter]).to(classOf[AtomicCounter])

    //akka scheduler
    bindActor[SchedulerActor]("scheduler-actor")
    bind(classOf[Scheduler]).asEagerSingleton()
  }
} 

//设置package包名称以及导入依赖的类
import com.google.inject.AbstractModule
import java.time.Clock

import services.{ApplicationTimer, WebSocketActor, WebSocketActorProvider, ListActor}
import play.api.{Environment, Configuration}
import play.api.libs.concurrent.AkkaGuiceSupport
import models.{UserRepository, SlickUserRepository, ItemRepository, SlickItemRepository}


class Module(environment: Environment, configuration: Configuration) extends AbstractModule with AkkaGuiceSupport {

  override def configure() = {
    // Use the system clock as the default implementation of Clock
    bind(classOf[Clock]).toInstance(Clock.systemDefaultZone)
    // Ask Guice to create an instance of ApplicationTimer when the
    // application starts.
    bind(classOf[ApplicationTimer]).asEagerSingleton()
    bind(classOf[UserRepository]).to(classOf[SlickUserRepository])
    bind(classOf[ItemRepository]).to(classOf[SlickItemRepository])

    bindActor[ListActor]("list-actor")
  }

} 

//设置package包名称以及导入依赖的类
import java.time.Clock

import com.google.inject.AbstractModule
import play.api.libs.concurrent.AkkaGuiceSupport
import services.{ApplicationTimer, SquarerTypedFactory, SquarerUntypedActor}


class Module extends AbstractModule with AkkaGuiceSupport {

  override def configure() = {
    // Use the system clock as the default implementation of Clock
    bind(classOf[Clock]).toInstance(Clock.systemDefaultZone)
    // Ask Guice to create an instance of ApplicationTimer when the
    // application starts.
    bind(classOf[ApplicationTimer]).asEagerSingleton()
    bindActor[SquarerUntypedActor]("squarerUntyped")
    bind(classOf[SquarerTypedFactory])
  }
} 

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

import com.google.inject.AbstractModule
import com.ning.http.client.AsyncHttpClientConfigBean
import net.codingwell.scalaguice.ScalaModule
import play.api.libs.concurrent.AkkaGuiceSupport
import play.api.libs.ws.WSClient
import play.api.libs.ws.ning.NingWSClient
import services.{DCOSAuthTokenActor, DefaultMarathonClientFactory, MarathonClientFactory}

class MetaDefaultDCOS extends AbstractModule with ScalaModule with AkkaGuiceSupport {

  override def configure(): Unit = {
    bind[MarathonClientFactory].to[DefaultMarathonClientFactory]
    bindActor[DCOSAuthTokenActor](DCOSAuthTokenActor.name)

    val config = new AsyncHttpClientConfigBean()
    config.setAcceptAnyCertificate(true)
    config.setFollowRedirect(true)
    val permissiveClient = NingWSClient(config)
    bind[WSClient].annotatedWithName("permissive-wsclient").toInstance(permissiveClient)
  }



} 

//设置package包名称以及导入依赖的类
import com.google.inject.AbstractModule
import java.time.Clock
import play.api.libs.concurrent.AkkaGuiceSupport

import services.{ApplicationTimer, AtomicCounter, Counter}
import actors._


class Module extends AbstractModule with AkkaGuiceSupport {

  override def configure() = {
    // Use the system clock as the default implementation of Clock
    bind(classOf[Clock]).toInstance(Clock.systemDefaultZone)
    // Ask Guice to create an instance of ApplicationTimer when the
    // application starts.
    bind(classOf[ApplicationTimer]).asEagerSingleton()
    // Set AtomicCounter as the implementation for Counter.
    bind(classOf[Counter]).to(classOf[AtomicCounter])
    bindActor[TemperatureActor]("temp-actor")
  }

} 

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

import javax.inject._

import akka.actor._
import com.google.inject.AbstractModule
import play.api.libs.concurrent.AkkaGuiceSupport

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

class SchedulerModule extends AbstractModule with AkkaGuiceSupport {
  def configure() = {
    bindActor[SchedulerActor]("scheduler")
    bind(classOf[SchedulerStart]) asEagerSingleton
  }
}

@Singleton
class SchedulerStart @Inject()(system: ActorSystem, @Named("scheduler") longRunningActor: ActorRef) {
  system.scheduler.schedule(10 seconds, 120 seconds, longRunningActor, CheckForRoundUps)
} 

//设置package包名称以及导入依赖的类
import com.google.inject.AbstractModule
import java.time.Clock

import Actors.{SentimentAPI, TagCounter, TweetActor, TwitterStreamActor}
import play.api.libs.concurrent.AkkaGuiceSupport
import services.{ApplicationTimer, AtomicCounter, Counter}


class Module extends AbstractModule with AkkaGuiceSupport{

  override def configure() = {
    // Use the system clock as the default implementation of Clock
    bind(classOf[Clock]).toInstance(Clock.systemDefaultZone)
    // Ask Guice to create an instance of ApplicationTimer when the
    // application starts.
    bind(classOf[ApplicationTimer]).asEagerSingleton()
    // Set AtomicCounter as the implementation for Counter.
    bind(classOf[Counter]).to(classOf[AtomicCounter])

//    bindActor[ConfiguredActor]("configured-actor")
    bindActor[TagCounter]("tag-counter-actor")
    bindActor[TweetActor]("tweet-actor")
    bindActor[TwitterStreamActor]("stream-actor")
    bindActor[SentimentAPI]("sentiment-actor")
  }

} 

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

import java.time.{Clock, ZoneId}

import akka.actor.{Actor, ActorRef, Props}
import com.google.api.client.googleapis.auth.oauth2.GoogleIdTokenVerifier
import com.google.api.client.http.javanet.NetHttpTransport
import com.google.api.client.json.jackson2.JacksonFactory
import com.google.api.client.util.store.AbstractDataStoreFactory
import com.google.inject.AbstractModule
import com.google.inject.name.Names
import com.google.inject.util.Providers
import controllers.AppController
import play.api.libs.concurrent.{Akka, AkkaGuiceSupport}
import services._
import services.support.SystemClock

import scala.reflect.ClassTag

class AppModule extends AbstractModule {
  def configure = {
    bind(classOf[AppController]).asEagerSingleton // in prod mode all dependencies of AppController get built at startup time
    bind(classOf[AbstractDataStoreFactory]).to(classOf[RepositoryDataStoreFactory])
    bind(classOf[GoogleIdTokenVerifier]).toInstance(new GoogleIdTokenVerifier.Builder(new NetHttpTransport, new JacksonFactory).build)
    bind(classOf[Clock]).toInstance(new SystemClock(ZoneId.systemDefault()))
  }
}

class AkkaModule extends AbstractModule with AkkaGuiceSupport {
  def configure = {
    bindActorNoEager[SuperSupervisorActor](SuperSupervisorActor.actorName)
    bindActorFactory[UserSupervisorActor, UserSupervisorActor.Factory]
  }

  private def bindActorNoEager[T <: Actor : ClassTag](name: String, props: Props => Props = identity): Unit = {
    binder.bind(classOf[ActorRef])
      .annotatedWith(Names.named(name))
      .toProvider(Providers.guicify(Akka.providerOf[T](name, props)))
  }
} 

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

import akka.actor.{Actor, ActorLogging, ActorSystem}
import lib.Cloudwatch
import com.google.inject.AbstractModule
import play.api.libs.concurrent.AkkaGuiceSupport
import scala.concurrent.ExecutionContext

class Bindings extends AbstractModule with AkkaGuiceSupport {
  def configure = {
    bindActor[MetricActor]("metric-actor")
  }
}

object MetricActor {
  object Messages {
    case class Send(server: String, method: String, path: String, ms: Long, response: Int, organization: Option[String], partner: Option[String])
  }
}

@javax.inject.Singleton
class MetricActor @javax.inject.Inject() (
  config: lib.Config,
  system: ActorSystem,
  cloudwatch: Cloudwatch
) extends Actor with ActorLogging {

  private[this] implicit val ec: ExecutionContext = system.dispatchers.lookup("metric-actor-context")

  def receive = akka.event.LoggingReceive {
    case msg @ MetricActor.Messages.Send(server, method, path, ms, response, organization, partner) => {
      cloudwatch.recordResponseTime(server, method, path, ms, response, organization, partner)
    }

    case msg: Any => // noop
  }

} 

//设置package包名称以及导入依赖的类
import javax.inject.Inject

import akka.actor.{ ActorRef, ActorSystem }
import akka.stream.Materializer
import com.github.j5ik2o.spetstore.adaptor.aggregate.{ CustomerMessageBroker, ItemTypeMessageBroker }
import com.github.j5ik2o.spetstore.adaptor.eventbus.EventBus
import com.google.inject.name.Names
import com.google.inject.{ AbstractModule, Provider }
import play.api.libs.concurrent.AkkaGuiceSupport

class EventBussProvider @Inject() (actorSystem: ActorSystem, materializer: Materializer) extends Provider[EventBus] {
  override def get(): EventBus = {
    EventBus.ofRemote(actorSystem)
  }
}

class CustomerAggregateProvider @Inject() (actorSystem: ActorSystem, eventBus: EventBus) extends Provider[ActorRef] {
  override def get(): ActorRef = {
    CustomerMessageBroker(eventBus)(actorSystem)
  }
}

class ItemTypeAggregateProvider @Inject() (actorSystem: ActorSystem, eventBus: EventBus) extends Provider[ActorRef] {
  override def get(): ActorRef = {
    ItemTypeMessageBroker(eventBus)(actorSystem)
  }
}

class Module extends AbstractModule with AkkaGuiceSupport {

  override def configure() = {
    bind(classOf[SharedJournalStarter]).asEagerSingleton()
    bind(classOf[EventBus])
      .toProvider(classOf[EventBussProvider])
      .asEagerSingleton()
    bind(classOf[ActorRef])
      .annotatedWith(Names.named("customer-aggregate"))
      .toProvider(classOf[CustomerAggregateProvider])
      .asEagerSingleton()
    bind(classOf[ActorRef])
      .annotatedWith(Names.named("item-type-aggregate"))
      .toProvider(classOf[ItemTypeAggregateProvider])
      .asEagerSingleton()
  }

}