/*
 * Copyright ...
 */
package example

import java.net.InetAddress
import net.liftweb.common._
import net.liftweb.mapper._
import net.liftweb.util._
import net.liftweb.util.Helpers._

object InetAddressHelpers extends InetAddressHelpers

trait InetAddressHelpers {
  def normalize(inet: String): Box[String] = tryo {
    InetAddress.getByName(inet).getHostAddress
  }

  def valid_?(inet: String): Boolean = (inet != null) && (tryo {
    InetAddress.getByName(inet)
  } isDefined ) && (inet.length > 0)

  def toBigInt(inet: InetAddress): BigInt = BigInt(1, inet.getAddress)

  def toInet(s: String): Box[InetAddress] = s match {
    case null | "" => Empty
    case _ => tryo { InetAddress.getByName(s) }
  }
}

/**
 * Postgres specific <code>InetAddress</code> mapping
 * (maps to ''inet'' data type).
 * Always use <code>asInet</code> to get <code>InetAddress</code> instance.
 */
abstract class MappedInetAddress[T<:Mapper[T]](owner: T) extends
  MappedString[T](owner, 128) with InetAddressHelpers {

  override def setFilter = normalizeFilter _ :: super.setFilter

  override def validate = (valid_?(i_is_!) match {
    case true => Nil
    case false => List(FieldError(this, "Invalid IP address"))
  }) ::: super.validate

  def normalizeFilter(inet: String): String = inet match {
    case null | "" => null
    case s => normalize(s) openOr null
  }

  def asInet: Box[InetAddress] = toInet(is)

  override def targetSQLType = Types.OTHER

  override def fieldCreatorString(d: DriverType, colName: String) = d match {
    case _d: BasePostgreSQLDriver => colName + " inet"
    case _ => super.fieldCreatorString(d, colName)
  }
}

/**
 * Caution: getters may return <code>null</code> value.
 * Always use <code>asInet</code>.
 */
abstract class MappedNullableInetAddress[T<:Mapper[T]](owner: T) extends
  MappedInetAddress[T](owner) {

  override def defaultValue = null

  override def validate = i_is_! match {
    case null | "" => Nil
    case _ => super.validate
  }

  override def dbNotNull_? = false
}

/**
 * IP network mapper via its start/end fields.
 * Implemented validation of IP overlaps, parent network, start, end.
 * Maintains network relationships (sub-net/super-net) and updates
 * parent field accordingly.
 */
object ExampleNetwork extends ExampleNetwork with
  LongKeyedMetaMapper[ExampleNetwork] with LongCRUDify[ExampleNetwork] {

  override def validation: List[ExampleNetwork => List[FieldError]] = 
    startLtEnd _ :: checkOverlap _ :: super.validation

  def startLtEnd(n: ExampleNetwork): List[FieldError] = (for {
    s <- n.start.asInet
    e <- n.end.asInet
  } yield (toBigInt(s) < toBigInt(e))) match {
    case Full(true) => Nil
    case Full(false) =>
      List(FieldError(n.start, "Start must be below end"))
    case _ =>
      List(FieldError(n.start, S ? "Can't compare start/end IP"))
  }

  def checkOverlap(net: ExampleNetwork): List[FieldError] = {
    def run(f: MappedInetAddress[ExampleNetwork]) = {
      findAll(inNet(f):_*) filter {!_.comparePrimaryKeys(net)} filter { n =>
        net.isSubnetOf(n) match {
          case f: Failure => true
          case _ => false
      }} map { n =>
        FieldError(f, "Overlaps with: " + n.start + " - " + n.end)
      }
    }
    run(net.start) ::: run(net.end)
  }

  override def beforeSave = List(n => n.parent(findParent(a)))

  override def afterSave = List(n => children(n.parent.obj) foreach { child =>
    child.parent(findParent(child)).save
  })

  override def afterDelete = List(n => children(Full(n)) foreach { child =>
    child.parent(findParent(child)).save
  })

  def findParent(net: ExampleNetwork): Box[ExampleNetwork] =
  findAll(inNet(net):_*) filter {!_.comparePrimaryKeys(net)} sort {
    (n1, n2) => (for {
      s1 <- n1.size
      s2 <- n2.size
  } yield s1 < s2) openOr true } firstOption

  import OprEnum._
  def inNet(inet: MappedInetAddress[ExampleNetwork]) = List(
    Cmp(start, <=, Full(inet.is), Empty, Empty),
    Cmp(end, >=, Full(inet.is), Empty, Empty)
  )

  def inNet(net: ExampleNetwork): List[QueryParam[ExampleNetwork]] =
    inNet(net.start) ::: inNet(net.end)

  def getByNet(s: String, e: String) = Box(findAll(By(start, s), By(end, e)))

  def children(n: Box[ExampleNetwork]) = findAll(By(parent, n))
}

class ExampleNetwork extends LongKeyedMapper[ExampleNetwork] with IdPK
  with InetAddressHelpers {

  override def getSingleton = ExampleNetwork

  object start extends MappedInetAddress(this)

  object end extends MappedInetAddress(this)

  object parent extends LongMappedMapper(this, ExampleNetwork) {
    override def dbIncludeInForm_? = false
  }

  def size: Box[BigInt] = for {
    s <- start.asInet
    e <- end.asInet
  } yield toBigInt(e) - toBigInt(s) + 1

  /**
   * Checks if this network is subnet of the <code>other</code>.
   * @return true if this is subnet of the other
   *         false if this is supernet
   *         empty not related at all
   *         failure if can't compare or network overlap
   */
  def isSubnetOf(other: ExampleNetwork): Box[Boolean] = {
    def inside(what: BigInt, from: BigInt, to: BigInt): Boolean =
      (from <= what) && (what <= to)

    (for {
      si <- start.asInet
      ei <- end.asInet
      osi <- other.start.asInet
      oei <- other.end.asInet
    } yield {
      val s = toBigInt(si)
      val e = toBigInt(ei)
      val os = toBigInt(osi)
      val oe = toBigInt(oei)
      val s_inside = inside(s, os, oe)
      val e_inside = inside(e, os, oe)
      val os_inside = inside(os, s, e)
      val oe_inside = inside(oe, s, e)
      (s_inside, e_inside, os_inside, oe_inside) match {
        case (true, true, _, _) => Full(true)
        case (_, _, true, true) => Full(false)
        case (false, false, false, false) => Empty
        case (_, _, _, _) => Failure("IP address overlap with: " + other)
      }
    }).openOr(Failure("Failed to obtain inet addresses: this: " + this +
      ", other: " + other))
  }
}

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