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

import akka.actor.ActorSystem
import models.{OrderPlaced, UserRecognized}
import play.api.BuiltInComponents

import scala.concurrent.ExecutionContext

trait DaoModule extends BuiltInComponents {

  import com.softwaremill.macwire.wire
  import com.softwaremill.tagging._

  implicit def ec: ExecutionContext =
    ExecutionContext.global
  implicit def sys: ActorSystem =
    actorSystem

  private def userTopic =
    "users".taggedWith[UserRecognized]
  private def orderTopic = "orders".taggedWith[OrderPlaced]

  lazy val orderDao: EventDao[OrderPlaced] =
    wire[KafkaDao[OrderPlaced]]
  lazy val userDao: EventDao[UserRecognized] =
    wire[KafkaDao[UserRecognized]]
} 

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

import akka.actor.{ActorRef, Props}
import com.softwaremill.macwire.wire
import config.HomeControllerConfiguration
import model.actuator.impl.ActuatorRepositoryNaive
import mqtt.clown.BridgeListener
import mqtt.watering.{WateringCommander, WateringHelloListener, WateringListener}
import mqtt.{MqttConnector, MqttDispatchingListener, MqttListenerMessage, MqttRepeater}
import play.api.BuiltInComponents


trait MqttConfig extends BuiltInComponents with DaoConfig with ClockConfig {
  lazy val mqttDispatchingListener: MqttDispatchingListener = wire[MqttDispatchingListener]
  lazy val mqttConnector = new MqttConnector(
    HomeControllerConfiguration(
      mqttBrokerUrl = configuration.getString("home_center.mqtt.url").get,
      mqttClientId = configuration.getString("home_center.mqtt.clientId").get
    ),
    mqttDispatchingListener,
    actorSystem
  )
  lazy val wateringCommander = wire[WateringCommander]

  lazy val actuatorRepository: ActuatorRepositoryNaive = wire[ActuatorRepositoryNaive]

  lazy val wateringListener: ActorRef = actorSystem.actorOf(Props(wire[WateringListener]))
  lazy val wateringHelloListener: ActorRef = actorSystem.actorOf(Props(wire[WateringHelloListener]))
  lazy val bcBridgeListenerActor: ActorRef = actorSystem.actorOf(Props(wire[BridgeListener]))
  lazy val mqttRepeaterActor: ActorRef = actorSystem.actorOf(Props(
    new MqttRepeater(
      HomeControllerConfiguration(
        configuration.getString("home_center.mqtt_repeater.url").orNull,
        configuration.getString("home_center.mqtt_repeater.clientId").orNull
      ),
      actorSystem,
      mqttConnector
    )
  ))

  def initializeListeners(): Unit = {
    mqttConnector.reconnect.run()

    bcBridgeListenerActor ! MqttListenerMessage.Ping
    wateringListener ! MqttListenerMessage.Ping
    wateringHelloListener ! MqttListenerMessage.Ping
    mqttRepeaterActor ! MqttListenerMessage.Ping

    mqttDispatchingListener.addListener(bcBridgeListenerActor.path)
    mqttDispatchingListener.addListener(wateringListener.path)
    mqttDispatchingListener.addListener(wateringHelloListener.path)
    mqttDispatchingListener.addListener(mqttRepeaterActor.path)
  }
} 

//设置package包名称以及导入依赖的类
import org.scalatest.{Suite, TestData}
import org.scalatestplus.play.{OneAppPerSuite, OneAppPerTest, OneServerPerSuite, OneServerPerTest}
import play.api.{BuiltInComponents, _}

trait OneAppPerTestWithComponents[T <: BuiltInComponents]
  extends OneAppPerTest
    with WithApplicationComponents[T] {
  this: Suite =>

  override def newAppForTest(testData: TestData): Application = newApplication
}

trait OneAppPerSuiteWithComponents[T <: BuiltInComponents]
  extends OneAppPerSuite
    with WithApplicationComponents[T] {
  this: Suite =>
  override implicit lazy val app: Application = newApplication
}

trait OneServerPerTestWithComponents[T <: BuiltInComponents]
  extends OneServerPerTest
    with WithApplicationComponents[T] {
  this: Suite =>

  override def newAppForTest(testData: TestData): Application = newApplication
}

trait OneServerPerSuiteWithComponents[T <: BuiltInComponents]
  extends OneServerPerSuite
    with WithApplicationComponents[T] {
  this: Suite =>

  override implicit lazy val app: Application = newApplication
} 

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

import chat.ChatEngine
import play.api.{ApplicationLoader, BuiltInComponents, BuiltInComponentsFromContext, LoggerConfigurator}
import com.softwaremill.macwire._
import controllers.AssetsComponents
import play.api.inject.DefaultApplicationLifecycle
import play.engineio.EngineIOController
import play.socketio.scaladsl.SocketIOComponents

class MyApplicationLoader extends ApplicationLoader {
  override def load(context: ApplicationLoader.Context) =
    new BuiltInComponentsFromContext(context) with MyApplication {
      LoggerConfigurator.apply(context.environment.classLoader)
        .foreach(_.configure(context.environment))
    }.application
}

trait MyApplication extends BuiltInComponents
  with AssetsComponents
  with SocketIOComponents {

  override def applicationLifecycle: DefaultApplicationLifecycle

  lazy val chatEngine = wire[ChatEngine]
  lazy val engineIOController: EngineIOController = chatEngine.controller

  override lazy val router = {
    val prefix = "/"
    wire[_root_.router.Routes]
  }
  override lazy val httpFilters = Nil
} 

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

import chat.ChatEngine
import play.api.{ApplicationLoader, BuiltInComponents, BuiltInComponentsFromContext, LoggerConfigurator}
import com.softwaremill.macwire._
import controllers.AssetsComponents
import play.api.inject.DefaultApplicationLifecycle
import play.engineio.{EngineIOComponents, EngineIOController}
import play.socketio.scaladsl.SocketIOComponents

class MyApplicationLoader extends ApplicationLoader {
  override def load(context: ApplicationLoader.Context) =
    new BuiltInComponentsFromContext(context) with MyApplication {
      LoggerConfigurator.apply(context.environment.classLoader)
        .foreach(_.configure(context.environment))
    }.application
}

trait MyApplication extends BuiltInComponents
  with AssetsComponents
  with SocketIOComponents {

  override def applicationLifecycle: DefaultApplicationLifecycle

  lazy val chatEngine = wire[ChatEngine]
  lazy val engineIOController: EngineIOController = chatEngine.controller

  override lazy val router = {
    val prefix = "/"
    wire[_root_.router.Routes]
  }
  override lazy val httpFilters = Nil
} 

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

import org.scalatest.TestSuite
import org.scalatestplus.play._
import play.api.{BuiltInComponents, _}
import play.api.ApplicationLoader.Context
import play.api._


trait OneAppPerTestWithComponents[T <: BuiltInComponents]
    extends BaseOneAppPerTest
    with FakeApplicationFactory
    with WithApplicationComponents[T] { this: TestSuite =>
}

trait OneAppPerSuiteWithComponents[T <: BuiltInComponents]
    extends BaseOneAppPerSuite
    with FakeApplicationFactory
    with WithApplicationComponents[T] { this: TestSuite =>
}

trait OneServerPerTestWithComponents[T <: BuiltInComponents]
    extends BaseOneServerPerTest
    with FakeApplicationFactory
    with WithApplicationComponents[T] { this: TestSuite =>

}

trait OneServerPerSuiteWithComponents[T <: BuiltInComponents]
    extends BaseOneServerPerSuite
    with FakeApplicationFactory
    with WithApplicationComponents[T] { this: TestSuite =>

}

trait WithApplicationComponents[T <: BuiltInComponents] {
  private var _components: T = _

  // accessed to get the components in tests
  final def components: T = _components

  // overridden by subclasses
  def createComponents(context: Context): T

  // creates a new application and sets the components
  def fakeApplication(): Application = {
    _components = createComponents(context)
    _components.application
  }

  def context: ApplicationLoader.Context = {
    val classLoader = ApplicationLoader.getClass.getClassLoader
    val env = new Environment(new java.io.File("."), classLoader, Mode.Test)
    ApplicationLoader.createContext(env)
  }
} 

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

import play.api.ApplicationLoader.Context
import play.api.inject.ApplicationLifecycle
import play.api.{BuiltInComponents, ApplicationLoader}

import scala.concurrent.Future

trait SwaggerApplicationLoader extends ApplicationLoader {
  def components(context: Context) : BuiltInComponents

  def load(context: Context) = {
    val comp = components(context)
    val application = comp.application
    val life : ApplicationLifecycle = new ApplicationLifecycle() {
      override def addStopHook(hook: () => Future[Unit]): Unit = ()
    }
    new SwaggerPluginImpl(life, comp.router, application)
    application
  }
} 

//设置package包名称以及导入依赖的类
import org.scalatest.{Suite, TestData}
import org.scalatestplus.play._
import play.api.{BuiltInComponents, _}

trait OneAppPerTestWithComponents[T <: BuiltInComponents]
  extends OneAppPerTest
    with WithApplicationComponents[T] {
  this: Suite =>

  override def newAppForTest(testData: TestData): Application = newApplication
}

trait OneAppPerSuiteWithComponents[T <: BuiltInComponents]
  extends OneAppPerSuite
    with WithApplicationComponents[T] {
  this: Suite =>
  override implicit lazy val app: Application = newApplication
}

trait OneServerPerTestWithComponents[T <: BuiltInComponents]
  extends OneServerPerTest
    with WithApplicationComponents[T] {
  this: Suite =>

  override def newAppForTest(testData: TestData): Application = newApplication
}

trait OneServerPerSuiteWithComponents[T <: BuiltInComponents]
  extends OneServerPerSuite
    with WithApplicationComponents[T] {
  this: Suite =>

  override implicit lazy val app: Application = newApplication
}