/*
 * 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.snippet

import net.liftweb.common._
import net.liftweb.util.Helpers._
import scala.xml.{Elem, NodeSeq, Text}

object Column {
  def apply[T](name: String, f: T => NodeSeq): Column[T] =
    new Column[T](Text(name), f, { _ => Empty})
  def apply[T](name: String, f: T => NodeSeq, tdCss: String): Column[T] =
    new Column[T](Text(name), f, { _ => Full(tdCss)})
}

class Column[T](name: => NodeSeq, f: T => NodeSeq, tdCss: T => Box[String])
  extends Function1[T, NodeSeq] {

  def th: Elem = <th>{name}</th>
  def td(in: T): Elem = {
    val r = <td>{apply(in)}</td>
    tdCss(in) map { css => r % ("class" -> css) } openOr r
  }
  def apply(in: T): NodeSeq = f(in)
}

object Table {
  def apply[T](cols: Iterable[Column[T]], rows: Iterable[T]) = new Table(Empty,
    cols, rows, Empty)
  def apply[T](css: String, cols: Iterable[Column[T]], rows: Iterable[T],
    foot: NodeSeq) = new Table(Full(css), cols, rows, Full(foot))
}

class Table[T](css: Box[String], cols: Iterable[Column[T]],
  rows: => Iterable[T], foot: Box[NodeSeq]) extends
  Function1[NodeSeq, NodeSeq] {

  def oddEven(i: Int) = (i % 2) match {
    case 1 => "even"
    case 0 => "odd"
  }

  def thead: Elem = <thead><tr>{ cols.map(c => c.th) }</tr></thead>
  def tbody: Elem = <tbody>{
    rows.zipWithIndex.map( r => tr(r._1, r._2))
  }</tbody>
  def tr(in: T, idx: Int): Elem = <tr class={oddEven(idx)}>{
    cols.map(_.td(in))
  }</tr>

  def tfoot: Elem = <tfoot>{
    foot map { f => <tr><td colspan={cols.size.toString}>{f}</td></tr>
    } openOr NodeSeq.Empty
  }</tfoot>

  def apply(ns: NodeSeq): NodeSeq = {
    val t = <table>{
      List(thead, tfoot, tbody)
    }</table>
    css map { cl => t % ("class" -> cl) } openOr t
  }

}

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