/**
 * @fileoverview Endpoint Metadata - Auth Matrix & Performance SLAs
 * v0.18.0 Enhancement: Contract-level auth and performance specifications
 * Purpose: Eliminate ambiguity, enable middleware enforcement, set SLA expectations
 */

import { z } from 'zod';

// Endpoint authentication levels
export const AuthLevel = z.enum(['public', 'user', 'service', 'admin']);

// HTTP methods
export const HttpMethod = z.enum(['GET', 'POST', 'PUT', 'DELETE', 'PATCH']);

// Performance SLA categories
export const PerformanceSLA = z.enum(['fast', 'standard', 'slow', 'batch']);

// Endpoint metadata schema
export const EndpointMeta = z.object({
  path: z.string(),
  method: HttpMethod,
  auth: AuthLevel,
  description: z.string(),
  
  // Performance expectations
  sla: PerformanceSLA,
  max_response_ms: z.number().int().positive(),
  
  // Pagination support
  supports_pagination: z.boolean().default(false),
  default_limit: z.number().int().positive().optional(),
  max_limit: z.number().int().positive().optional(),
  
  // Caching policy
  cache_ttl_seconds: z.number().int().nonnegative().optional(),
  
  // Deprecation info
  deprecated: z.boolean().default(false),
  deprecated_in: z.string().optional(),
  removed_in: z.string().optional(),
  replacement: z.string().optional()
}).strict();

// Endpoint registry schema
export const EndpointRegistrySchema = z.record(
  z.string(), // Endpoint path
  EndpointMeta
).describe('Complete endpoint registry with auth matrix');

// Complete endpoint registry with auth matrix and Zod schema validation
export const ENDPOINT_REGISTRY = {
  // === PUBLIC ENDPOINTS (no auth required) ===
  '/api/infra/health': {
    method: 'GET' as const,
    auth: 'public' as const,
    description: 'System health check',
    sla: 'fast' as const,
    max_response_ms: 100,
    cache_ttl_seconds: 30
  },
  
  '/api/infra/market/meta/universe': {
    method: 'GET' as const,
    auth: 'public' as const,
    description: 'Available trading symbols',
    sla: 'fast' as const,
    max_response_ms: 200,
    supports_pagination: true,
    default_limit: 100,
    max_limit: 1000,
    cache_ttl_seconds: 300
  },
  
  '/api/infra/market/meta/timeframes': {
    method: 'GET' as const,
    auth: 'public' as const,
    description: 'Supported timeframes',
    sla: 'fast' as const,
    max_response_ms: 100,
    cache_ttl_seconds: 3600
  },
  
  '/api/infra/marketplace/models': {
    method: 'GET' as const,
    auth: 'public' as const,
    description: 'Public model catalog (stub)',
    sla: 'standard' as const,
    max_response_ms: 300,
    supports_pagination: true,
    default_limit: 50,
    max_limit: 200
  },

  // === USER AUTHENTICATED ENDPOINTS ===
  '/api/infra/portfolio/summary': {
    method: 'GET' as const,
    auth: 'user' as const,
    description: 'User portfolio overview',
    sla: 'standard' as const,
    max_response_ms: 500,
    cache_ttl_seconds: 60
  },
  
  '/api/infra/portfolio/investments': {
    method: 'GET' as const,
    auth: 'user' as const,
    description: 'User manual investments',
    sla: 'standard' as const,
    max_response_ms: 300,
    supports_pagination: true,
    default_limit: 50,
    max_limit: 500
  },
  
  '/api/infra/trading/accounts': {
    method: 'GET' as const,
    auth: 'user' as const,
    description: 'User trading accounts',
    sla: 'standard' as const,
    max_response_ms: 400,
    cache_ttl_seconds: 120
  },
  
  '/api/infra/trading/positions': {
    method: 'GET' as const,
    auth: 'user' as const,
    description: 'User trading positions',
    sla: 'standard' as const,
    max_response_ms: 300,
    supports_pagination: true,
    default_limit: 100,
    max_limit: 1000
  },
  
  '/api/infra/ml/signals/latest': {
    method: 'GET' as const,
    auth: 'user' as const,
    description: 'Latest ML signals for user',
    sla: 'standard' as const,
    max_response_ms: 400,
    supports_pagination: true,
    default_limit: 20,
    max_limit: 100
  },
  
  '/api/infra/jobs/recent': {
    method: 'GET' as const,
    auth: 'user' as const,
    description: 'User recent jobs',
    sla: 'standard' as const,
    max_response_ms: 300,
    supports_pagination: true,
    default_limit: 50,
    max_limit: 200
  },

  // === SERVICE AUTHENTICATED ENDPOINTS (service role key) ===
  '/api/infra/ml/signals/store': {
    method: 'POST' as const,
    auth: 'service' as const,
    description: 'Store ML signal (ML team only)',
    sla: 'fast' as const,
    max_response_ms: 200
  },
  
  '/api/infra/ml/consensus/store': {
    method: 'POST' as const,
    auth: 'service' as const,
    description: 'Store ML consensus (ML team only)',
    sla: 'fast' as const,
    max_response_ms: 200
  },
  
  '/api/infra/market/data/bars/store': {
    method: 'POST' as const,
    auth: 'service' as const,
    description: 'Store market bars (Infrastructure only)',
    sla: 'standard' as const,
    max_response_ms: 500
  },
  
  '/api/infra/jobs/claim': {
    method: 'POST' as const,
    auth: 'service' as const,
    description: 'Worker claims job (Infrastructure only)',
    sla: 'fast' as const,
    max_response_ms: 100
  },

  // === ADMIN ENDPOINTS ===
  '/api/admin/users': {
    method: 'GET' as const,
    auth: 'admin' as const,
    description: 'User management',
    sla: 'standard' as const,
    max_response_ms: 500,
    supports_pagination: true,
    default_limit: 50,
    max_limit: 200
  },
  
  '/api/admin/system': {
    method: 'GET' as const,
    auth: 'admin' as const,
    description: 'System administration',
    sla: 'standard' as const,
    max_response_ms: 1000
  }
} as const;

// Complete Auth Matrix Export (Management requirement #7)
export const ENDPOINT_AUTH_MATRIX: Record<string, z.infer<typeof AuthLevel>> = {
  // === PUBLIC ENDPOINTS (no auth required) ===
  '/api/infra/health': 'public',
  '/api/infra/status': 'public',
  '/api/infra/version': 'public',
  '/api/infra/market/meta/universe': 'public',
  '/api/infra/market/meta/timeframes': 'public',
  '/api/infra/marketplace/models/catalog': 'public',
  '/api/auth/jwks': 'public',
  
  // === USER AUTHENTICATED ENDPOINTS ===
  '/api/auth/whoami': 'user',
  '/api/auth/validate': 'user',
  '/api/auth/permissions': 'user',
  '/api/user/profile': 'user',
  '/api/user/preferences': 'user',
  '/api/user/sessions': 'user',
  '/api/infra/portfolio/summary': 'user',
  '/api/infra/portfolio/investments': 'user',
  '/api/infra/trading/accounts': 'user',
  '/api/infra/trading/positions': 'user',
  '/api/infra/ml/signals/latest': 'user',
  '/api/infra/jobs/recent': 'user',
  '/api/infra/wealth/hl': 'user',
  
  // === SERVICE AUTHENTICATED ENDPOINTS ===
  '/api/infra/ml/signals/store': 'service',
  '/api/infra/ml/consensus/store': 'service',
  '/api/infra/ml/features/store': 'service',
  '/api/infra/market/data/bars/store': 'service',
  '/api/infra/market/data/indicators/store': 'service',
  '/api/infra/jobs/claim': 'service',
  '/api/infra/jobs/heartbeat': 'service',
  
  // === ADMIN ENDPOINTS ===
  '/api/admin/users': 'admin',
  '/api/admin/roles': 'admin',
  '/api/admin/permissions': 'admin',
  '/api/admin/system': 'admin',
  '/api/admin/audit': 'admin',
  '/api/admin/organizations': 'admin',
  '/api/admin/security': 'admin',
  '/api/admin/monitoring': 'admin'
} as const satisfies Record<string, z.infer<typeof AuthLevel>>;

// Helper functions for endpoint metadata
export function getEndpointAuth(path: string): z.infer<typeof AuthLevel> | null {
  const endpoint = ENDPOINT_REGISTRY[path as keyof typeof ENDPOINT_REGISTRY];
  return endpoint ? endpoint.auth : null;
}

export function getEndpointSLA(path: string): number | null {
  const endpoint = ENDPOINT_REGISTRY[path as keyof typeof ENDPOINT_REGISTRY];
  return endpoint?.max_response_ms || null;
}

export function isEndpointDeprecated(path: string): boolean {
  const endpoint = ENDPOINT_REGISTRY[path as keyof typeof ENDPOINT_REGISTRY];
  return false; // v0.18.0 endpoints are not deprecated yet
}

// Type exports
export type EndpointAuthLevel = z.infer<typeof AuthLevel>;
export type EndpointHttpMethod = z.infer<typeof HttpMethod>;
export type EndpointPerformanceSLA = z.infer<typeof PerformanceSLA>;
export type EndpointMetadata = z.infer<typeof EndpointMeta>;
export type EndpointRegistryType = z.infer<typeof EndpointRegistrySchema>;