package net.shrine.status

import java.io.File
import javax.ws.rs.{GET, Path, Produces, WebApplicationException}
import javax.ws.rs.core.{MediaType, Response}

import com.sun.jersey.spi.container.{ContainerRequest, ContainerRequestFilter}
import com.typesafe.config.{Config => TsConfig}
import net.shrine.authorization.StewardQueryAuthorizationService
import net.shrine.broadcaster.{Broadcaster, NodeHandle}
import net.shrine.client.PosterOntClient
import net.shrine.wiring.ShrineOrchestrator
import org.json4s.{DefaultFormats, Formats}
import org.json4s.native.Serialization
import net.shrine.log.{Log, Loggable}

import scala.collection.JavaConverters._
import scala.collection.immutable.{Map, Seq, Set}
import net.shrine.config.ConfigExtensions
import net.shrine.crypto.SigningCertStrategy
import net.shrine.protocol.query.{OccuranceLimited, QueryDefinition, Term}
import net.shrine.protocol.{AuthenticationInfo, BroadcastMessage, Credential, Failure, Result, ResultOutputType, RunQueryRequest, Timeout}
import net.shrine.util.Versions

import scala.concurrent.Await
import scala.util.Try
import scala.util.control.NonFatal

/**
  * A subservice that shares internal state of the shrine servlet.
  *
  * @author david 
  * @since 12/2/15
  */
@Path("/internalstatus")
@Produces(Array(MediaType.APPLICATION_JSON))
case class StatusJaxrs(shrineConfig:TsConfig) extends Loggable {

  implicit def json4sFormats: Formats = DefaultFormats

  @GET
  @Path("version")
  def version: String = {
    val version = Version("changeMe")
    val versionString = Serialization.write(version)
    versionString
  }

  @GET
  @Path("config")
  def config: String = {
    //todo probably better to reach out and grab the config from ManuallyWiredShrineJaxrsResources once it is a singleton
    Serialization.write(Json4sConfig(shrineConfig))
  }

  @GET
  @Path("summary")
  def summary: String = {
    val summary = Summary()
    Serialization.write(summary)
  }

  @GET
  @Path("i2b2")
  def i2b2: String = {
    val i2b2 = I2b2()
    Serialization.write(i2b2)
  }

  @GET
  @Path("optionalParts")
  def optionalParts: String = {
    val optionalParts = OptionalParts()
    Serialization.write(optionalParts)
  }

  @GET
  @Path("hub")
  def hub: String = {
    val hub = Hub()
    Serialization.write(hub)
  }

  @GET
  @Path("adapter")
  def adapter: String = {
    val adapter = Adapter()
    Serialization.write(adapter)
  }

  @GET
  @Path("qep")
  def qep: String = {
    val qep = Qep()
    Serialization.write(qep)
  }


}

case class I2b2(pmUrl:String,
                crcUrl:Option[String],
                ontUrl:String,
                i2b2Domain:String,
                username:String,
                crcProject:String,
                ontProject:String)

object I2b2 {
  def apply(): I2b2 = new I2b2(
    pmUrl = ShrineOrchestrator.pmPoster.url,
    crcUrl = ShrineOrchestrator.adapterComponents.map(_.i2b2AdminService.crcUrl),
    ontUrl = "", //todo
    i2b2Domain = ShrineOrchestrator.crcHiveCredentials.domain,
    username = ShrineOrchestrator.crcHiveCredentials.username,
    crcProject = ShrineOrchestrator.crcHiveCredentials.projectId,
    ontProject = ShrineOrchestrator.ontologyMetadata.client match {
      case client: PosterOntClient => client.hiveCredentials.projectId
      case _ => ""
    }
  )
}

case class DownstreamNode(name:String, url:String)

case class Qep(
                maxQueryWaitTimeMillis:Long,
                create:Boolean,
                attachSigningCert:Boolean,
                authorizationType:String,
                includeAggregateResults:Boolean,
                authenticationType:String
              )

object Qep{
  val key = "shrine.queryEntryPoint."
  def apply():Qep = new Qep(
    maxQueryWaitTimeMillis = ShrineOrchestrator.queryEntryPointComponents.fold(0L)(_.i2b2Service.queryTimeout.toMicros),
    create                  = ShrineOrchestrator.queryEntryPointComponents.isDefined,
    attachSigningCert       = ShrineOrchestrator.queryEntryPointComponents.fold(false)(_.i2b2Service.broadcastAndAggregationService.attachSigningCert),
    authorizationType       = ShrineOrchestrator.queryEntryPointComponents.fold("")(_.i2b2Service.authorizationService.getClass.getSimpleName),
    includeAggregateResults = ShrineOrchestrator.queryEntryPointComponents.fold(false)(_.i2b2Service.includeAggregateResult),
    authenticationType      = ShrineOrchestrator.queryEntryPointComponents.fold("")(_.i2b2Service.authenticator.getClass.getName)
  )
}

object DownstreamNodes {
  def get():Seq[DownstreamNode] = {
    ShrineOrchestrator.hubComponents.fold(Seq.empty[DownstreamNode])(_.broadcastDestinations.map(DownstreamNode(_)).to[Seq])
  }
}

object DownstreamNode {
  def apply(nodeHandle: NodeHandle): DownstreamNode = new DownstreamNode(
    nodeHandle.nodeId.name,
    nodeHandle.client.url.map(_.toString).getOrElse("not applicable"))
}

case class Adapter(crcEndpointUrl:String,
                   setSizeObfuscation:Boolean,
                   adapterLockoutAttemptsThreshold:Int,
                   adapterMappingsFilename:String)

object Adapter{
  def apply():Adapter = {
    val crcEndpointUrl                  = ShrineOrchestrator.adapterComponents.fold("")(_.i2b2AdminService.crcUrl)
    val setSizeObfuscation              = ShrineOrchestrator.adapterComponents.fold(false)(_.i2b2AdminService.obfuscate)
    val adapterLockoutAttemptsThreshold = ShrineOrchestrator.adapterComponents.fold(0)(_.i2b2AdminService.adapterLockoutAttemptsThreshold)
    val adapterMappingsFileName         = ShrineOrchestrator.adapterComponents.fold("")(_.adapterMappings.source)

    Adapter(crcEndpointUrl, setSizeObfuscation, adapterLockoutAttemptsThreshold, adapterMappingsFileName)
  }
}

case class Hub(shouldQuerySelf:Boolean, //todo don't use this field any more. Drop it when possible
               create:Boolean,
               downstreamNodes:Seq[DownstreamNode])

object Hub{
  def apply():Hub = {
    val shouldQuerySelf = false
    val create          = ShrineOrchestrator.hubComponents.isDefined
    val downstreamNodes = DownstreamNodes.get()
    Hub(shouldQuerySelf, create, downstreamNodes)
  }
}


case class OptionalParts(isHub:Boolean,
                         stewardEnabled:Boolean,
                         shouldQuerySelf:Boolean, //todo don't use this field any more. Drop it when possible
                         downstreamNodes:Seq[DownstreamNode])

object OptionalParts {
  def apply(): OptionalParts = {
    OptionalParts(
      ShrineOrchestrator.hubComponents.isDefined,
      ShrineOrchestrator.queryEntryPointComponents.fold(false)(_.shrineService.authorizationService.isInstanceOf[StewardQueryAuthorizationService]),
      shouldQuerySelf = false,
      DownstreamNodes.get()
    )
  }
}

case class Summary(
                    isHub:Boolean,
                    shrineVersion:String,
                    shrineBuildDate:String,
                    ontologyVersion:String,
                    ontologyTerm:String,
                    adapterMappingsFileName:Option[String],
                    adapterMappingsDate:Option[Long],
                    adapterOk:Boolean,
                    keystoreOk:Boolean,
                    hubOk:Boolean,
                    qepOk:Boolean
                  )

object Summary {

  val term = Term(ShrineOrchestrator.shrineConfig.getString("networkStatusQuery"))

  def runQueryRequest: BroadcastMessage = {
    val domain = "happy"
    val username = "happy"

    val networkAuthn = AuthenticationInfo(domain, username, Credential("", isToken = false))

    val queryDefinition = QueryDefinition("TestQuery", OccuranceLimited(1, term))
    import scala.concurrent.duration._
    val req = RunQueryRequest(
      "happyProject",
      3.minutes,
      networkAuthn,
      None,
      None,
      Set(ResultOutputType.PATIENT_COUNT_XML),
      queryDefinition)


    ShrineOrchestrator.signerVerifier.sign(BroadcastMessage(req.networkQueryId, networkAuthn, req), SigningCertStrategy.Attach)
  }

  def apply(): Summary = {

    val message = runQueryRequest

    val adapterOk: Boolean = ShrineOrchestrator.adapterService.fold(true) { adapterService =>

      import scala.concurrent.duration._

      val start = System.currentTimeMillis
      val resultAttempt: Try[Result] = Try(adapterService.handleRequest(message))
      val end = System.currentTimeMillis
      val elapsed = (end - start).milliseconds

      resultAttempt match {
        case scala.util.Failure(cause) => false
        case scala.util.Success(response) => true
      }
    }

    val hubOk = ShrineOrchestrator.hubComponents.fold(true){ hubComponents =>
      val maxQueryWaitTime = hubComponents.broadcasterMultiplexerService.maxQueryWaitTime
      val broadcaster: Broadcaster = hubComponents.broadcasterMultiplexerService.broadcaster
      val message = runQueryRequest
      val triedMultiplexer = Try(broadcaster.broadcast(message))
      //todo just use fold()() in scala 2.12
      triedMultiplexer.toOption.fold(false) { multiplexer =>
        val responses = Await.result(multiplexer.responses, maxQueryWaitTime).toSeq
        val failures = responses.collect { case f: Failure => f }
        val timeouts = responses.collect { case t: Timeout => t }
        val validResults = responses.collect { case r: Result => r }

        failures.isEmpty && timeouts.isEmpty && (validResults.size == broadcaster.destinations.size)
      }
    }

    val adapterMappingsFileName = ShrineOrchestrator.adapterComponents.map(_.adapterMappings.source)
    val adapterMappingsVersion = ShrineOrchestrator.adapterComponents.map(_.adapterMappings.version) //todo use this?
    val noDate:Option[Long] = None
    val adapterMappingsDate:Option[Long] = adapterMappingsFileName.fold(noDate){ fileName =>
      val file:File = new File(fileName)
      if(file.exists) Some(file.lastModified())
      else None
    }

    val ontologyVersion = try {
      ShrineOrchestrator.ontologyMetadata.ontologyVersion
    }
    catch {
      case NonFatal(x) =>
        Log.info("Problem while getting ontology version",x)
        x.getMessage
    }

    Summary(
      isHub = ShrineOrchestrator.hubComponents.isDefined,
      shrineVersion = Versions.version,
      shrineBuildDate = Versions.buildDate,
      //todo in scala 2.12, do better
      ontologyVersion = ontologyVersion,
      ontologyTerm = term.value,
      adapterMappingsFileName = adapterMappingsFileName,
      adapterMappingsDate = adapterMappingsDate,
      adapterOk = adapterOk,
      keystoreOk = true, //todo something for this
      hubOk = hubOk,
      qepOk = true //todo something for this
    )
  }
}

case class Version(version:String)

//todo SortedMap when possible
case class Json4sConfig(keyValues:Map[String,String])

object Json4sConfig{
  def isPassword(key:String):Boolean = {
    if(key.toLowerCase.contains("password")) true
    else false
  }

  def apply(config:TsConfig):Json4sConfig = {

    val entries: Set[(String, String)] = config.entrySet.asScala.to[Set].map(x => (x.getKey,x.getValue.render())).filterNot(x => isPassword(x._1))
    val sortedMap: Map[String, String] = entries.toMap
    Json4sConfig(sortedMap)
  }
}

class PermittedHostOnly extends ContainerRequestFilter {

  //todo generalize for happy, too
  //todo for tomcat 8 see https://jersey.java.net/documentation/latest/filters-and-interceptors.html for a cleaner version
  //shell code from http://stackoverflow.com/questions/17143514/how-to-add-custom-response-and-abort-request-in-jersey-1-11-filters

  //how to apply in http://stackoverflow.com/questions/4358213/how-does-one-intercept-a-request-during-the-jersey-lifecycle
  override def filter(requestContext: ContainerRequest): ContainerRequest = {
    val hostOfOrigin = requestContext.getBaseUri.getHost
    val shrineConfig:TsConfig = ShrineOrchestrator.config
    val permittedHostOfOrigin:String = shrineConfig.getOption("shrine.status.permittedHostOfOrigin",_.getString).getOrElse("localhost")

    val path = requestContext.getPath

    //happy and internalstatus API calls must come from the same host as tomcat is running on (hopefully the dashboard servlet).
    // todo access to the happy service permitted for SHRINE 1.21 per SHRINE-1366
    // restrict access to happy service when database work resumes as part of SHRINE-
    //       if ((path.contains("happy") || path.contains("internalstatus")) && (hostOfOrigin != permittedHostOfOrigin)) {
    if (path.contains("internalstatus") && (hostOfOrigin != permittedHostOfOrigin)) {
      val response = Response.status(Response.Status.UNAUTHORIZED).entity(s"Only available from $permittedHostOfOrigin, not $hostOfOrigin, controlled by shrine.status.permittedHostOfOrigin in shrine.conf").build()
      throw new WebApplicationException(response)
    }
    else requestContext
  }

}