package grpc

import (
	"context"
	"github.com/pocketbase/pocketbase"
	"htwkalender/data-manager/service/db"
	"log"
	"net"

	"google.golang.org/grpc"
	pb "htwkalender/common/genproto/modules"
)

type ModulesGrpcHandler struct {
	app *pocketbase.PocketBase
	pb.UnimplementedModuleServiceServer
}

func (s *ModulesGrpcHandler) GetModule(ctx context.Context, in *pb.GetModuleRequest) (*pb.GetModuleResponse, error) {

	s.app.Logger().Info(
		"Protobuf - GetModule",
		"uuid", in.Uuid,
	)

	// get module from database by UUID
	module, err := db.FindModuleByUUID(s.app, in.Uuid)
	if err != nil {
		return nil, err
	}

	events, err := db.FindAllEventsByModule(s.app, module)
	if err != nil {
		return nil, err
	}

	//map module Events to proto struct Events
	protoEvents := make([]*pb.Event, 0)
	for _, event := range events {
		protoEvents = append(protoEvents, eventToProto(&event))
	}
	//map module to proto struct
	protoModule := &pb.Module{
		Uuid:     module.UUID,
		Name:     module.Name,
		Prof:     module.Prof,
		Course:   module.Course,
		Semester: module.Semester,
		Events:   protoEvents,
	}
	// Implement your logic here to fetch module data based on the UUID
	// Example response
	return &pb.GetModuleResponse{
		Module: protoModule,
	}, nil
}

func StartGRPCServer(app *pocketbase.PocketBase) {
	lis, err := net.Listen("tcp", ":50051")
	if err != nil {
		log.Fatalf("failed to listen: %v", err)
	}
	s := grpc.NewServer()
	pb.RegisterModuleServiceServer(s, &ModulesGrpcHandler{
		app: app,
	})
	log.Printf("server listening at %v", lis.Addr())
	if err := s.Serve(lis); err != nil {
		log.Fatalf("failed to serve: %v", err)
	}
}

func (s *ModulesGrpcHandler) GetEventsForModules(ctx context.Context, in *pb.GetModulesRequest) (*pb.GetEventsResponse, error) {

	s.app.Logger().Info(
		"Protobuf - GetEventsForModules",
		"uuids", in.Uuids,
	)

	events, err := db.GetPlanForModules(s.app, in.Uuids)
	if err != nil {
		return nil, err
	}

	return &pb.GetEventsResponse{
		Events: eventsToProto(events),
	}, nil
}