UserSession

class UserSession(val userId:String) extends Actor{
    implicit val formats = Serialization.formats(NoTypeHints)

    var waitRequest:Option[RequestContext] = None
    var filters:Seq[String] = Nil
    var messagesQueue = List.empty[ChatMessage]
    var lastAccess:Long = System.currentTimeMillis()

    val okResponse = write(Map("ok"->true))
    val timeout = 1000*60*10L

    protected def receive = {
        case Request(ctx) => {
            lastAccess = System.currentTimeMillis()
            val action = ctx.param("action")
            action match {
                case "sendMessage" => {
                    val msg = ctx.param("message")
                    Chat.instance ! ChatMessage(prepareMessage(msg))
                    ctx.writeAndComplete(okResponse)
                }
                case "changeFilter" => {
                    val filterString = ctx.param("filter")
                    val newFilters = filterString.split(' ') .map(_.trim)
                        .filter(s => s.startsWith("#"))
                    filters = newFilters
                    ctx.writeAndComplete(okResponse)
                }
                case "getMessages" =>{
                    closeLastRequest()
                    if(messagesQueue.isEmpty){
                        waitRequest = Some(ctx)
                    } else{
                        sendMessagesToClient(ctx)
                    }
                }
                case "getUserId" => {
                    val json: String = write(Map("ok" -> true, "userId" -> userId))
                    ctx.writeAndComplete(json)
                }
            }
        }

        case msg @ ChatMessage(_,_) => {
            if(checkFilter(msg)){
                messagesQueue = msg :: messagesQueue
                if(waitRequest.isDefined){
                    sendMessagesToClient(waitRequest.get)
                    waitRequest = None
                }
            }
            checkTimeOut()
        }

        case CloseRequest() =>{
            waitRequest = None
        }
    }

    override def preStart {
        Chat.instance ! Subscribe(self)
    }


    override def postStop {
        closeLastRequest()
        Chat.instance ! UnSubscribe(self)
    }


    override def preRestart(reason: Throwable) {
        postStop
    }

    private def closeLastRequest() {
        try {
            waitRequest.foreach(r => {
                r.writeAndComplete(write((Map("ok" -> false))))
            })
        }
        catch {
            case _ => {}
        }
        waitRequest = None
    }

    private def sendMessagesToClient(ctx:RequestContext){
        val msgs =  messagesQueue.reverse.map(m => Map("msg" -> m.msg, "time" -> m.time))
        val response = Map("ok" -> true,
                            "messages"-> msgs)

        var json = write(response)
        ctx.writeAndComplete(json)
        messagesQueue = List.empty[ChatMessage]
    }

    private def prepareMessage(m:String):String = {
        val m1 = m.replaceAll("\n", "\\\\n")
        Jsoup.parse(m1).text().take(200)
    }

    private def checkFilter(msg:ChatMessage) = {
        if(filters.isEmpty) true
        else filters.exists(f => msg.tags.contains(f))
    }

    private def checkTimeOut(){
        if(System.currentTimeMillis - lastAccess > timeout)
            RequestDispatcher.instance ! CloseSession(userId)
    }

}