5G Network Slice Selection (NSSAI) Processor

/**
 * Single Network Slice Selection Assistance Information (S-NSSAI)
 * Per 3GPP TS 23.501 Section 5.15.2
 */
export interface SNSSAI {
  sst: SliceServiceType;    // Slice/Service Type (1 byte, 0-255)
  sd?: SliceDifferentiator; // Slice Differentiator (3 bytes, optional)
}

/**
 * Slice/Service Type (SST) - Standard values per 3GPP TS 23.501
 */
export enum SliceServiceType {
  eMBB = 1,    // Enhanced Mobile Broadband
  URLLC = 2,   // Ultra-Reliable Low Latency Communications
  MIoT = 3,    // Massive IoT (formerly mMTC)
  V2X = 4,     // Vehicle-to-Everything
  // 5-127: Reserved for future use
  // 128-255: Operator-specific slices
}

/**
 * Slice Differentiator (SD) - Optional 24-bit field
 * Used to differentiate multiple slices of same SST
 */
export type SliceDifferentiator = string; // Hex string: "000001" - "FFFFFF"

/**
 * Network Slice Selection Assistance Information (NSSAI)
 * Collection of up to 8 S-NSSAIs
 */
export interface NSSAI {
  snssaiList: SNSSAI[];
}

/**
 * Subscription Data containing slice configurations
 */
export interface SubscriptionData {
  supi: string;                    // Subscription Permanent Identifier
  plmnId: string;                  // Public Land Mobile Network ID
  configuredNSSAI: SNSSAI[];       // Slices subscriber is allowed to use
  defaultNSSAI?: SNSSAI;           // Default slice if none requested
  subscribedSliceData: Array<{
    snssai: SNSSAI;
    priority: number;              // 1 (highest) to 16 (lowest)
    maxBitRate: {
      uplink: number;              // Mbps
      downlink: number;            // Mbps
    };
    sessionAMBR: {                 // Aggregate Maximum Bit Rate
      uplink: string;              // "100 Mbps"
      downlink: string;            // "1 Gbps"
    };
  }>;
}

/**
 * NSSAI types exchanged during registration
 */
export interface NSSAIContext {
  requestedNSSAI?: NSSAI;          // From UE in Registration Request
  configuredNSSAI: NSSAI;          // From subscription data
  allowedNSSAI: NSSAI;             // AMF decision sent to UE
  rejectedNSSAI?: Array<{
    snssai: SNSSAI;
    cause: RejectionCause;
  }>;
}

export enum RejectionCause {
  NOT_AVAILABLE_IN_PLMN = \"Not available in current PLMN\",
  NOT_AVAILABLE_IN_REG_AREA = \"Not available in registration area\",
  NOT_SUBSCRIBED = \"Slice not subscribed\",
  NETWORK_SLICE_CONGESTION = \"Network slice congestion\"
}

import { SNSSAI, NSSAI, SubscriptionData, NSSAIContext, RejectionCause } from '../types/nssai';

export class NSSAISelector {
  /**
   * Select allowed slices for UE registration
   * Per 3GPP TS 23.502 Section 4.2.2.2.2
   */
  async selectAllowedNSSAI(
    requestedNSSAI: NSSAI | undefined,
    subscriptionData: SubscriptionData,
    plmnId: string
  ): Promise<NSSAIContext> {
    const context: NSSAIContext = {
      requestedNSSAI,
      configuredNSSAI: { snssaiList: subscriptionData.configuredNSSAI },
      allowedNSSAI: { snssaiList: [] },
      rejectedNSSAI: []
    };

    // If no Requested NSSAI, use default or all configured slices
    if (!requestedNSSAI || requestedNSSAI.snssaiList.length === 0) {
      if (subscriptionData.defaultNSSAI) {
        context.allowedNSSAI.snssaiList.push(subscriptionData.defaultNSSAI);
      } else {
        // Allow up to 8 slices (max per 3GPP spec)
        context.allowedNSSAI.snssaiList = subscriptionData.configuredNSSAI.slice(0, 8);
      }
      return context;
    }

    // Process each requested S-NSSAI
    for (const requestedSNSSAI of requestedNSSAI.snssaiList) {
      const result = await this.evaluateSNSSAI(
        requestedSNSSAI,
        subscriptionData,
        plmnId
      );

      if (result.allowed) {
        context.allowedNSSAI.snssaiList.push(requestedSNSSAI);
      } else {
        context.rejectedNSSAI!.push({
          snssai: requestedSNSSAI,
          cause: result.rejectionCause!
        });
      }
    }

    // If no slices allowed, assign default
    if (context.allowedNSSAI.snssaiList.length === 0 && subscriptionData.defaultNSSAI) {
      context.allowedNSSAI.snssaiList.push(subscriptionData.defaultNSSAI);
    }

    return context;
  }

  /**
   * Evaluate if single S-NSSAI should be allowed
   */
  private async evaluateSNSSAI(
    snssai: SNSSAI,
    subscriptionData: SubscriptionData,
    plmnId: string
  ): Promise<{ allowed: boolean; rejectionCause?: RejectionCause }> {
    // Check if subscribed
    const isSubscribed = subscriptionData.configuredNSSAI.some(
      configured => this.matchSNSSAI(snssai, configured)
    );

    if (!isSubscribed) {
      return {
        allowed: false,
        rejectionCause: RejectionCause.NOT_SUBSCRIBED
      };
    }

    // Check slice availability in network
    const isAvailable = await this.checkSliceAvailability(snssai, plmnId);
    if (!isAvailable) {
      return {
        allowed: false,
        rejectionCause: RejectionCause.NOT_AVAILABLE_IN_PLMN
      };
    }

    // Check network congestion
    const isCongested = await this.checkSliceCongestion(snssai);
    if (isCongested) {
      return {
        allowed: false,
        rejectionCause: RejectionCause.NETWORK_SLICE_CONGESTION
      };
    }

    return { allowed: true };
  }

  /**
   * Match two S-NSSAIs (SST must match, SD must match if present)
   */
  private matchSNSSAI(a: SNSSAI, b: SNSSAI): boolean {
    if (a.sst !== b.sst) return false;
    if (a.sd !== undefined && b.sd !== undefined) {
      return a.sd === b.sd;
    }
    return true; // SD optional, match on SST alone
  }

  /**
   * Check if slice is available in current PLMN
   */
  private async checkSliceAvailability(
    snssai: SNSSAI,
    plmnId: string
  ): Promise<boolean> {
    // Query network configuration for slice availability
    // In production, this would check AMF/SMF/UPF capacity
    return true; // Simplified for example
  }

  /**
   * Check if slice is congested
   */
  private async checkSliceCongestion(snssai: SNSSAI): Promise<boolean> {
    // Query real-time metrics from network functions
    // In production, check slice load vs capacity thresholds
    return false; // Simplified for example
  }

  /**
   * Validate S-NSSAI for PDU Session Establishment
   * Per 3GPP TS 23.502 Section 4.3.2
   */
  async validatePDUSessionNSSAI(
    snssai: SNSSAI,
    allowedNSSAI: NSSAI,
    dnn: string
  ): Promise<boolean> {
    // Check if S-NSSAI is in Allowed NSSAI from registration
    const isAllowed = allowedNSSAI.snssaiList.some(
      allowed => this.matchSNSSAI(snssai, allowed)
    );

    if (!isAllowed) {
      return false;
    }

    // Validate DNN (Data Network Name) is compatible with slice
    // e.g., "internet" for eMBB, "ims" for voice, "v2x" for V2X
    return this.validateDNN(snssai, dnn);
  }

  private validateDNN(snssai: SNSSAI, dnn: string): boolean {
    // Map of typical DNN to SST associations
    const dnnMapping: Record<string, number[]> = {
      'internet': [1], // eMBB
      'ims': [1],       // eMBB for voice
      'v2x': [4],       // V2X
      'iot': [3]        // mMTC
    };

    const allowedSSTs = dnnMapping[dnn.toLowerCase()];
    return allowedSSTs ? allowedSSTs.includes(snssai.sst) : false;
  }
}