import colossus._
import service._
import protocols.http._
import UrlParsing._
import HttpMethod._

object Main extends App {
  
  implicit val io_system = IOSystem()

  Service.become[Http]("http-echo", 9000){
    case request @ Get on Root => request.ok("Hello world!")
    case request @ Get on Root / "echo" / str => request.ok(str)
  }
}

class KeyValDB extends Actor {

  import KeyValDB._

  val db = collection.mutable.Map[ByteString, ByteString]()

  def receive = {
    case Get(key, promise) => promise.success(db.get(key))
    case Set(key, value, promise) => {
      db(key) = value
      promise.success(())
    }
  }
}

object KeyValDB {
  case class Get(key: ByteString, promise: Promise[Option[ByteString]] = Promise())
  case class Set(key: ByteString, value: ByteString, promise: Promise[Unit] = Promise())
}

object KeyValExample {
  
  def start(port: Int)(implicit io: IOSystem): ServerRef = {
    import io.actorSystem.dispatcher

    val db = io.actorSystem.actorOf(Props[KeyValDB])

    Service.become[Redis]("key-value-example", port){
      case Command("GET", args) => {
        val dbCmd = KeyValDB.Get(args(0))
        db ! dbCmd
        dbCmd.promise.future.map{
          case Some(value) => BulkReply(value)
          case None => NilReply
        }
      }
      case Command("SET", args) => {
        val dbCmd = KeyValDB.Set(args(0), args(1))
        db ! dbCmd
        dbCmd.promise.future.map{_ =>
          StatusReply("OK")
        }
      }
    }
  }
}

object HttpExample {

  /**
   * Here we're demonstrating a common way of breaking out the business logic
   * from the server setup, which makes functional testing easy
   */
  class HttpRoutes(redis: LocalClient[Command, Reply]) {
    
    def invalidReply(reply: Reply) = s"Invalid reply from redis $reply"    

    val handler: PartialFunction[HttpRequest, Response[HttpResponse]] = {
      case req @ Get on Root => req.ok("Hello World!")

      case req @ Get on Root / "get"  / key => redis.send(Commands.Get(ByteString(key))).map{
        case BulkReply(data) => req.ok(data.utf8String)
        case NilReply => req.notFound("(nil)")
        case other => req.error(invalidReply(other))
      }

      case req @ Get on Root / "set" / key / value => redis.send(Commands.Set(ByteString(key), ByteString(value))).map{
        case StatusReply(msg) => req.ok(msg)
        case other => req.error(invalidReply(other))
      }

    }

  }


  def start(port: Int, redisAddress: InetSocketAddress)(implicit system: IOSystem): ServerRef = {
    Service.serve[Http]("http-example", port){context =>
      val redis = context.clientFor[Redis](redisAddress.getHostName, redisAddress.getPort)
      //because our routes object has no internal state, we can share it among
      //connections.  If the class did have some per-connection internal state,
      //we'd just create one per connection
      val routes = new HttpRoutes(redis)

      context.handle{connection => 
        connection.become(routes.handler)
      }
    }
  }

}