package fmon.util

import com.fasterxml.jackson.core._
import com.fasterxml.jackson.databind._
import com.fasterxml.jackson.databind.ser._
import com.fasterxml.jackson.databind.ser.std.StdSerializer
import com.fasterxml.jackson.databind.deser._
import com.fasterxml.jackson.databind.deser.std.StdDeserializer
import com.fasterxml.jackson.databind.module.SimpleModule
import com.fasterxml.jackson.databind.JsonNode
import com.fasterxml.jackson.dataformat.yaml.YAMLFactory
import com.fasterxml.jackson.module.scala.DefaultScalaModule
import com.fasterxml.jackson.module.scala.experimental.ScalaObjectMapper

import scalafx.scene.paint.Color

import java.io.{InputStream, OutputStream}

import scala.io.Source

import fmon.util._

class ColorSerializer extends StdSerializer[Color](classOf[Color]) {
  override def serialize(color: Color, jgen: JsonGenerator, serializer: SerializerProvider): Unit = {
    jgen.writeStartObject()
    jgen.writeFieldName("red")
    jgen.writeNumber(color.red)
    jgen.writeFieldName("green")
    jgen.writeNumber(color.green)
    jgen.writeFieldName("blue")
    jgen.writeNumber(color.blue)
    jgen.writeEndObject()
  }
}

class ColorDeserializer extends StdDeserializer[Color](classOf[Color]) {
  override def deserialize(jp: JsonParser, ctxt: DeserializationContext): Color = {
    val node = jp.getCodec.readTree[JsonNode](jp)
    val red = node.get("red").asDouble()
    val green = node.get("green").asDouble()
    val blue = node.get("blue").asDouble()
    Color.color(red, green, blue)
  }
}

object YamlHelper {
  val mapper = new ObjectMapper(new YAMLFactory()) with ScalaObjectMapper
  mapper.registerModule(DefaultScalaModule)
  val module = new SimpleModule()
  module.addSerializer(classOf[Color], new ColorSerializer)
  module.addDeserializer(classOf[Color], new ColorDeserializer)
  mapper.registerModule(module)
  mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false)
  
  def extract[T](text : String)(implicit m : Manifest[T]) : T = {
    mapper.readValue[T](text)
  }
  
  def extract[T](source : Source)(implicit mf : Manifest[T]) : T = {
    val text = source.getLines().mkString("\n")
    extract(text)
  }
  
  def extract[T](source : InputStream)(implicit m : Manifest[T]) : T = {
    mapper.readValue[T](source)
  }
  
  def extractSeq[T](text : String)(implicit m : Manifest[T]) : IndexedSeq[T] = {
    mapper.readValue[IndexedSeq[T]](text)
  }
  
  def extractSeq[T](source : Source)(implicit mf : Manifest[T]) : IndexedSeq[T] = {
    val text = source.getLines().mkString("\n")
    extractSeq(text)
  }
  
  def extractSeq[T](source : InputStream)(implicit m : Manifest[T]) : IndexedSeq[T] = {
    mapper.readValue[IndexedSeq[T]](source)
  }
  
  def extractMap[T](source : Source)(implicit mf : Manifest[T]) : Map[String, T] = {
    extract[Map[String, T]](source)
  }
  
  def extractMap[T](source : InputStream)(implicit m: Manifest[T]) : Map[String, T] = {
    mapper.readValue[Map[String, T]](source)
  }
  
  def write[T](source: OutputStream, item: T) = {
    mapper.writeValue(source, item)
  }
  
  def writeSeq[T](source: OutputStream, items: Seq[T]) = {
    mapper.writeValue(source, items)
  }
  
  def writeMap[T](source: OutputStream, items: Map[String, T])(implicit m: Manifest[T]) = {
    mapper.writeValue(source, items)
  }
}