package main

import (
	"time"
	"encoding/gob"
	"fmt"
	"net"
	"os"
)

var ch = make(chan int)

func main() {
	gob.Register(new(RegisterRequest))
	gob.Register(new(net.UnixAddr))
	gob.Register(new(net.TCPAddr))

	addr := "/tmp/experiment.socket"
	os.Remove(addr)
	x := 3000
	go Server(x, addr)
	time.Sleep(5e8)
	Client(x,addr)
}

func check(err error) {
	if err != nil {
		panic(err)
	}
}

func Server(x int, addr string) {
	laddr, err := net.ResolveUnixAddr("unix", addr)
	check(err)
	l, err := net.ListenUnix("unix", laddr)
	check(err)

	c, err := l.Accept()
	check(err)
	enc := gob.NewEncoder(c)
	dec := gob.NewDecoder(c)

	for i := 0; i < x; i++ {
		<-ch
		fmt.Println(x)
		var anyMsg interface{}
		err = dec.Decode(&anyMsg)
		check(err)

		fmt.Printf("SERVER:Decoded msg : %v  err: %v\n", anyMsg, err)
		err = enc.Encode(&err)
		check(err)
		ch <- 0
	}
}

func Client(x int ,addr string) {

	fmt.Printf("Servicedial\n")

	uc, err := net.Dial("unix", addr)
	if err != nil {
		panic(err)
	}
	enc := gob.NewEncoder(uc)
	dec := gob.NewDecoder(uc)

	for i := 0; i < x; i++ {

		fmt.Printf("RR %v\n",x)
		tmp, err := requestResponse(enc, dec, regReq1)
		check(err)
		fmt.Printf("CLIENT: Decoded msg : %v  err: %v\n", tmp, err)
	}
}

func requestResponse(enc *gob.Encoder, dec *gob.Decoder, e interface{}) (interface{}, error) {
	fmt.Printf("to be enconded: %v\n", e)
	if err := enc.Encode(&e); err != nil {
		return nil, err
	}
	fmt.Printf("Request sent\n")
	ch <- 0

	<-ch
	var anyMsg interface{}
	if err := dec.Decode(&anyMsg); err != nil {
		return nil, err
	}
	fmt.Printf("Response receive\n")
	return anyMsg, nil
}

func regReq(servicetype []string) *RegisterRequest {
	sreg := []ServiceRegistration{}
	tcp1, _ := net.ResolveTCPAddr("tcp", "1.2.3.4:23123")
	tcp2, _ := net.ResolveTCPAddr("tcp", "11.21.31.41:23123")
	for _, v := range servicetype {
		sreg = append(sreg, ServiceRegistration{v, []net.Addr{tcp1, tcp2}})
	}
	return &RegisterRequest{
		sreg,
		[]byte{1, 2, 34, 5, 8, 4, 54, 48, 54, 21, 200},
		[]byte{1, 2, 34, 5, 8, 4, 54, 48, 54, 21, 200},
	}
}

var regReq1 = regReq([]string{"servicetype"})

type RegisterRequest struct {
	Services       []ServiceRegistration
	ConfigChecksum []byte
	BinaryChecksum []byte
}

type ServiceRegistration struct {
	ServiceType string
	Addresses   []net.Addr
}