package main

import (
	"gob"
	"log"
	"net"
)

type MetaMsg struct {
	Msg interface{}
}

type Msg1 struct {
}

type Msg2 struct {
}

func Client() {
	c, err := net.Dial("unix", "", "@gobbers")
	if err != nil {
		log.Panicf("Dial failed: %#v", err)
	}
	enc := gob.NewEncoder(c)
	for {
		msg1 := Msg1{}
		err := enc.Encode(&MetaMsg{msg1})
		if err != nil {
			log.Panicf("Encode of Msg1 failed: %#v", err)
		}
		msg2 := Msg2{}
		err = enc.Encode(&MetaMsg{msg2})
		if err != nil {
			log.Panicf("Encode of Msg2 failed: %#v", err)
		}
	}

}

func acceptor(l net.Listener) {
	for {
		c, err := l.Accept()
		if err != nil {
			log.Panicf("Accept failed: %#v", err)
		}
		go clientHandler(c)
	}
}

func clientHandler(c net.Conn) {
	defer c.Close()
	dec := gob.NewDecoder(c)
	for {
		var msg MetaMsg
		err := dec.Decode(&msg)
		if err != nil {
			log.Panicf("Decode failed: %#v\n", err)
			return
		}
		log.Printf("Decoded a %#v from client", msg.Msg)
	}
}

func Main(listeners ...net.Listener) {
	for _, l := range listeners {
		go acceptor(l)
	}
	select {
	}
}

func main() {
	gob.Register(&Msg1{})
	gob.Register(&Msg2{})
	unix, err := net.Listen("unix", "@gobbers")
	if err != nil {
		log.Panicf("Listen failed: %#v", err)
	}
	go Main(unix)
	// one client works
	for i := 0; i < 2; i++ {
		go Client()
	}
	select {
	}
}