package main

import (
	"context"
	"flag"
	"fmt"
	"log"
	"os"
	"os/signal"
	"syscall"

	"github.com/libp2p/go-libp2p"
	peerstore "github.com/libp2p/go-libp2p/core/peer"
	"github.com/libp2p/go-libp2p/p2p/protocol/ping"
	"github.com/libp2p/go-libp2p/p2p/security/noise"
	"github.com/libp2p/go-libp2p/p2p/transport/tcp"
	multiaddr "github.com/multiformats/go-multiaddr"
)

const help = `pear [options] [<multiaddr>]

Options:
  -h    Output this help
`

func main() {
	var (
		helpFlag bool
		portFlag string
	)

	flag.BoolVar(&helpFlag, "h", false, "output help")
	flag.StringVar(&portFlag, "p", "9000", "port to listen on")
	flag.Parse()

	if helpFlag {
		fmt.Printf(help)
		os.Exit(0)
	}

	opts := []libp2p.Option{
		libp2p.RandomIdentity,
		libp2p.DisableMetrics(),
		libp2p.DisableRelay(),
		libp2p.Security(noise.ID, noise.New),
		libp2p.Transport(tcp.NewTCPTransport),
		libp2p.DefaultPeerstore,
		libp2p.DefaultConnectionManager,
		libp2p.DefaultMuxers,
		libp2p.ListenAddrStrings(
			fmt.Sprintf("/ip4/0.0.0.0/tcp/%s", portFlag),
		),
		libp2p.NATPortMap(),
		libp2p.Ping(false),
	}

	pear, err := libp2p.NewWithoutDefaults(opts...)
	if err != nil {
		log.Fatalf("failed to initialise libp2p: %s", err)
	}

	pingService := &ping.PingService{Host: pear}
	pear.SetStreamHandler(ping.ID, pingService.PingHandler)

	peerId, err := multiaddr.NewMultiaddr(fmt.Sprintf("/p2p/%s", pear.ID().Pretty()))
	if err != nil {
		log.Fatalf("failed to create new multiaddr: %s", err)
	}

	for _, addr := range pear.Addrs() {
		fmt.Println(addr.Encapsulate(peerId))
	}

	maddr := flag.Arg(0)
	if maddr != "" {
		addr, err := multiaddr.NewMultiaddr(maddr)
		if err != nil {
			log.Fatalf("failed to parse %s: %s", maddr, err)
		}

		peer, err := peerstore.AddrInfoFromP2pAddr(addr)
		if err != nil {
			log.Fatalf("failed to add %s to peer store: %s", addr, err)
		}

		if err := pear.Connect(context.Background(), *peer); err != nil {
			log.Fatalf("failed to connect to %s: %s", peer, err)
		}

		ch := pingService.Ping(context.Background(), peer.ID)
		for i := 0; i < 5; i++ {
			res := <-ch
			fmt.Println("pinged", addr, "in", res.RTT)
		}
	}

	ch := make(chan os.Signal, 1)
	signal.Notify(ch, syscall.SIGINT, syscall.SIGTERM)
	<-ch

	if err := pear.Close(); err != nil {
		log.Fatalf("failed to shutdown: %s", err)
	}
}