package main

import (
	"context"
	"fmt"
	"log"
	"net"
	"time"

	pb_get_currenttime "serve_segments/stubs/serve_currenttime"
	pb_serve_segments "serve_segments/stubs/serve_segments"

	"google.golang.org/grpc"
	"google.golang.org/grpc/credentials/insecure"
)

const SERVE_CURRENTTIME_HOST = "localhost"
const SERVE_CURRENTTIME_PORT = 50000
const SERVE_SEGMENTS_HOST = "localhost"
const SERVE_SEGMENTS_PORT = 50001

type grpc_server struct {
	pb_serve_segments.UnimplementedServeSegmentsServer
}

type currentTimeResponse struct {
	hours          uint32
	minutes        uint32
	seconds        uint32
	milliseconds   uint32
	formatted_time string
}

var serveCurrentTimeServiceClient pb_get_currenttime.ServeCurrentTimeServiceClient

func GetCurrentTime(timezone string) currentTimeResponse {
	ctx, cancel := context.WithTimeout(context.Background(), time.Second)
	defer cancel()
	r, err := serveCurrentTimeServiceClient.GetCurrentTime(
		ctx,
		&pb_get_currenttime.GetCurrentTimeRequest{Timezone: timezone},
	)
	if err != nil {
		log.Fatalf("could not greet: %v", err)
	}

	return currentTimeResponse{
		hours:          r.Hours,
		minutes:        r.Minutes,
		seconds:        r.Seconds,
		milliseconds:   r.Milliseconds,
		formatted_time: r.FormattedTime,
	}
}

func (s *grpc_server) GetHours(
	ctx context.Context,
	in *pb_serve_segments.GetHoursRequest,
) (*pb_serve_segments.GetHoursResponse, error) {
	timezone := in.GetTimezone()
	current_time := GetCurrentTime(timezone)
	return &pb_serve_segments.GetHoursResponse{Hours: current_time.hours}, nil
}

func (s *grpc_server) GetMinutes(
	ctx context.Context,
	in *pb_serve_segments.GetMinutesRequest,
) (*pb_serve_segments.GetMinutesResponse, error) {
	timezone := in.GetTimezone()
	current_time := GetCurrentTime(timezone)
	return &pb_serve_segments.GetMinutesResponse{Minutes: current_time.minutes}, nil
}

func (s *grpc_server) GetSeconds(
	ctx context.Context,
	in *pb_serve_segments.GetSecondsRequest,
) (*pb_serve_segments.GetSecondsResponse, error) {
	timezone := in.GetTimezone()
	current_time := GetCurrentTime(timezone)
	return &pb_serve_segments.GetSecondsResponse{Seconds: current_time.seconds}, nil
}

func (s *grpc_server) GetMilliseconds(
	ctx context.Context,
	in *pb_serve_segments.GetMillisecondsRequest,
) (*pb_serve_segments.GetMillisecondsResponse, error) {
	timezone := in.GetTimezone()
	current_time := GetCurrentTime(timezone)
	return &pb_serve_segments.GetMillisecondsResponse{Milliseconds: current_time.milliseconds}, nil
}

func serve() {
	lis, err := net.Listen("tcp", fmt.Sprintf("%s:%d", SERVE_SEGMENTS_HOST, SERVE_SEGMENTS_PORT))
	if err != nil {
		log.Fatalf("failed to listen: %v", err)
	}

	// create ServeSegments server
	server := grpc.NewServer()
	pb_serve_segments.RegisterServeSegmentsServer(server, &grpc_server{})
	log.Printf("server listening at %v", lis.Addr())

	// create connection to ServeCurrentTime server
	getCurrentTimeConn, err := grpc.Dial(
		fmt.Sprintf("%s:%d", SERVE_CURRENTTIME_HOST, SERVE_CURRENTTIME_PORT),
		grpc.WithTransportCredentials(insecure.NewCredentials()),
	)
	if err != nil {
		log.Fatalf("did not connect: %v", err)
	}
	defer getCurrentTimeConn.Close()
	// create client
	serveCurrentTimeServiceClient = pb_get_currenttime.NewServeCurrentTimeServiceClient(getCurrentTimeConn)

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

func main() {
	serve()
}