/*

 * 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 net.tz.lift.util

import java.text.SimpleDateFormat

import java.util.Date

import net.liftweb.http.LiftRules

import net.liftweb.util.Helpers.tryo

import org.joda.time.{DateMidnight, DateTime, Period, ReadableInstant}

import org.joda.time.format.{DateTimeFormat, PeriodFormatterBuilder}

import scala.xml.{NodeSeq, Text}

object AsIsoDateTime {

  val df = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss")

  def unapply(in: String): Option[Date] = tryo { df.parse(in) }

  def apply(d: Date): String = df.format(d)

}

object AsDate {

  import DateExtension._

  def unapply(in: String): Option[Date] = LiftRules.dateTimeConverter().

    parseDate(in).map(_.noTime)

  def apply(d: Date) = LiftRules.dateTimeConverter().formatDate(d)

}

object AsDateTime {

  def unapply(in: String): Option[Date] = LiftRules.dateTimeConverter().

    parseDateTime(in)

  def apply(d: Date) = LiftRules.dateTimeConverter().formatDateTime(d)

}

object AsDateMidnight {

  lazy val fmt = DateTimeFormat.forPattern("yyyy-MM-dd")

  def unapply(in: String): Option[DateMidnight] = apply(in)

  def apply(in: String): Option[DateMidnight] = tryo {

    fmt.parseDateTime(in).toDateMidnight

  }

  def apply(d: ReadableInstant) = fmt.print(d)

  implicit def dt2d(d: DateTime): Date = d.toDate

  implicit def dm2d(d: DateMidnight): Date = d.toDate

  implicit def d2dm(d: Date): DateMidnight = new DateMidnight(d)

  implicit def dm2dt(d: DateMidnight): DateTime = d.toDateTime

}

object AsTimePeriod {

  lazy val fmt = (new PeriodFormatterBuilder).printZeroAlways.

    minimumPrintedDigits(2).appendHours.

    appendSeparator(":").appendMinutes.toFormatter

  lazy val fmtDt = DateTimeFormat.forPattern("HH:mm")

  /** Parses HH:mm time into period. */

  def apply(in: String): Option[Period] = tryo { fmt.parsePeriod(in) }

  def apply(p: Period) = fmt.print(p)

  def apply(dt: DateTime) = fmtDt.print(dt)

}

object Bytes {

  implicit def dbl2ns(d: Double): NodeSeq =

    Text(String.format(fmt, d.asInstanceOf[AnyRef]))

  def fmt = "%.2f"

  def kb(v: Long): NodeSeq = v.toDouble / 1024

  def mb(v: Long): NodeSeq = v.toDouble / (1024*1024)

}

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