Chatto-Desktop-ScalaFX/src/main/scala/wow/doge/chatto/ApplicationController.scala

package wow.doge.chatto

import javax.enterprise.context.ApplicationScoped
import javax.enterprise.inject.Produces
import javax.inject.Named
import com.typesafe.config.ConfigFactory
import com.sfxcode.sapphire.core.controller.DefaultWindowController
// import org.asynchttpclient.Dsl._
import wow.doge.chatto.controller.MainViewController
import sttp.client.asynchttpclient.future.AsyncHttpClientFutureBackend
import sttp.client._
import scala.concurrent.ExecutionContext.Implicits.global
import scala.async.Async.{async, await}
import sttp.client.json4s._
import org.json4s._
// import org.json4s.native.JsonMethods._
import org.json4s.jackson.JsonMethods._

import org.json4s.JsonDSL._
import scala.util.Success
import scala.util.Failure
import com.softwaremill.quicklens._
import org.scalafx.extras._
import wow.doge.chatto.service.UserService
import javax.inject._
import javafx.application.Platform
import com.sfxcode.sapphire.core.controller.SceneControllerDidChangeEvent
import javax.enterprise.event.Observes
import com.sfxcode.sapphire.core.controller.SceneControllerWillChangeEvent
@Named
@ApplicationScoped
class ApplicationController extends DefaultWindowController {
  // import ApplicationController._

  lazy val mainViewController = getController[MainViewController]()
  private implicit lazy val serialization = org.json4s.jackson.Serialization
  private implicit lazy val backend = AsyncHttpClientFutureBackend()

  // override def width: Int = 400

  @Inject
  private var appDataHandler: AppDataHandler = _

  def applicationDidLaunch() = {
    logger.info("start " + this)
    applicationEnvironment.loadResourceBundle("bundles/application")
    replaceSceneContent(mainViewController)
  }

  @Produces
  def applicationName: ApplicationName = {
    ApplicationName(configStringValue("application.name"))
  }
  @Produces
  def httpBackend = backend

  def replacePrimarySceneContent(): Unit = {
    // Styling
    reloadStyles()
    // Resources
    applicationEnvironment.clearResourceBundleCache()
    applicationEnvironment.loadResourceBundle("bundles/application")
    // FXML
    val newMainViewController = getController[MainViewController]()
    replaceSceneContent(newMainViewController)
  }

  def testListener(@Observes event: SceneControllerWillChangeEvent) = {
    logger.info("test success 1")
    // logger.info(s"${event.newController}")
  }

  def testListener2(@Observes event: SceneControllerDidChangeEvent) = {
    logger.info("test success 2")
    // logger.info(s"${event.newController}")
  }

  override def applicationWillStop(): Unit = async {
    super.applicationWillStop()
    println("stopping")
    await(httpBackend.close())
    Platform.exit()
    System.exit(0)
  }

  def showLoginPane() = onFX {
    offFX { appDataHandler.clearCredentials() }
    // replaceSceneContent(mainViewController.loginController)
    // mainViewController.mainManager.updatePaneContent(
    //   mainViewController.loginController
    // )
    replaceSceneContent(mainViewController.loginController)
  }

  def logout() = {
    val newMainViewController = getController[MainViewController]()
    replaceSceneContent(newMainViewController)
  }

  def showChatPane(): Unit = onFX {
    // import org.scalafx.extras._
    replaceSceneContent(mainViewController.chatController, true)
    // mainViewController.mainManager.updatePaneContent(
    //   mainViewController.chatController
    // )
    // httpBackend.send(basicRequest.get(uri""))
    // val willBeResponse = basicRequest
    //   .get(uri"https://httpbin.org/get")
    //   .response(asJson[HttpBinResponse])
    //   .send()
    // async {
    //   val r = await { willBeResponse }
    //   r.body.map(println)
    // }

    // willBeResponse onComplete {
    //   case Success(x) => { x.body }
    //   case Failure(x) => {}
    // }
    // val body = for {
    //   r <- willBeResponse
    // } yield (r.body)
  }
}

final case class ApplicationName(name: String)
final case class UserCredentials(
    username: String,
    password: String,
    token: String
)
object UserCredentials {
  def empty = UserCredentials("empty", "empty", "empty")
}

@ApplicationScoped
class AppDataHandler {
  private var _appData: AppData = AppData(UserCredentials.empty, "empty")

  private def appData_=(appData: AppData) = synchronized { _appData = appData }

  def appData = _appData

  def updateCredentials(credentials: UserCredentials): Unit = offFX {
    println(credentials)
    appData = appData.copy(credentials = credentials)
  }

  def clearCredentials() = {
    appData = appData.copy(credentials = UserCredentials.empty)
  }
}
final case class AppData(credentials: UserCredentials, sumth: String)