//  lazy val twitter = project("twitter", "Dispatch Twitter", new ScappsDefault(_), http, json, oauth)

  val servlet = "javax.servlet" % "servlet-api" % "2.5"

  val jettyServlet = "org.eclipse.jetty" % "jetty-servlet" % "7.0.0.RC2"

  val jettyServer = "org.eclipse.jetty" % "jetty-server" % "7.0.0.RC2"

  val gae = "com.google.appengine" % "appengine-api-1.0-sdk" % "1.2.1"

  val dnAppEngine = "com.google.appengine.orm" % "datanucleus-appengine" % "1.0.0"

  override def ivyXML =

        <dependencies>

            <dependency org="org.datanucleus" name="datanucleus-core" rev="1.1.0">

                <exclude org="javax.transaction" />

            </dependency>

        </dependencies>

package scapps.gae

import scalaz.Scalaz._

import reflect.Manifest

abstract class DataMapper[T](implicit m : Manifest[T]) {

  import scapps.util.IterableConversions._

  private val cls : Class[T] = m.erasure.asInstanceOf[Class[T]]

  def findById(id: Long): Option[T] = State.runDB(pm => pm.getObjectById(cls, id).asInstanceOf[T].onull)

  def findAll() = State.runDB(pm => pm.getExtent(cls).iterator.toList)

  def findFirst(filter: String, params: String, args: String*): Option[T] = State.runDB(pm => {

    val q = pm.newQuery(cls, filter)

    q.declareParameters(params)

    val iterator = q.executeWithArray(args : _*).asInstanceOf[java.lang.Iterable[T]].iterator

    (iterator.hasNext).option(iterator.next)

  })

  def save(t : T) = State.runDB(pm => pm.makePersistent(t))

}

// TODO If this gets any bigger, split it out into a new file

trait Mappable {

  def save()(implicit mapper : DataMapper[this.type]) = mapper.save(this)

}

package scapps.gae

import com.google.appengine.api.memcache._

import com.google.appengine.api.users._

trait GoogleServices {

  def memcacheService : MemcacheService

  def userService : UserService

}

trait DefaultServices extends GoogleServices {

  def memcacheService : MemcacheService = MemcacheServiceFactory.getMemcacheService

  def userService : UserService = UserServiceFactory.getUserService

}

object G extends DefaultServices

package scapps.gae

import scalaz.Scalaz._

import com.google.appengine.api.memcache.MemcacheService

case class RichMemcacheService(memcache: MemcacheService) {

  def lookup[A](key: String): Option[A] = memcache.get(key).asInstanceOf[A].onull

  def getOrElsePut[A](key: String, a: => A) : A = {

    lookup(key) getOrElse {

      val v: A = a

      memcache.put(key, v)

      v

    }

  }

}

object RichMemcacheService {

  implicit def MemcacheTo(s: MemcacheService) = RichMemcacheService(s)

}

package scapps.gae

import com.google.appengine.api.users._

import scalaz.Scalaz._

case class RichUserService(service : UserService) {

  def user: Option[User] = service.getCurrentUser.onull

}

object RichUserService {

  implicit def UserServiceTo(s: UserService) = RichUserService(s)

}

package scapps.gae

import scalaz.Scalaz._

import javax.jdo.{JDOHelper, PersistenceManager}

trait Database {

  def runDB[B](f : PersistenceManager => B)

  // TODO provide implementation of this in terms of runDb

  def transaction[B](thunk : => B)

}

object State {

  private val pmf = JDOHelper.getPersistenceManagerFactory("transactions-optional")

  trait PM {

    def acquire() : PersistenceManager

    def release(pm : PersistenceManager)

  }

  case class NormalPM() extends PM {

    def acquire() : PersistenceManager = pmf.getPersistenceManager

    def release(pm : PersistenceManager) = pm.close

  }

  case class TransactionalPM(pm : PersistenceManager) extends PM {

    def acquire() : PersistenceManager = pm

    def release(pm : PersistenceManager) = () // no op

  }

  private val managerMaker = new scala.util.DynamicVariable[PM](NormalPM())

  def runDB[B](f : PersistenceManager => B) = {

    val thePm = managerMaker.value.acquire()

    try {

      f(thePm)

    } finally {

      managerMaker.value.release(thePm)

    }

  }

  def transaction[B](thunk : => B) = runDB(pm => {

    val pm = managerMaker.value.acquire();

    val t = pm.currentTransaction()

    try {

      t.begin()

      val r = managerMaker.withValue(TransactionalPM(pm)) { thunk }

      t.commit()

      r

    } finally {

      if (t.isActive()) {

        t.rollback()

      }

      managerMaker.value.release(pm)

    }

  }

  )

}

package scapps.http

// TODO clean up these imports if possible

import javax.servlet.ServletContext

import scalaz.Scalaz._

import scalaz.http.request.{Method, Request}

import scalaz.http.servlet.{HttpServlet, HttpServletRequest, ServletApplication, StreamStreamServletApplication}

import scalaz.http.servlet.HttpServlet._

import scalaz.http.StreamStreamApplication._

import scalaz.http.{Application}

import scalaz.http.response._

import scalaz.http.response.Body._

/*

Slinky base application that provides Optional handling of request.

Looks up resources if None.

*/

abstract class BaseApp extends StreamStreamServletApplication {

  def route(implicit request : Request[Stream], servletRequest: HttpServletRequest) : Option[Response[Stream]]

  def log(request: Request[Stream], response: Response[Stream]) {

    //"0.0.0.0 - localhost [%s] \"%s %s HTTP/1.0\" %s 0000" format ("", request.method.asString, request.path.list.mkString, response.status.toInt.toString)

    //request

    // TODO use apache log format

    // 127.0.0.1 - frank [10/Oct/2000:13:55:36 -0700] "GET /apache_pb.gif HTTP/1.0" 200 2326

  }

  val application = new ServletApplication[Stream, Stream] {

    def application(implicit servlet: HttpServlet, servletRequest: HttpServletRequest, request: Request[Stream]) = {

      val response = route getOrElse resource(x => OK << Stream.fromIterator(x), NotFound.xhtml)

      log(request, response)

      response

    }

  }

}

package scapps.htpp

import scalaz.Scalaz._

import scalaz.{NonEmptyList, Kleisli}

import scalaz.http.request._

import scalaz.http.response.Response

case class ItemRequest(request: Request[Stream], key: NonEmptyList[Char]) {

  import scapps.util.StringParser._

  lazy val longKey: Option[Long] = key.list.mkString.asLong

}

final class RequestW(val request : Request[Stream]) {

  def asItemRequest : Option[ItemRequest] = {

    val sid: Option[NonEmptyList[Char]] = request.path.list.mkString.split("/")(0).toList.nel

    (sid |> (ItemRequest(request, _)))

  }

}

object RequestW {

  implicit def RequestTo(request : Request[Stream]) = new RequestW(request)

  implicit def RequestFrom(w : RequestW) = w.request

}

trait RestfulRoute extends Kleisli[Option, Request[Stream], Response[Stream]] {

  import scapps.http.Route._

  import scapps.http.OptionKleisli.OptionKleisli

  import RequestW._

  val base: String

  def index(r: Request[Stream]): Option[Response[Stream]]

  def formForCreate(r: Request[Stream]): Option[Response[Stream]]

  def createItem(r: Request[Stream]): Option[Response[Stream]]

  def formForEdit(request: ItemRequest): Option[Response[Stream]]

  def deleteItem(r: ItemRequest): Option[Response[Stream]]

  def updateItem(r: ItemRequest): Option[Response[Stream]]

  def item(r: ItemRequest): Option[Response[Stream]]

  def routes : Kleisli[Option, Request[Stream], Response[Stream]]  = {

    methodHax >=> dir("/" + base) >=> List(

      GET >=> List(

        "/" >=> index _,

        "/new" >=> formForCreate _,

        dir("/") >=> withParam("edit") >=> (_.asItemRequest) >=> formForEdit _,

        dir("/") >=> (_.asItemRequest) >=> item _

        ),

      PUT >=> dir("/") >=> (_.asItemRequest) >=> updateItem _,

      POST >=> "/" >=> createItem _,

      DELETE >=> dir("/") >=> (_.asItemRequest) >=> deleteItem _

      )

  }

}

package scapps.http

import scalaz.Kleisli

import scalaz.{OptionW, StringW}

import scalaz.http.request._

import scalaz.http.response.Response

import scalaz.NonEmptyList._

import scalaz.NonEmptyList

import scalaz.Scalaz._

object OptionKleisli {

  // Scalaz doesn't supply this. Yet.

  implicit def OptionKleisli[A, B](f: A => Option[B]): Kleisli[Option, A, B] = Kleisli.kleisli[Option](f)  

}

object Route {

  def firstSome[A, B](fs: List[Kleisli[Option, A, B]])(a: A): Option[B] = (fs.elements.map(_(a)).find(_.isDefined)).join

  implicit def ListKleisliKleisli[A, B](fs: List[Kleisli[Option, A, B]]): Kleisli[Option, A, B] = Kleisli.kleisli[Option](firstSome(fs) _)

  implicit def PathKliesli(s: String) = Kleisli.kleisli[Option](exactdir(s))

  implicit def MethodKliesli(m: Method) = Kleisli.kleisli[Option](methodM(m))

  implicit def PathMethodKliesli(t: Tuple2[Method, String]) = MethodKliesli(t._1) >=> PathKliesli(t._2)

  def stringToNel(s : String, n : NonEmptyList[Char]) = {

    if (s.length == 0) n else {

      val l = s.toList

      nel(l.head, l.tail)

    }

  }

  // returns a new request with the prefix stripped if it matches, else none

  def dir(prefix: String) = {

    def f(prefix: String)(r: Request[Stream]): Option[Request[Stream]] = {

      (r.pathStartsWith(prefix)).option(

        r(r.uri(stringToNel(r.path.list.mkString.replaceFirst(prefix, ""), NonEmptyList.nel('/'))))

      )

    }

    f(prefix) _

  }

  // returns a new request with the uri stripped to '/', if it matches exactly, else none

  def exactdir(s: String) : (Request[Stream] => Option[Request[Stream]]) = {

    def g(s: String)(r: Request[Stream]): Option[Request[Stream]] = (r.pathEquals(s)).option(r(r.uri(NonEmptyList.nel('/'))))

    g(s) _

  }

  def withParam(key: String) = (r: Request[Stream]) => (r !? key).option(r)

  def methodM(m: Method) : (Request[Stream] => Option[Request[Stream]]) = (r: Request[Stream]) => { (r.method.equals(m)).option(r) }

  // interprets the value of _method in a post as an HTTP method

  def methodHax = (r: Request[Stream]) => {

    import scalaz.http.request.Method._

    val mbMeth: Option[Method] = (r | "_method") >>= (_.mkString : Option[Method])

    Some((mbMeth |> (r(_))) getOrElse (r))

  }

}

package scapps.http

import org.eclipse.jetty.server.bio.SocketConnector

import org.eclipse.jetty.server.handler.ContextHandler

import org.eclipse.jetty.server.{Connector, Handler, Server}

import org.eclipse.jetty.servlet.{ServletHolder, ServletContextHandler}

object SlinkyRunner {

  def main(args: Array[String]) {

    val server: Server = new Server(8081)

    val handler: ServletContextHandler = new ServletContextHandler(server, "/", ServletContextHandler.SESSIONS |

            ServletContextHandler.NO_SECURITY)

    val holder = new ServletHolder(classOf[scalaz.http.servlet.StreamStreamServlet])

    holder.setInitParameter("application", "com.scapps.ScappsApplication")

    // TODO Improve

    holder.setInitParameter("scapps-application", args(0))

    handler.addServlet(holder, "/*")

    server.setHandler(handler);

    server.start();

    server.join();

  }

}

package scapps.util

/**

 * General Java Iterable converters, allowing for comprehensions.

 *

 * Based on suggestions from Jamie Webb (http://scala.sygneca.com/)

 */

object IterableConversions {

  case class JavaIteratorIterator[A](itr: java.util.Iterator[A]) extends Iterator[A] {

    def hasNext = itr.hasNext

    def next() = itr.next

  }

  case class JavaIteratableIterable[A](iterable: java.lang.Iterable[A]) extends Iterable[A] {

    def elements = JavaIteratorIterator(iterable.iterator)

  }

  implicit def javaIteratorTo[A](iterator : java.util.Iterator[A]) = JavaIteratorIterator(iterator)

  implicit def implicitJavaIterableToScalaIterable[A](iterable: java.lang.Iterable[A]): Iterable[A] =

    JavaIteratableIterable(iterable)

  case class JavaEnumerationIterator[A](itr: java.util.Enumeration[A]) extends Iterator[A] {

    def hasNext = itr.hasMoreElements

    def next() = itr.nextElement

  }

  case class JavaEnumerationIterable[A](iterable: java.util.Enumeration[A]) extends Iterable[A] {

    def elements = JavaEnumerationIterator(iterable)

  }

  implicit def implicitJavaEnumerationToScalaIterable[A](iterable: java.util.Enumeration[A]): Iterable[A] =

    JavaEnumerationIterable(iterable)

}

object JavaEnumerationConversions {

  implicit def toEnumeration[A](iterator: java.util.Iterator[A]): java.util.Enumeration[A] =

    new java.util.Enumeration[A] {

      def hasMoreElements = iterator.hasNext

      def nextElement = iterator.next

    }

}

/**

 * General Scala to Iterable converters, allowing for java use.

 *

 */

object JavaIterableConversions {

  class JavaIterator[T](itr: Iterator[T]) extends java.util.Iterator[T] {

    def hasNext() = itr.hasNext

    def next() = itr.next

    def remove() = throw new java.lang.UnsupportedOperationException("Remove is not implemented in JavaIterableConversions:JavaIterator")

  }

  class JavaIterable[T](iterable: Iterable[T]) extends java.lang.Iterable[T] {

    def iterator() = new JavaIterator[T](iterable.elements)

  }

  implicit def implicitScalaIterableToJavaIterable[T](iterable: Iterable[T]): java.lang.Iterable[T] =

    new JavaIterable[T](iterable)

}

package scapps.util

import scalaz.Scalaz._

import scalaz.{Validation, Success, Failure}

case class StringParser(s : String) {

  def parseLong: Validation[NumberFormatException, Long] = {

    (() => java.lang.Long.parseLong(s)).throws.left.map(_.asInstanceOf[NumberFormatException])

  }.fold(Failure(_), Success(_))

  def asLong: Option[Long] = parseLong.either.right.toOption

}

object StringParser {

  implicit def StringTo(s : String) = StringParser(s)

  implicit def StringFrom(p : StringParser) = p.s

}