/*
 * Copyright 2011 Tomas Zeman <tzeman@volny.cz>
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package radview.snippet

import net.liftweb.common._
import net.liftweb.http._
import net.liftweb.http.{RewriteRequest => RReq, RewriteResponse => RResp, ParsePath => PP}
import net.liftweb.mapper._
import net.liftweb.sitemap._
import net.liftweb.sitemap.Loc._
import net.liftweb.util._
import net.liftweb.util.{Cell => _}
import net.liftweb.util.Helpers.urlEncode
import net.tz.lift.snippet._
import net.tz.lift.util._
import radview.model.{Cdr, CdrSession, Cell}
import scala.xml.{Elem, NodeSeq, Text}

object AsCdrSession {
  def unapply(in: String): Option[CdrSession] =
    Cdr.session(in.split('+').mkString("/"))
}

object SessionSnippet extends Loc[CdrSession] with SnippetHelpers {

  object showCdr extends RequestVar[Boolean](false)

  def encode(s: String) = urlEncode(s.split('/').mkString("+"))

  val name = "session"
  val prefix = "session"
  val tpl = "session"
  val params = List(Hidden)
  val defaultValue = Empty
  val link = new Link[CdrSession](List(prefix), true) {
    override def createPath(s: CdrSession): String =
      mkPath(prefix, encode(s.sid))
  }
  val text = LinkText[CdrSession](s => Text("Session " + s.sid))

  override def rewrite: LocRewrite = Full({
    case RReq(PP("session" :: AsCdrSession(s) :: xs, _,_,_), _,_) =>
      showCdr(xs contains "cdr")
      ActionLinks.append(showCdr.is match {
        case true =>  A(url(s, false), "Hide CDR")
        case false => A(url(s, true), "Show CDR")
      })
      (RResp(List("session")), s)
  })

  def url(sid: String): String = "/" + prefix + "/" + encode(sid)
  def url(s: CdrSession): String = url(s, false)
  def url(s: CdrSession, _showCdr: Boolean): String = link.createPath(s) +
    (if (_showCdr) "/cdr" else "")

  override def snippets: SnippetTest = {
    case ("panel", Full(s)) => SessionPanel(s)
    case ("cdr-list", Full(s)) if showCdr => CdrTable(s)

    case ("panel", _) => ClearNodes
    case ("cdr-list", _) => ClearNodes
  }

}

object SessionPanel {
  def apply(s: CdrSession): (NodeSeq => NodeSeq) = {
    val l1 = List(
      (Cdr.sid.displayName, s.sid),
      ("Session start", AsDateTime(s.start)),
      ("Session end", AsDateTime(s.end)),
      (Cdr.inBytes.displayName + " [MB]", Bytes.mb(s.inBytes)),
      (Cdr.outBytes.displayName + " [MB]", Bytes.mb(s.outBytes))
    ) map { r: (String, Any) =>
      AttrRow(Text(r._1), Text(r._2.toString))
    }
    Panel(l1 :+ AttrRow(Text("Cell"), s.cell.map { c =>
      A(CellSnippet.url(CellView(c)), c.btsName.is) } openOr NodeSeq.Empty))
  }
}

import radview.model.RadCheckSub

object CdrSessionTable {
  def apply(l: Iterable[CdrSession]): (NodeSeq => NodeSeq) = {
    val accounts: Map[String, RadCheckSub] = Map() ++
      (RadCheckSub.byImsi(l.map { _.callingNo.toString }.toList.distinct).
      map { r => (r.imsi.is, r) })

    Table[CdrSession](List(
      Column(Cdr.sid.displayName, { s: CdrSession =>
        A(SessionSnippet.url(s), s.sid) } ),
      Column("Session start", { s: CdrSession => Text(AsDateTime(s.start)) } ),
      Column("Session end", { s: CdrSession => Text(AsDateTime(s.end)) } ),
      Column(Cdr.inBytes.displayName + " [MB]",
        { s: CdrSession => Bytes.mb(s.inBytes) }, "td-right"),
      Column(Cdr.outBytes.displayName + " [MB]",
        { s: CdrSession => Bytes.mb(s.outBytes) }, "td-right"),
      Column(RadCheckSub.imsi.displayName,
        { s: CdrSession => accounts.get(s.callingNo.toString).map { r =>
          A(AccountSnippet.url(ViewAccount(r)), r.imsi.asHtml)
        } getOrElse NodeSeq.Empty })
      ), l)
  }
}

object CdrTable {
  import Cdr._
  def apply(cdr: Iterable[Cdr], isAdsl: Boolean): (NodeSeq => NodeSeq) = {

    def cssF(f: MappedField[_, Cdr])(cdr: Cdr): Box[String] = {
      f.actualField(cdr).is match {
        case l: Long => Full("td-right")
        case i: Int => Full("td-right")
        case _ => Empty
      }
    }

    def valF(f: MappedField[_, Cdr])(cdr: Cdr): NodeSeq =
      f.actualField(cdr).asHtml

    val cells: Map[String, Cell] = Map() ++
      (Cell.findAll(ByList(Cell.idpk, cdr.map { _.cell.is }.toList.distinct)).
      map { c => (c.idpk.is, c) })

    val cdrCols = fieldsForList.map { f =>
      new Column[Cdr](Text(f.displayName), valF(f) _, cssF(f) _) }

    val cellCols = List(Cell.btsDesc, Cell.btsSysIdHex, Cell.bssIntDesc).
      map { f => Column(f.displayName,
        { cdr: Cdr => cells.get(cdr.cell.is).map { c => 
          val cnt = f.actualField(c).asHtml
          if (f.name != Cell.btsSysIdHex.name) cnt
          else  A(CellSnippet.url(CellView(c)))(cnt)
        } getOrElse NodeSeq.Empty })
    }

    val cdr2Cols = List(serviceOption, releaseInd).map { f =>
      new Column[Cdr](Text(f.displayName), valF(f) _, cssF(f) _) }

    val cols = cdrCols ++ (isAdsl match {
      case true => Nil
      case false => cellCols ++ cdr2Cols
    })
    Table[Cdr](cols, cdr)
  }

  def apply(s: CdrSession): (NodeSeq => NodeSeq) = apply(bySession(s),
    s.cell.isEmpty)
}

// vim: set ts=2 sw=2 et: