// examples/auth/server.go

package main

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

	"net"
	"os"
	"os/signal"
	"syscall"

	"github.com/golang-jwt/jwt/v4"
	pb "github.com/romnn/go-service/examples/auth/gen"
	"github.com/romnn/go-service/pkg/auth"
	"google.golang.org/grpc"
	"google.golang.org/grpc/codes"
	"google.golang.org/grpc/status"
	"google.golang.org/protobuf/types/known/timestamppb"
)

// User represents a user
type User struct {
	Email          string
	HashedPassword string
}

// UserDatabase is a mock user database
type UserDatabase interface {
	GetUserByEmail(email string) (*User, error)
	AddUser(user *User)
	RemoveUserByEmail(email string) (*User, error)
}

type userDatabase struct {
	users map[string]*User
}

// AddUser adds a user to the database
func (db *userDatabase) AddUser(user *User) {
	db.users[user.Email] = user
}

// RemoveUserByEmail removes a user
func (db *userDatabase) RemoveUserByEmail(email string) (*User, error) {
	if user, ok := db.users[email]; ok {
		delete(db.users, email)
		return user, nil
	}
	return nil, fmt.Errorf("no user with email %q", email)
}

// GetUserByEmail gets a user
func (db *userDatabase) GetUserByEmail(email string) (*User, error) {
	if user, ok := db.users[email]; ok {
		return user, nil
	}
	return nil, fmt.Errorf("no user with email %q", email)
}

// AuthService ...
type AuthService struct {
	pb.UnimplementedAuthServer
	Authenticator *auth.Authenticator
	Database      UserDatabase
}

// Claims encode the JWT token claims
type Claims struct {
	UserEmail string `json:"user-email"`
	jwt.RegisteredClaims
}

// GetRegisteredClaims returns the standard claims that will be set automatically
func (claims *Claims) GetRegisteredClaims() *jwt.RegisteredClaims {
	// MUST return pointer to registered claims of this struct
	return &claims.RegisteredClaims
}

// Validate validates a token
func (s *AuthService) Validate(ctx context.Context, in *pb.ValidationRequest) (*pb.ValidationResult, error) {
	valid, token, err := s.Authenticator.Validate(in.GetToken(), &Claims{})
	if err != nil {
		log.Println(err)
		return &pb.ValidationResult{Valid: false}, status.Error(codes.Internal, "Failed to validate token")
	}
	if claims, ok := token.Claims.(*Claims); ok && valid {
		log.Printf("valid authentication claims: %v", claims)
		return &pb.ValidationResult{Valid: true}, nil
	}
	return &pb.ValidationResult{Valid: false}, nil
}

// Login logs in a user
func (s *AuthService) Login(ctx context.Context, in *pb.LoginRequest) (*pb.AuthToken, error) {
	user, err := s.Database.GetUserByEmail(in.GetEmail())
	if err != nil {
		log.Println(err)
		return nil, status.Error(codes.NotFound, "no such user")
	}
	if !auth.CheckPasswordHash(in.GetPassword(), user.HashedPassword) {
		return nil, status.Error(codes.Unauthenticated, "unauthorized")
	}

	// authenticated
	token, err := s.Authenticator.SignJwtClaims(&Claims{
		UserEmail: user.Email,
	})
	if err != nil {
		log.Println(err)
		return nil, status.Error(codes.Internal, "error while signing token")
	}

	expirationTime := time.Now().Add(s.Authenticator.ExpiresAfter)
	return &pb.AuthToken{
		Token:   token,
		Email:   user.Email,
		Expires: timestamppb.New(expirationTime),
	}, nil
}

func main() {
	listener, err := net.Listen("tcp", ":8080")
	if err != nil {
		log.Fatalf("failed to listen: %v", err)
	}

	authenticator := auth.Authenticator{
		ExpiresAfter: 100 * time.Second,
		Issuer:       "issuer@example.org",
		Audience:     "example.org",
	}

	keyConfig := auth.KeyConfig{Generate: true}
	if err := authenticator.SetupKeys(&keyConfig); err != nil {
		log.Fatalf("failed to setup keys: %v", err)
	}

	service := AuthService{
		Authenticator: &authenticator,
		Database: &userDatabase{
			users: make(map[string]*User),
		},
	}

	server := grpc.NewServer()
	pb.RegisterAuthServer(server, &service)

	shutdown := make(chan os.Signal, 1)
	signal.Notify(shutdown, syscall.SIGINT, syscall.SIGTERM)
	go func() {
		<-shutdown
		log.Println("shutdown ...")
		server.GracefulStop()
		listener.Close()
	}()

	log.Printf("listening on: %v", listener.Addr())
	if err := server.Serve(listener); err != nil {
		log.Fatalf("failed to serve: %v", err)
	}
}

// examples/reflect/server.go

package main

import (
	"context"
	"log"
	"net"
	"os"
	"os/signal"
	"syscall"

	pb "github.com/romnn/go-service/examples/reflect/gen"
	"github.com/romnn/go-service/pkg/grpc/reflect"
	"google.golang.org/grpc"
	"google.golang.org/protobuf/proto"

	"google.golang.org/grpc/codes"
	"google.golang.org/grpc/status"
)

// ReflectService implements the reflect service
type ReflectService struct {
	pb.UnimplementedReflectServer
}

func (s *ReflectService) getAnnotations(ctx context.Context) (*pb.Annotations, error) {
	info, ok := reflect.GetMethodInfo(ctx)
	if !ok {
		return nil, status.Error(codes.Internal, "failed to get grpc method info")
	}
	var annotations pb.Annotations
	methodOptions := info.Method().Options()
	if boolValue, ok := proto.GetExtension(methodOptions, pb.E_BoolValue).(bool); ok {
		annotations.BoolValue = boolValue
	}
	if stringValue, ok := proto.GetExtension(methodOptions, pb.E_StringValue).(string); ok {
		annotations.StringValue = stringValue
	}
	if intValue, ok := proto.GetExtension(methodOptions, pb.E_IntValue).(int32); ok {
		annotations.IntValue = intValue
	}
	return &annotations, nil
}

// GetNoAnnotations returns the options of this GRPC method
func (s *ReflectService) GetNoAnnotations(ctx context.Context, req *pb.Empty) (*pb.Annotations, error) {
	return s.getAnnotations(ctx)
}

// GetAnnotations returns the options of this GRPC method
func (s *ReflectService) GetAnnotations(ctx context.Context, req *pb.Empty) (*pb.Annotations, error) {
	return s.getAnnotations(ctx)
}

func main() {
	listener, err := net.Listen("tcp", ":8080")
	if err != nil {
		log.Fatalf("failed to listen: %v", err)
	}

	service := ReflectService{}
	registry := reflect.NewRegistry()
	server := grpc.NewServer(
		grpc.ChainUnaryInterceptor(reflect.UnaryServerInterceptor(registry)),
		grpc.ChainStreamInterceptor(reflect.StreamServerInterceptor(registry)),
	)
	pb.RegisterReflectServer(server, &service)
	registry.Load(server)

	shutdown := make(chan os.Signal, 1)
	signal.Notify(shutdown, syscall.SIGINT, syscall.SIGTERM)
	go func() {
		<-shutdown
		log.Println("shutdown ...")
		server.GracefulStop()
		listener.Close()
	}()

	log.Printf("listening on: %v", listener.Addr())
	if err := server.Serve(listener); err != nil {
		log.Fatalf("failed to serve: %v", err)
	}
}