import ox.CSO._
import ox.cso.Connection
import ox.cso.NetIO
import ox.cso.SyncNetIO
import ox.cso.Components._

/**
        Remote hash-table client and server
*/
object RHT
{ var port   = 8086
  var trials = 10
  var size   = 10
  
  var par    = 1
  var client = true
  var sync   = false
  var netcon = true
  var host   = "localhost"
  
  type Client[S, T] = SyncNetIO.Client[S, T]
    
  def time: long = java.lang.System.currentTimeMillis
    
  def main(args: Array[String]) =
  { for (arg<-args)
    if (arg.equals("-sync"))       sync=true
    else
    if (arg.equals("-netio"))      netcon=false
    else
    if (arg.equals("-s"))          client=false 
    else
    if (arg.matches("-p=[0-9]+"))  port=Integer.parseInt(arg.substring(3)) 
    else
    if (arg.startsWith("-h="))     host=arg.substring(3)
    
    if (client)
    { val server = 
          if (netcon) 
              SyncNetIO.clientConnection[RHTReq,RHTRep](host,port)
          else
              NetIO.clientConnection[RHTReq,RHTRep](host,port,sync)
      
      val fromKbd = OneOne[String]
      
      keyboard(fromKbd).fork
      
      serve ( fromKbd ==> 
              { case raw =>
                { val line  = raw.trim
                  val instr = line.split("[ ]+")
                  instr.length match
                  { case 0 => 
                    case 1 => Console.println(server!?Get(instr(0)))
                    case 2 => 
                     instr(0) match
                     { case "del" => Console.println(server!?Del(instr(1)))
                       case _     => Console.println(server!?Set(instr(0), instr(1)))
                     }
                  }
                }
              }
            )
      
      server.close
    }
    else
    { val clients = OneOne[Client[RHTReq,RHTRep]]
      val table   = new scala.collection.mutable.HashMap[String, Value]
      var n = 0
      if (netcon)
         SyncNetIO.serverPort(port, clients).fork
      else
         NetIO.serverPort(port, clients).fork
      
      Console.println("Started Server on "+port)
      
      serve
      { clients ==> 
        { client =>
          Console.println(client.socket)        
          proc
          {
            val start = time
            serve ( client ==> 
                    { case Set(k, v)    => 
                      { table.update(k, Value(v, start))
                        client!Tack(start) 
                      }
                      case Get(k)       => 
                      { table get k match 
                        { case Some(v) => client!v
                          case None    => client!Nack
                        }
                      }
                      case Del(k)       => 
                      { table get k match 
                        { case Some(Value(_, t)) => { table -= k; client!Tack(t) }
                          case None              => client!Nack
                        }
                      }
                    } 
                 |  after(5000) ==> { stop }
                 ) 
            client.close
            Console.println("closed "+client.socket)
          } . fork;
        }
      }
    }
  }
}

trait RHTReq {}
trait RHTRep {}
case  object Ack                              extends RHTRep {}
case  object Nack                             extends RHTRep {}
case  class  Tack(time: long)                 extends RHTRep {}
case  class  Value(value: String,   time: long) extends RHTRep {}
case  class  Set(key: String, value: String)  extends RHTReq {}
case  class  Get(key: String)                 extends RHTReq {}
case  class  Del(key: String)                 extends RHTReq {}
case  object Timeout                          extends RHTReq {}