package main

import (
	"context"
	"flag"
	"fmt"
	"net"
	"os"
	"os/signal"
	"syscall"
	"time"

	"git.pengzhan.dev/ddp-simulator/pkg/device"
	"git.pengzhan.dev/ddp-simulator/pkg/env"
	pb "git.pengzhan.dev/ddp-simulator/proto"
	log "github.com/sirupsen/logrus"
	"google.golang.org/grpc"
	"google.golang.org/grpc/credentials/insecure"
)

var (
	id    = flag.String("id", "0", "The device id")
	gip   = flag.String("gip", "127.0.0.1", "The global server ip")
	gport = flag.Int("gport", 3200, "The global server port")
)

func init() {
	flag.Parse()

	log.SetOutput(os.Stdout)
	log.SetLevel(log.TraceLevel)
	// log.SetReportCaller(true)
}

func main() {
	conn, err := grpc.NewClient(fmt.Sprintf("%s:%d", *gip, *gport), grpc.WithTransportCredentials(insecure.NewCredentials()))
	if err != nil {
		log.Fatalf("failed to connect to global server: %v", err)
	}
	client := pb.NewGlobalServiceClient(conn)
	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
	defer cancel()
	resp, err := client.Init(ctx, &pb.InitRequest{Id: *id})
	if err != nil {
		log.Fatalf("failed to init: %v", err)
	}

	d := device.NewDevice(*id, resp.Role, resp.Ip, int(resp.Port))
	if resp.Capacity != nil {
		d.UpdateCapacity(resp.Capacity)
	}
	if resp.ParentId != nil {
		d.UpdateParent(resp.ParentId, *resp.Pip, int(*resp.Pport))
		if err := d.RegisterClientRetry(context.TODO(), 30*time.Second); err != nil {
			log.WithField("device", d.ID).Fatalf("failed to register: %v", err)
		}
	}

	s := grpc.NewServer()
	lis, err := net.Listen(env.PROTOCOL, fmt.Sprintf("%s:%d", resp.Ip, resp.Port))
	if err != nil {
		log.Fatalf("failed to listen: %v", err)
	}
	c := make(chan os.Signal, 1)
	signal.Notify(c, os.Interrupt, syscall.SIGTERM)
	go func() {
		<-c
		os.Exit(1)
	}()
	pb.RegisterDeviceServer(s, d)

	log.Infof("device %s start on %s:%d", *id, resp.Ip, resp.Port)

	if err := s.Serve(lis); err != nil {
		log.Fatalf("failed to serve: %v", err)
	}
}