package main
import "fmt"
import "net"
import "bufio"
import "strings"

func readLineSafe(rw *bufio.ReadWriter) (string, error) {
  wasPrefix:=false
  var line string
  for isPrefix:=true;isPrefix; {
    var lineBuf []byte 
    var err error
    lineBuf,isPrefix,err = rw.ReadLine()
    if err != nil {
        return "",err
    }
    if isPrefix {
      wasPrefix=true
    } else {
      line=string(lineBuf)
    }
  }
  if wasPrefix {
      fmt.Println("line too long")
      fmt.Fprintf(rw,"line too long\n")
      rw.Flush()
      return "",nil
  }
  return line,nil
}

func connToReadWriter(c net.Conn) (*bufio.ReadWriter) {
    client_r := bufio.NewReaderSize(c,14)
    client_w := bufio.NewWriterSize(c,14)
    return bufio.NewReadWriter(client_r,client_w)
}

func handleConnection(c net.Conn) () {
    client:=connToReadWriter(c)
    fmt.Println("new connection")
    for {
         line,err:=readLineSafe(client)
         if err != nil {
          fmt.Println(err.Error())
          c.Close()
          return
         }
         if line == "" {
           continue
         }
         fmt.Printf("Received: %v\n", line)
         tokens:=strings.Fields(line)
         remainStr:=strings.Join(tokens[1:]," ")
         handleCmd(tokens,remainStr)
    }
}

func handleCmd(tokens []string, remainStr string) {
  cmd:=tokens[0]
  fmt.Printf("Handling Cmd: %v\n", cmd)
}
func main() {
  ln, err := net.Listen("unix", "/tmp/test.sock")
  if err != nil {
    fmt.Printf("Error: %s\n",err.Error())
    return
  }
  fmt.Printf("Listener started\n")
  for {
    conn, err := ln.Accept()
    if err != nil {
      // handle error
      continue
    }
    go handleConnection(conn)
  }
}