package com.posterous.agilesteel

trait IDisposable {
  def dispose()
}

object LoanPattern {
  implicit val byteDefault: Exception => Byte = e => 0
  implicit val shortDefault: Exception => Short = e => 0
  implicit val intDefault: Exception => Int = e => 0
  implicit val longDefault: Exception => Long = e => 0
  implicit val floatDefault: Exception => Float = e => 0f
  implicit val doubleDefault: Exception => Double = e => 0d
  implicit val booleanDefault: Exception => Boolean = e => false
  implicit val unitDefault: Exception => Unit = e => ()
  implicit val anyRefDefault: Exception => AnyRef = e => null

  def using[SomethingDisposable <: IDisposable, ResultType](getResource: => SomethingDisposable)(operate: SomethingDisposable => ResultType)(implicit catchBlock: Exception => ResultType) = {
    var optionalResource: Option[SomethingDisposable] = null
    try {
      optionalResource = Some(getResource)
      val resource = optionalResource.get
      operate(resource)
    } catch {
      case e: Exception => catchBlock(e)
    } finally optionalResource match {
      case Some(resource) => resource.dispose()
      case None =>
    }
  }

  def using[SomethingDisposable <% IDisposable, ResultType](getResource: => SomethingDisposable)(operate: SomethingDisposable => ResultType)(catchBlock: Exception => ResultType) = {
    var optionalResource: Option[SomethingDisposable] = null
    try {
      optionalResource = Some(getResource)
      val resource = optionalResource.get
      operate(resource)
    } catch {
      case e: Exception => catchBlock(e)
    } finally optionalResource match {
      case Some(resource) => resource.dispose()
      case None =>
    }
  }
}

class SomeResource extends IDisposable {
  def dispose() {}
  def doSomethingUseful() {}
}

class AnotherResource {
  def close() {}
  def doSomeOtherThing() {}
}

object ResouceToIDisposable {
  implicit def resourceToIDisposable(a: AnotherResource) = new IDisposable {
    def dispose() = a.close()
  }
}

object LoanPatternDemonstration {

  import LoanPattern._
  import ResouceToIDisposable._

  def main(args: Array[String]) {

    using(new SomeResource) {
      _.doSomethingUseful()
    }

    using(new SomeResource) {
      _.doSomethingUseful()
    } { e => println(e.getMessage) }

    using(new SomeResource) {
      _.doSomethingUseful()
    } {
      case r: RuntimeException => println("r " + r.getMessage)
      case e: Exception => println("e " + e.getMessage)
    }

    using(new AnotherResource) {
      _.doSomeOtherThing()
    } { e => println(e.getMessage) }

    using(new AnotherResource) {
      _.doSomeOtherThing()
    } {
      case r: RuntimeException => println("r " + r.getMessage)
      case e: Exception => println("e " + e.getMessage)
    }

    // This one won't compile
    // And Scala gets confused when I try to overload using...
    using(new AnotherResource) {
      _.doSomeOtherThing()
    }
  }
}