package peers

import (
  "net"
  "os"
  "fmt"
  "strings"
  "errfn"
)

type Peer struct {
  address net.TCPAddr
  listener net.TCPListener
  connection net.TCPConn
}

func (p* Peer) SetAddr(port string) {
  service := ":" + port
  tcpAddr, err := net.ResolveTCPAddr("tcp4", service)
  errfn.Check(err)

  p.address = *tcpAddr
}

func (p* Peer) StartListening() {
  listener, err := net.ListenTCP("tcp", &p.address)
  errfn.Check(err)

  p.listener = *listener

  fmt.Printf("(%s) Waiting for peer connections...\n", os.Args[1])
  for {
    conn, err := p.listener.Accept()
    if err != nil {
      continue
    }

    handleConnection(conn)
  }
}

func (p* Peer) Connect(remote Peer) {
  peerconn, err := net.DialTCP("tcp4", nil, &remote.address)
  errfn.Check(err)

  fmt.Println("Found a remote peer")
  p.connection = *peerconn

  _, err = p.connection.Write([]byte("Hello from " + os.Args[1]))
  errfn.Check(err)

  var buf [512]byte

  n, err := p.connection.Read(buf[0:])
  errfn.Check(err)

  result := string(buf[0:n])
  fmt.Println(string(result))
}

func handleConnection(conn net.Conn) {
  // close connection on exit
  defer conn.Close()

  var buf [512]byte

  for {
    // read up to 512 bytes
    n, err := conn.Read(buf[0:])
    if err != nil {
      return
    }

    message := string(buf[0:n])
    fmt.Println(message)

    tokens := strings.Split(message, " ")
    if tokens[0] != "" {
      response := "Hi " + tokens[2] + ", from " + os.Args[1]
      // write the n bytes read
      _, err2 := conn.Write([]byte(response))
      if err2 != nil {
        return
      }
    }

  }
}