/**
 * Copyright (C) 2009-2010 Scalable Solutions AB <http://scalablesolutions.se>
 */

package se.scalablesolutions.akka.persistence.redis

import se.scalablesolutions.akka.stm._
import se.scalablesolutions.akka.persistence.common._
import se.scalablesolutions.akka.util.Logging
import se.scalablesolutions.akka.config.Config.config

import com.redis._

trait Encoder {
  def encode(bytes: Array[Byte]): Array[Byte]
  def decode(bytes: Array[Byte]): Array[Byte]
}

trait CommonsCodecBase64 {
  import org.apache.commons.codec.binary.Base64._

  def encode(bytes: Array[Byte]): Array[Byte] = encodeBase64(bytes)
  def decode(bytes: Array[Byte]): Array[Byte] = decodeBase64(bytes)
}

object Base64Encoder extends Encoder with CommonsCodecBase64
import Base64Encoder._

/**
 * A module for supporting Redis based persistence.
 * <p/>
 * The module offers functionality for:
 * <li>Persistent Maps</li>
 * <li>Persistent Vectors</li>
 * <li>Persistent Refs</li>
 * <p/>
 * @author <a href="http://debasishg.blogspot.com">Debasish Ghosh</a>
 */
private [akka] object RedisStorageBackend extends 
  MapStorageBackend[Array[Byte], Array[Byte]] with 
  VectorStorageBackend[Array[Byte]] with 
  RefStorageBackend[Array[Byte]] with
  QueueStorageBackend[Array[Byte]] with
  SortedSetStorageBackend[Array[Byte]] with
  Logging {
    
  val REDIS_SERVER_HOSTNAME = config.getString("akka.storage.redis.hostname", "127.0.0.1")
  val REDIS_SERVER_PORT = config.getInt("akka.storage.redis.port", 6379)

  val db = new RedisClient(REDIS_SERVER_HOSTNAME, REDIS_SERVER_PORT)
  
  /**
   * Map storage in Redis.
   * <p/>
   * Maps are stored as key/value pairs in redis. <i>Redis keys cannot contain spaces</i>. But with
   * our use case, the keys will be specified by the user. Hence we need to encode the key
   * ourselves before sending to Redis. We use base64 encoding.
   * <p/>
   * Also since we are storing the key/value in the global namespace, we need to construct the
   * key suitably so as to avoid namespace clash. The following strategy is used:
   * 
   * Unique identifier for the map = T1 (say)
   * <pre>
   * Map(
   *   "debasish.address" -> "kolkata, India",
   *   "debasish.company" -> "anshinsoft",
   *   "debasish.programming_language" -> "scala",
   * )</pre>
   * will be stored as the following key-value pair in Redis:
   * 
   * <i>
   * base64(T1):base64("debasish.address") -> "kolkata, India"
   * base64(T1):base64("debasish.company") -> "anshinsoft"
   * base64(T1):base64("debasish.programming_language") -> "scala"
   * </i>
   */
  def insertMapStorageEntryFor(name: String, key: Array[Byte], value: Array[Byte]): Unit = withErrorHandling {
    insertMapStorageEntriesFor(name, List((key, value)))
  }

  def insertMapStorageEntriesFor(name: String, entries: List[Tuple2[Array[Byte], Array[Byte]]]): Unit = withErrorHandling {
    mset(entries.map(e =>
          (makeRedisKey(name, e._1), new String(e._2))))
  }
  
  /**
   * Make a redis key from an Akka Map key.
   * <p/>
   * The key is made as follows:
   * <li>redis key is composed of 2 parts: the transaction id and the map key separated by :</li>
   * <li>: is chosen since it cannot appear in base64 encoding charset</li>
   * <li>both parts of the key need to be based64 encoded since there can be spaces within each of them</li>
   */
  private [this] def makeRedisKey(name: String, key: Array[Byte]): String = withErrorHandling {
    "%s:%s".format(new String(encode(name.getBytes)), new String(encode(key)))
  }
  
  private [this] def makeKeyFromRedisKey(redisKey: String) = withErrorHandling {
    val nk = redisKey.split(':').map{e: String => decode(e.getBytes)}
    (nk(0), nk(1))
  }
  
  private [this] def mset(entries: List[(String, String)]): Unit = withErrorHandling {
    entries.foreach {e: (String, String) =>
      db.set(e._1, e._2)
    }
  }

  def removeMapStorageFor(name: String): Unit = withErrorHandling {
    db.keys("%s:*".format(encode(name.getBytes))) match {
      case None =>
        throw new Predef.NoSuchElementException(name + " not present")
      case Some(keys) =>
        keys.foreach(db.delete(_))
    }
  }

  def removeMapStorageFor(name: String, key: Array[Byte]): Unit = withErrorHandling {
    db.delete(makeRedisKey(name, key))
  }
    
  def getMapStorageEntryFor(name: String, key: Array[Byte]): Option[Array[Byte]] = withErrorHandling {
    db.get(makeRedisKey(name, key)) match {
      case None =>
        throw new Predef.NoSuchElementException(new String(key) + " not present")
      case Some(s) => Some(s.getBytes)
    }
  }

  def getMapStorageSizeFor(name: String): Int = withErrorHandling {
    db.keys("%s:*".format(new String(encode(name.getBytes)))) match {
      case None => 0
      case Some(keys) => 
        keys.length
    }
  }

  def getMapStorageFor(name: String): List[(Array[Byte], Array[Byte])] = withErrorHandling {
    db.keys("%s:*".format(new String(encode(name.getBytes)))) match {
      case None =>
        throw new Predef.NoSuchElementException(name + " not present")
      case Some(keys) =>
        keys.map(key => (makeKeyFromRedisKey(key)._2, db.get(key).get.getBytes)).toList
    }
  }

  def getMapStorageRangeFor(name: String, start: Option[Array[Byte]],
                            finish: Option[Array[Byte]],
                            count: Int): List[(Array[Byte], Array[Byte])] = withErrorHandling {

    import scala.collection.immutable.TreeMap
    val wholeSorted = 
      TreeMap(getMapStorageFor(name).map(e => (new String(e._1), e._2)): _*)

    if (wholeSorted isEmpty) List()

    val startKey =
      start match {
        case Some(bytes) => Some(new String(bytes))
        case None => None
      }

    val endKey =
      finish match {
        case Some(bytes) => Some(new String(bytes))
        case None => None
      }

    ((startKey, endKey, count): @unchecked) match {
      case ((Some(s), Some(e), _)) =>
        wholeSorted.range(s, e)
                   .toList
                   .map(e => (e._1.getBytes, e._2))
                   .toList
      case ((Some(s), None, c)) if c > 0 =>
        wholeSorted.from(s)
                   .elements
                   .take(count)
                   .map(e => (e._1.getBytes, e._2))
                   .toList
      case ((Some(s), None, _)) =>
        wholeSorted.from(s)
                   .toList
                   .map(e => (e._1.getBytes, e._2))
                   .toList
      case ((None, Some(e), _)) =>
        wholeSorted.until(e)
                   .toList
                   .map(e => (e._1.getBytes, e._2))
                   .toList
    }
  }
  
  def insertVectorStorageEntryFor(name: String, element: Array[Byte]): Unit = withErrorHandling {
    db.lpush(new String(encode(name.getBytes)), new String(element))
  }
  
  def insertVectorStorageEntriesFor(name: String, elements: List[Array[Byte]]): Unit = withErrorHandling {
    elements.foreach(insertVectorStorageEntryFor(name, _))
  }
  
  def updateVectorStorageEntryFor(name: String, index: Int, elem: Array[Byte]): Unit = withErrorHandling {
    db.lset(new String(encode(name.getBytes)), index, new String(elem))
  }
  
  def getVectorStorageEntryFor(name: String, index: Int): Array[Byte] = withErrorHandling {
    db.lindex(new String(encode(name.getBytes)), index) match {
      case None =>
        throw new Predef.NoSuchElementException(name + " does not have element at " + index)
      case Some(e) => e.getBytes
    }
  }
  
  def getVectorStorageRangeFor(name: String, start: Option[Int], finish: Option[Int], count: Int): List[Array[Byte]] = withErrorHandling {
    /**
     * <tt>count</tt> is the max number of results to return. Start with
     * <tt>start</tt> or 0 (if <tt>start</tt> is not defined) and go until
     * you hit <tt>finish</tt> or <tt>count</tt>.
     */
    val s = if (start.isDefined) start.get else 0
    val cnt =
      if (finish.isDefined) {
        val f = finish.get
        if (f >= s) Math.min(count, (f - s)) else count
      }
      else count
    db.lrange(new String(encode(name.getBytes)), s, s + cnt - 1) match {
      case None =>
        throw new Predef.NoSuchElementException(name + " does not have elements in the range specified")
      case Some(l) =>
        l map (_.get.getBytes)
    }
  }
  
  def getVectorStorageSizeFor(name: String): Int = {
    db.llen(new String(encode(name.getBytes))) match {
      case None =>
        throw new Predef.NoSuchElementException(name + " not present")
      case Some(l) => l
    }
  }
  
  def insertRefStorageFor(name: String, element: Array[Byte]): Unit = withErrorHandling {
    db.set(new String(encode(name.getBytes)), new String(element))
  }
  
  def getRefStorageFor(name: String): Option[Array[Byte]] = withErrorHandling {
    db.get(new String(encode(name.getBytes))) match {
      case None =>
        throw new Predef.NoSuchElementException(name + " not present")
      case Some(s) => Some(s.getBytes)
    }
  }

  // add to the end of the queue
  def enqueue(name: String, item: Array[Byte]): Boolean = withErrorHandling {
    db.rpush(new String(encode(name.getBytes)), new String(item))
  }


  // pop from the front of the queue
  def dequeue(name: String): Option[Array[Byte]] = withErrorHandling {
    db.lpop(new String(encode(name.getBytes))) match {
      case None =>
        throw new Predef.NoSuchElementException(name + " not present")
      case Some(s) =>
        Some(s.getBytes)
    }
  }
  
  // get the size of the queue
  def size(name: String): Int = withErrorHandling {
    db.llen(new String(encode(name.getBytes))) match {
      case None =>
        throw new Predef.NoSuchElementException(name + " not present")
      case Some(l) => l
    }
  }
  
  // return an array of items currently stored in the queue
  // start is the item to begin, count is how many items to return
  def peek(name: String, start: Int, count: Int): List[Array[Byte]] = withErrorHandling {
    count match {
      case 1 =>
        db.lindex(new String(encode(name.getBytes)), start) match {
          case None =>
            throw new Predef.NoSuchElementException("No element at " + start)
          case Some(s) =>
            List(s.getBytes)
        }
      case n =>
        db.lrange(new String(encode(name.getBytes)), start, start + count - 1) match {
          case None =>
            throw new Predef.NoSuchElementException(
              "No element found between " + start + " and " + (start + count - 1))
          case Some(es) =>
            es.map(_.get.getBytes)
        }
     }
  }
  
  // completely delete the queue
  def remove(name: String): Boolean = withErrorHandling {
    db.delete(new String(encode(name.getBytes))) match {
      case Some(1) => true
      case _ => false
    }
  }
  
  // add item to sorted set identified by name
  def zadd(name: String, zscore: String, item: Array[Byte]): Boolean = withErrorHandling {
    db.zadd(new String(encode(name.getBytes)), zscore, new String(item)) match {
      case Some(1) => true
      case _ => false
    }
  }
  
  // remove item from sorted set identified by name
  def zrem(name: String, item: Array[Byte]): Boolean = withErrorHandling {
    db.zrem(new String(encode(name.getBytes)), new String(item)) match {
      case Some(1) => true
      case _ => false
    }
  }
  
  // cardinality of the set identified by name
  def zcard(name: String): Int = withErrorHandling {
    db.zcard(new String(encode(name.getBytes))) match {
      case None =>
        throw new Predef.NoSuchElementException(name + " not present")
      case Some(l) => l
    }
  }
  
  def zscore(name: String, item: Array[Byte]): String = withErrorHandling {
    db.zscore(new String(encode(name.getBytes)), new String(item)) match {
      case None =>
        throw new Predef.NoSuchElementException(new String(item) + " not present")
      case Some(s) => s
    }
  }
  
  def zrange(name: String, start: Int, end: Int): List[Array[Byte]] = withErrorHandling {
    db.zrange(new String(encode(name.getBytes)), start.toString, end.toString, RedisClient.ASC, false) match {
      case None => 
        throw new Predef.NoSuchElementException(name + " not present")
      case Some(s) =>
        s.map(_.get.getBytes)
    }
  }
  
  def flushDB = withErrorHandling(db.flushDb)

  private def withErrorHandling[T](body: => T): T = {
    try {
      body
    } catch {
      case e: java.lang.NullPointerException =>
        throw new StorageException("Could not connect to Redis server")
      case e =>
        throw new StorageException("Error in Redis: " + e.getMessage)
    }
  }
}