telecom-platform/apps/carrier-connector/main.go

package main

import (
	"context"
	"fmt"
	"net/http"
	"os"
	"strconv"
	"time"

	"github.com/gin-gonic/gin"
	"github.com/joho/godotenv"
	"github.com/nutcas3/telecom-platform/apps/carrier-connector/internal/config"
	"github.com/nutcas3/telecom-platform/apps/carrier-connector/internal/es2"
	"github.com/rs/zerolog"
)

var logger zerolog.Logger

// GSMA ES2+ Profile Order Request
type ProfileOrder struct {
	EID              string `json:"eid"`
	ICCID            string `json:"iccid"`
	IMSI             string `json:"imsi"`
	K                string `json:"k"`
	OPc              string `json:"opc"`
	MCC              string `json:"mcc"`
	MNC              string `json:"mnc"`
	ProfileType      string `json:"profileType"`
	ConfirmationCode string `json:"confirmationCode,omitempty"`
}

// GSMA ES2+ Profile Order Response
type ProfileResponse struct {
	ExecutionStatus string `json:"executionStatus"`
	StatusMessage   string `json:"statusMessage"`
	ProfileID       string `json:"profileId"`
	ActivationCode  string `json:"activationCode,omitempty"`
}

func main() {
	// Initialize logger
	logger = zerolog.New(os.Stdout).With().
		Timestamp().
		Str("service", "carrier-connector").
		Logger()

	// Load environment variables
	if err := godotenv.Load(); err != nil {
		logger.Info().Msg("No .env file found, using system environment")
	}

	// Initialize ES2+ client with GSMA protocol
	smdpURL := getEnv("SMDP_URL", "https://smdp.example.com")
	apiKey := getEnv("SMDP_API_KEY", "test-api-key")
	requesterID := getEnv("FUNCTIONALITY_REQUESTER_ID", "carrier-connector")
	insecure := getEnv("INSECURE_SKIP_VERIFY", "false") == "true"
	port := getEnv("PORT", "8080")

	es2Config := &config.ES2Config{
		BaseURL:                  smdpURL,
		APIKey:                   apiKey,
		FunctionalityRequesterID: requesterID,
		InsecureSkipVerify:       insecure,
	}

	client := es2.NewES2Client(es2Config)

	// Initialize Gin router
	router := gin.Default()

	// Add middleware for logging
	router.Use(gin.LoggerWithFormatter(func(param gin.LogFormatterParams) string {
		return fmt.Sprintf("%s - [%s] \"%s %s %s %d %s \"%s\" %s\"\n",
			param.ClientIP,
			param.TimeStamp.Format(time.RFC1123),
			param.Method,
			param.Path,
			param.Request.Proto,
			param.StatusCode,
			param.Latency,
			param.Request.UserAgent(),
			param.ErrorMessage,
		)
	}))

	// Add recovery middleware
	router.Use(gin.Recovery())

	// Initialize API routes
	setupRoutes(router, client)

	logger.Info().
		Str("port", port).
		Msg("Carrier Connector API server starting")

	// Start server
	if err := router.Run(":" + port); err != nil {
		logger.Fatal().Err(err).Msg("Failed to start server")
	}
}

func setupRoutes(router *gin.Engine, client *ES2Client) {
	api := router.Group("/api/v1")

	// Health check endpoint
	api.GET("/health", func(c *gin.Context) {
		c.JSON(http.StatusOK, gin.H{
			"status":    "healthy",
			"service":   "carrier-connector",
			"timestamp": time.Now().UTC(),
		})
	})

	// eSIM profile endpoints
	esim := api.Group("/esim")
	{
		// Order a new eSIM profile
		esim.POST("/profiles", orderProfileHandler(client))

		// Get profile status
		esim.GET("/profiles/:profileId", getProfileHandler(client))

		// List all profiles
		esim.GET("/profiles", listProfilesHandler(client))

		// Delete/disable profile
		esim.DELETE("/profiles/:profileId", deleteProfileHandler(client))
	}

	// Carrier management endpoints
	carrier := api.Group("/carrier")
	{
		// Get carrier info
		carrier.GET("/info", getCarrierInfoHandler(client))

		// Check SM-DP+ connectivity
		carrier.GET("/connectivity", checkConnectivityHandler(client))
	}
}

// API Handlers

func orderProfileHandler(client *es2.ES2Client) gin.HandlerFunc {
	return func(c *gin.Context) {
		var order ProfileOrder

		if err := c.ShouldBindJSON(&order); err != nil {
			logger.Error().Err(err).Msg("Invalid request body")
			c.JSON(http.StatusBadRequest, gin.H{
				"error":   "Invalid request body",
				"message": err.Error(),
			})
			return
		}

		// Validate required fields
		if order.ICCID == "" || order.IMSI == "" || order.K == "" || order.OPc == "" {
			c.JSON(http.StatusBadRequest, gin.H{
				"error":   "Missing required fields",
				"message": "ICCID, IMSI, K, and OPc are required",
			})
			return
		}

		logger.Info().
			Str("imsi", order.IMSI).
			Str("iccid", order.ICCID).
			Msg("API request: Ordering eSIM profile from SM-DP+")

		// Convert ProfileOrder to DownloadProfileRequest for GSMA ES2+ protocol
		downloadReq := &es2.DownloadProfileRequest{
			EID:              order.EID,
			ICCID:            order.ICCID,
			ProfileType:      order.ProfileType,
			ConfirmationCode: order.ConfirmationCode,
		}

		downloadResp, err := client.DownloadProfile(context.Background(), downloadReq)
		if err != nil {
			logger.Error().Err(err).Str("imsi", order.IMSI).Msg("Failed to order profile")
			c.JSON(http.StatusInternalServerError, gin.H{
				"error":   "Failed to order profile",
				"message": err.Error(),
			})
			return
		}

		logger.Info().
			Str("execution_status", downloadResp.ExecutionStatus).
			Str("status_message", downloadResp.StatusMessage).
			Str("imsi", order.IMSI).
			Msg("Profile ordered successfully via API")

		// Convert GSMA response to our API response format
		response := &ProfileResponse{
			ExecutionStatus: downloadResp.ExecutionStatus,
			StatusMessage:   downloadResp.StatusMessage,
			ProfileID:       order.ICCID, // Use ICCID as profile ID for our API
		}

		c.JSON(http.StatusOK, gin.H{
			"success": true,
			"profile": response,
		})
	}
}

func getProfileHandler(client *es2.ES2Client) gin.HandlerFunc {
	return func(c *gin.Context) {
		profileID := c.Param("profileId")

		if profileID == "" {
			c.JSON(http.StatusBadRequest, gin.H{
				"error":   "Missing profile ID",
				"message": "Profile ID is required",
			})
			return
		}

		logger.Info().
			Str("profile_id", profileID).
			Msg("API request: Getting eSIM profile status")

		// TODO: Implement actual profile retrieval from SM-DP+
		// For now, return a mock response
		c.JSON(http.StatusOK, gin.H{
			"success": true,
			"profile": gin.H{
				"profileId": profileID,
				"status":    "active",
				"createdAt": time.Now().UTC(),
			},
		})
	}
}

func listProfilesHandler(client *es2.ES2Client) gin.HandlerFunc {
	return func(c *gin.Context) {
		logger.Info().Msg("API request: Listing eSIM profiles")

		// Parse query parameters
		page := 1
		if pageStr := c.Query("page"); pageStr != "" {
			if parsed, err := strconv.Atoi(pageStr); err == nil && parsed > 0 {
				page = parsed
			}
		}

		limit := 20
		if limitStr := c.Query("limit"); limitStr != "" {
			if parsed, err := strconv.Atoi(limitStr); err == nil && parsed > 0 && parsed <= 100 {
				limit = parsed
			}
		}

		// TODO: Implement actual profile listing from database/SM-DP+
		// For now, return a mock response
		c.JSON(http.StatusOK, gin.H{
			"success": true,
			"profiles": []gin.H{
				{
					"profileId": "profile-123",
					"imsi":      "208930000000001",
					"status":    "active",
				},
				{
					"profileId": "profile-456",
					"imsi":      "208930000000002",
					"status":    "inactive",
				},
			},
			"pagination": gin.H{
				"page":  page,
				"limit": limit,
				"total": 2,
			},
		})
	}
}

func deleteProfileHandler(client *es2.ES2Client) gin.HandlerFunc {
	return func(c *gin.Context) {
		profileID := c.Param("profileId")

		if profileID == "" {
			c.JSON(http.StatusBadRequest, gin.H{
				"error":   "Missing profile ID",
				"message": "Profile ID is required",
			})
			return
		}

		logger.Info().
			Str("profile_id", profileID).
			Msg("API request: Deleting eSIM profile")

		// TODO: Implement actual profile deletion/disable from SM-DP+
		c.JSON(http.StatusOK, gin.H{
			"success": true,
			"message": "Profile deleted successfully",
		})
	}
}

func getCarrierInfoHandler(client *es2.ES2Client) gin.HandlerFunc {
	return func(c *gin.Context) {
		logger.Info().Msg("API request: Getting carrier information")

		c.JSON(http.StatusOK, gin.H{
			"success": true,
			"carrier": gin.H{
				"name":        "Example Carrier",
				"mcc":         "208",
				"mnc":         "93",
				"smdpUrl":     "https://smdp.example.com", // Use config value
				"supported":   true,
				"lastChecked": time.Now().UTC(),
			},
		})
	}
}

func checkConnectivityHandler(client *es2.ES2Client) gin.HandlerFunc {
	return func(c *gin.Context) {
		logger.Info().Msg("API request: Checking SM-DP+ connectivity")

		// Simple connectivity check using the ES2+ client
		// Use a GetProfileStatus request with dummy data to test connectivity
		req := &es2.GetProfileStatusRequest{
			EID:   "test-eid",
			ICCID: "test-iccid",
		}

		_, err := client.GetProfileStatus(context.Background(), req)

		isConnected := err == nil
		statusCode := 200
		if err != nil {
			statusCode = 500 // Assume connection error
		}

		c.JSON(http.StatusOK, gin.H{
			"success": true,
			"connectivity": gin.H{
				"smdpConnected": isConnected,
				"statusCode":    statusCode,
				"checkedAt":     time.Now().UTC(),
				"error":         nil,
			},
		})
	}
}

func getEnv(key, fallback string) string {
	if value := os.Getenv(key); value != "" {
		return value
	}
	return fallback
}