//package cluster
package main
import (
"encoding/csv"
"encoding/json"
"fmt"
"io"
"math/rand"
"net"
"os"
"strconv"
"time"
//"bytes"
)
const (
BROADCAST = -1
 )
var outbox, inbox chan *Envelope
var pids [10]int
var ips [10]string
type Envelope struct {
Pid   int
MsgId int64
Msg   interface{}
}
type Server interface {
Pid() int
Peers() []int
Outbox() chan *Envelope
Inbox() chan *Envelope
}
/*
func (envelope Envelope) Pid() int {
return envelope.MsgId
}
*/
var server Envelope
func (envelope Envelope) Peers() []int {
return nil //pids
}
func (envelope Envelope) Outbox() chan *Envelope {
return outbox
}
func (envelope Envelope) Inbox() chan *Envelope {
return inbox
}
func server_() {
// listen on a port
ln, err := net.Listen("tcp", ":9999")
//time.Sleep(time.Second * 2)
if err != nil {
	fmt.Println(err)
	return
}
for {
	c, err := ln.Accept()
	if err != nil {
		fmt.Println(err)
		continue
	} else {
		fmt.Println("handle")
		go handleServerConnection(c)
	}
} 
}
func handleServerConnection(c net.Conn) {
// receive the message
var msg Envelope
var b []byte
//	for{
c.Read(b)
/*
	if b == nil{
		continue
	}else{
		break
	}
*/
//	}
fmt.Println(b)
err := json.Unmarshal(b, &msg)
if err != nil { //ERORR !!!!
	fmt.Println(err)
} else {
	fmt.Println("Received : %+v", msg)
}
c.Close()
}
func client() {
// connect to the server
for msg := range outbox {
	c, err := net.Dial("tcp", "127.0.0.1:9999")
	if err != nil {
		fmt.Println(err)
		return
	}
	if err != nil {
		fmt.Println("error encoding the response to a join request")
		fmt.Println(err)
	}
	b, _ := json.Marshal(msg)
	fmt.Printf("the json: %s\n", b)
	c.Write(b)
	c.Close()
}
time.Sleep(time.Second * 2)
}
func New(myPid int, ConFile string) Envelope {
inbox = make(chan *Envelope, 100)
outbox = make(chan *Envelope, 100)
file, err := os.Open(ConFile)
if err != nil {
	fmt.Println("Error:", err)
}
defer file.Close()
reader := csv.NewReader(file)
i := 0
j := 0
for {
	record, err := reader.Read()
	if err == io.EOF {
		break
	} else if err != nil {
		fmt.Println("Error:", err)
	}
	x, _ := strconv.Atoi(record[0])
	pids[i] = x
	i++
	ips[j] = record[1]
	j++
}
fmt.Println("\n", ips)
fmt.Println("\n", pids)
MsgId := rand.Int63n(0x10000000)
server = Envelope{Pid: myPid, MsgId: MsgId, Msg: "Hello World :)"}
go server_()
go client()
var input string
fmt.Println("\n\nPress enter ---\n\n")
fmt.Scanln(&input)
return server
}
func main() {
//for i := 1; i <= 10; i++ {
server := New(12, "config.txt")
server.Outbox() <- &Envelope{Pid: BROADCAST, MsgId: server.MsgId, Msg: "hello there"}
select {
case envelope := <-server.Inbox():
	fmt.Printf("Received msg from %d: '%s'\n", envelope.Pid, envelope.Msg)
case <-time.After(2 * time.Second):
	println("Waited and waited. Ab thak gaya\n")
}
//fmt.Println(server.Pid, server.MsgId, server.Msg )
//}
}

{"pid":"0", "msgId":"500", "msg":"this is the message"}

type Envelope struct {
	Pid   int         `json:"pid"`
	MsgId int64       `json:"msgId"`
	Msg   interface{} `json:"msg"`
}