syntax = "proto3";

package graph;

// Dịch vụ mà sidecar sẽ cung cấp
service GraphService {
  rpc GetUser (UserRequest) returns (UserResponse);
}

// Yêu cầu: khách hàng có thể cung cấp user_id
// Nếu trống, sidecar truy vấn "me" (người dùng hiện tại)
message UserRequest {
  string user_id = 1;
}

// Phản hồi: dữ liệu cơ bản của người dùng trong Graph
message UserResponse {
  string id = 1;
  string display_name = 2;
  string given_name = 3;
  string surname = 4;
  string user_principal_name = 5;
}

protoc --go_out=. --go-grpc_out=. graph.proto

package main

import (
    "bytes"
    "context"
    "encoding/json"
    "fmt"
    "io"
    "net"
    "net/http"
    "os"
    "sync"
    "time"

    pb "example.com/graph/proto" // điều chỉnh cho đúng đường dẫn
    "google.golang.org/grpc"
)

const (
    tokenURL = "https://login.microsoftonline.com/%s/oauth2/v2.0/token"
    graphURL = "https://graph.microsoft.com/v1.0/%s"
)

// Máy chủ gRPC sẽ chạy như một sidecar
type server struct {
    pb.UnimplementedGraphServiceServer
    mu          sync.Mutex
    accessToken string
    expiration  time.Time
}

func (s *server) getToken(ctx context.Context) (string, error) {
    s.mu.Lock()
    defer s.mu.Unlock()

    // Nếu đã có token hợp lệ, tái sử dụng
    if time.Now().Before(s.expiration) && s.accessToken != "" {
        return s.accessToken, nil
    }

    // Nếu không, yêu cầu token mới từ Entra ID
    tenantID := os.Getenv("ENTRA_TENANT_ID")
    clientID := os.Getenv("ENTRA_CLIENT_ID")
    clientSecret := os.Getenv("ENTRA_CLIENT_SECRET")

    url := fmt.Sprintf(tokenURL, tenantID)
    data := []byte(fmt.Sprintf(
        "client_id=%s&scope=https%%3A%%2F%%2Fgraph.microsoft.com%%2F.default&client_secret=%s&grant_type=client_credentials",
        clientID, clientSecret,
    ))

    req, _ := http.NewRequestWithContext(ctx, "POST", url, bytes.NewBuffer(data))
    req.Header.Set("Content-Type", "application/x-www-form-urlencoded")

    resp, err := http.DefaultClient.Do(req)
    if err != nil {
        return "", err
    }
    defer resp.Body.Close()

    body, _ := io.ReadAll(resp.Body)
    if resp.StatusCode != http.StatusOK {
        return "", fmt.Errorf("lỗi khi lấy token: %s", string(body))
    }

    var token struct {
        AccessToken string `json:"access_token"`
        ExpiresIn   int    `json:"expires_in"`
    }
    if err := json.Unmarshal(body, &token); err != nil {
        return "", err
    }

    // Cập nhật cache (tái tạo 1 phút trước khi hết hạn)
    s.accessToken = token.AccessToken
    s.expiration = time.Now().Add(time.Duration(token.ExpiresIn-60) * time.Second)

    return s.accessToken, nil
}

func (s *server) GetUser(ctx context.Context, req *pb.UserRequest) (*pb.UserResponse, error) {
    // 1. Đảm bảo token hợp lệ
    token, err := s.getToken(ctx)
    if err != nil {
        return nil, err
    }

    // 2. Tạo endpoint
    userEndpoint := "me"
    if req.UserId != "" {
        userEndpoint = "users/" + req.UserId
    }

    url := fmt.Sprintf(graphURL, userEndpoint)
    httpReq, _ := http.NewRequestWithContext(ctx, "GET", url, nil)
    httpReq.Header.Set("Authorization", "Bearer "+token)

    // 3. Thực hiện yêu cầu tới Microsoft Graph
    resp, err := http.DefaultClient.Do(httpReq)
    if err != nil {
        return nil, err
    }
    defer resp.Body.Close()

    body, _ := io.ReadAll(resp.Body)
    if resp.StatusCode != http.StatusOK {
        return nil, fmt.Errorf("lỗi khi tìm người dùng: %s", string(body))
    }

    // 4. Ánh xạ phản hồi sang UserResponse
    var user map[string]interface{}
    if err := json.Unmarshal(body, &user); err != nil {
        return nil, err
    }

    return &pb.UserResponse{
        Id:                user["id"].(string),
        DisplayName:       user["displayName"].(string),
        GivenName:         user["givenName"].(string),
        Surname:           user["surname"].(string),
        UserPrincipalName: user["userPrincipalName"].(string),
    }, nil
}

func main() {
    lis, err := net.Listen("tcp", ":50051")
    if err != nil {
        panic(err)
    }
    grpcServer := grpc.NewServer()
    pb.RegisterGraphServiceServer(grpcServer, &server{})
    fmt.Println("Sidecar Microsoft Graph đang chạy trên :50051")
    if err := grpcServer.Serve(lis); err != nil {
        panic(err)
    }
}

   export ENTRA_CLIENT_ID="client-id-của-bạn"
   export ENTRA_CLIENT_SECRET="secret-của-bạn"
   export ENTRA_TENANT_ID="tenant-id-của-bạn"

   go run sidecar.go

   grpcurl -plaintext -d '{}' localhost:50051 graph.GraphService/GetUser

{
  "id": "1234abcd-...",
  "display_name": "Nguyễn Văn A",
  "given_name": "Nguyễn",
  "surname": "Văn A",
  "user_principal_name": "nguyenvana@doanhnghiep.com"
}