s2core/src/main/scala/com/daumkakao/s2graph/core/GraphUtil.scala

package com.daumkakao.s2graph.core

import scala.util.hashing.MurmurHash3
import java.util.regex.Pattern
import play.api.libs.json.Json

object GraphUtil {
  private val seperator = HBaseElement.seperator
  private val TOKEN_DELIMITER = Pattern.compile("[\t]")
  val operations = Map("i" -> 0, "insert" -> 0, "u" -> 1, "update" -> 1,
    "increment" -> 2,  "d" -> 3, "delete" -> 3, 
    "deleteAll" -> 4, "insertBulk" -> 5).map {
      case (k, v) =>
        (k -> v.toByte)
    }
  val directions = Map("out" -> 0, "in" -> 1, "undirected" -> 2, "u" -> 2, "directed" -> 0, "d" -> 0)
  val consistencyLevel = Map("weak" -> 0, "strong" -> 1)
  
  def toType(t: String) = {
    t.trim().toLowerCase() match {
      case "e" | "edge" => "edge"
      case "v" | "vertex" => "vertex"
    }
  }
  def toDir(direction: String): Option[Byte] = {
    val d = direction.trim().toLowerCase() match {
      case "directed" | "d" => Some(0)
      case "undirected" | "u" => Some(2)
      case "out" => Some(0)
      case "in" => Some(1)
      case _ => None
    }
    d.map(x => x.toByte)
  }
  def toDirection(direction: String): Int = {
    direction.trim().toLowerCase() match {
      case "directed" | "d" => 0
      case "undirected" | "u" => 2
      case "out" => 0
      case "in" => 1
      case _ => 2
    }
  }
  def fromDirection(direction: Int) = {
    direction match {
      case 0 => "out"
      case 1 => "in"
      case 2 => "undirected"
    }
  }
  def toggleDir(dir: Int) = {
    dir match {
      case 0 => 1
      case 1 => 0
      case 2 => 2
      case _ => throw new UnsupportedOperationException(s"toggleDirection: $dir")
    }
  }
  def toOp(op: String): Option[Byte] = {
    op.trim() match {
      case "i" | "insert" => Some(0)
      case "d" | "delete" => Some(3)
      case "u" | "update" => Some(1)
      case "increment" => Some(2)
      case "deleteAll" => Some(4)
      case "insertBulk" => Some(5)
      case _ => None
    }
  }
  def fromOp(op: Byte): String = {
    op match {
      case 0 => "insert"
      case 3 => "delete"
      case 1 => "update"
      case 2 => "increment"
      case 4 => "deleteAll"
      case 5 => "insertBulk"
      case _ =>
        throw new UnsupportedOperationException(s"op : $op (only support 0(insert),1(delete),2(updaet),3(increment))")
    }
  }
//  def toggleOp(op: Byte): Byte = {
//    val ret = op match {
//      case 0 => 1
//      case 1 => 0
//      case x: Byte => x
//    }
//    ret.toByte
//  }
  // 2^31 - 1
  def transformHash(h: Int): Int = {
    //    h / 2 + (Int.MaxValue / 2 - 1)
    if (h < 0) -1 * (h + 1) else h
  }
  def murmur3(s: String): Short = {
    val hash = MurmurHash3.stringHash(s)
    val positiveHash = transformHash(hash) >> 16
    positiveHash.toShort
  }
  
  def smartSplit(s: String, delemiter: String) = {
    val trimed_string = s.trim()
    if (trimed_string.equals("")) {
      List[String]()
    } else {
      trimed_string.split(delemiter).toList
    }
  }

  def split(line: String) = TOKEN_DELIMITER.split(line)

  def parseString(s: String): List[String] = {
    if (!s.startsWith("[")) {
      s.split("\n").toList
    } else {
      Json.parse(s).asOpt[List[String]].getOrElse(List.empty[String])
    }
  }
  
}