package com.owlbookit.shared.domain.users

import com.owlbookit.shared.util.JsonProvider
import play.api.libs.json.{Writes, Reads}
import play.api.Logger
import scala.collection.mutable
import com.owlbookit.shared.domain.users.PreferenceKeyBases.{IntPreferenceKey, BooleanPreferenceKey}

/**
 * Created by ed on 4/20/14.
 */
case class UserPreference(userId: Long, key: Int, value: String)

class UserPreferences(val userId: Long, prefs: Iterable[UserPreference]) {
  private val store: Map[PreferenceKey[_], String] = {
    // this is because the functional projection decided to not ever work. flatten sucks.
    val tempMap = mutable.Map[PreferenceKey[_], String]()
    prefs.foreach(pref => {
      UserPreferences.prefMap.get(pref.key) match {
        case None => {
          Logger.warn(s"User preference ")
        }
        case Some(key: PreferenceKey[_]) => tempMap.put(key, pref.value)
      }
    })
    tempMap.toMap
  }

  def get[B](key: PreferenceKey[B]) = store.get(key) match {
    case None => key.default
    case Some(v: String) => key.out(v)
  }

  def set[B](key: PreferenceKey[B], value: B) = if (value == key.default) {
    this
  } else {
    val seq = store.toSeq.map(t => UserPreference(userId, t._1.key, t._2))
    val newItem = UserPreference(userId, key.key, key.in(value))
    new UserPreferences(userId, seq :+ newItem)
  }
}

object UserPreferences extends JsonProvider[UserPreferences] {
  object DummyTestPreference extends IntPreferenceKey(-1337, 42)
  object WantsNewsletter extends BooleanPreferenceKey(1, true)




  private val prefMap = Seq[PreferenceKey[_]](
    DummyTestPreference,
    WantsNewsletter
  ).map(p => (p.key, p)).toMap[Int, PreferenceKey[_]]


  override implicit val writer: Writes[UserPreferences] = ???
  override implicit val reader: Reads[UserPreferences] = ???
}




abstract class PreferenceKey[A](val key: Int, val default: A) {
  def out(value: String): A
  def in(value: A): String
}

object PreferenceKeyBases {
  abstract class BooleanPreferenceKey(key: Int, default: Boolean)
    extends PreferenceKey[Boolean](key, default) {

    override def out(value: String): Boolean = value.toBoolean
    override def in(value: Boolean): String = value.toString
  }
  abstract class StringPreferenceKey(key: Int, default: String)
    extends PreferenceKey[String](key, default) {

    override def out(value: String): String = value
    override def in(value: String): String = value
  }
  abstract class IntPreferenceKey(key: Int, default: Int)
    extends PreferenceKey[Int](key, default) {

    override def out(value: String): Int = value.toInt
    override def in(value: Int): String = value.toString
  }
}