package main

import "encoding/gob"
import "fmt"
import "net"
import "os"

type Netdata struct {
    Type int
    Data interface{}
}

type Subdata struct {
    IntField    int
    StringField string
}

func main() {
    if os.Args[1] == "server" {
        server("localhost:8011")
    } else {
        client("localhost:8011")
    }

}

func server(listen string) {

    if netlisten, err := net.Listen("tcp", listen); err != nil {
        fmt.Printf("Unable to listen on: %s (%s)", listen, err.Error())
    } else {
        defer netlisten.Close()
        for {
            if conn, err := netlisten.Accept(); err != nil {
                fmt.Printf("Connection DENIED on: %s (%s)\n", listen, err.Error())
            } else {
                fmt.Printf("Connection accepted on: %s\n", listen)
                send_message(conn, "server")
                // recv_message(conn)
            }
        }
    }
}

func client(server string) {
    if conn, err := net.Dial("tcp", server); err != nil {
        fmt.Printf("Unable to connect to : %s\n", server)

    } else {
        // Connected
        fmt.Printf("Connected to : %s\n", server)

        // send_message(conn, "client")
        recv_message(conn)

    }

}

func recv_message(conn net.Conn) {

    var data Netdata

    fmt.Printf("Receiving message... \n")
    dec := gob.NewDecoder(conn)
    if err := dec.Decode(&data); err != nil {
        fmt.Printf("Error! %s\n", err.Error())
    } else {
        sd := data.Data.(Subdata)

        fmt.Printf("Data: %s\n", sd.StringField)
    }
}

func send_message(conn net.Conn, msg string) {

    // Server now sends something
    sd := Subdata{IntField: 1, StringField: msg}
    d := Netdata{Type: 0, Data: sd}

    fmt.Printf("Sending message... \n")
    enc := gob.NewEncoder(conn)
    enc.Encode(d)
    fmt.Printf("Sent!\n")
}