/**
 * @fileoverview Jobs Domain - Unified Async Task Orchestration  
 * v0.18.0 Enhancement: Team-specific workflows with enhanced metadata
 * Purpose: ML training, data ingestion, consensus building, marketplace operations
 */

import { z } from 'zod';

// Job types for all teams
export const JobType = z.enum([
  // ML Team workflows
  'ml.signal_generation',
  'ml.model_training', 
  'ml.backtest',
  'ml.consensus_build',
  'ml.feature_computation',
  'ml.model_deployment',
  'ml.performance_analysis',
  
  // Infrastructure workflows
  'infra.data_ingestion',
  'infra.database_migration',
  'infra.system_maintenance',
  'infra.backup_restore',
  
  // Frontend workflows  
  'frontend.report_generation',
  'frontend.data_export',
  'frontend.cache_warming',
  
  // Marketplace workflows
  'marketplace.model_validation',
  'marketplace.vendor_onboarding',
  'marketplace.deployment_scaling',
  'marketplace.revenue_calculation',
  
  // System workflows
  'system.health_check',
  'system.log_rotation',
  'system.cleanup'
]);

export const JobStatus = z.enum([
  'pending',     // Queued but not started
  'queued',      // In queue waiting for worker
  'running',     // Currently executing
  'succeeded',   // Completed successfully
  'failed',      // Failed with error
  'cancelled',   // Manually cancelled
  'timeout'      // Exceeded time limit
]);

export const JobPriority = z.number().int().min(1).max(10).default(5);

// Enhanced Job Schema with team-specific metadata
export const Job = z.object({
  // Core identification
  id: z.string().uuid(),
  type: JobType,
  owner: z.string(),                            // User or service that created job
  
  // Execution details
  status: JobStatus,
  priority: JobPriority,
  
  // Resource requirements
  estimated_duration_ms: z.number().int().positive().optional(),
  max_duration_ms: z.number().int().positive().default(1800000), // 30 min default
  cpu_cores: z.number().int().positive().default(1),
  memory_mb: z.number().int().positive().default(512),
  requires_gpu: z.boolean().default(false),
  
  // Team-specific metadata
  metadata: z.object({
    // ML-specific fields
    model_id: z.string().optional(),
    symbol: z.string().optional(),
    timeframe: z.string().optional(),
    features_used: z.array(z.string()).optional(),
    confidence_threshold: z.number().min(0).max(1).optional(),
    ensemble_weights: z.record(z.number()).optional(),
    
    // Infrastructure-specific fields
    migration_version: z.string().optional(),
    backup_target: z.string().optional(),
    affected_tables: z.array(z.string()).optional(),
    
    // Marketplace-specific fields
    vendor_id: z.string().uuid().optional(),
    deployment_id: z.string().uuid().optional(),
    billing_category: z.string().optional(),
    resource_pool: z.string().optional(),
    
    // Frontend-specific fields
    report_type: z.string().optional(),
    export_format: z.enum(['csv', 'json', 'pdf']).optional(),
    date_range: z.object({
      from: z.string().datetime(),
      to: z.string().datetime()
    }).optional(),
    
    // Generic fields
    custom_params: z.record(z.any()).optional()
  }).strict().optional(),
  
  // Execution tracking
  started_at: z.string().datetime().optional(),
  completed_at: z.string().datetime().optional(),
  heartbeat_at: z.string().datetime().optional(),
  
  // Results and logs
  result: z.record(z.any()).optional(),
  error_message: z.string().optional(),
  error_code: z.string().optional(),
  
  // Progress tracking
  progress_percent: z.number().min(0).max(100).default(0),
  progress_message: z.string().optional(),
  
  // Dependency management
  depends_on: z.array(z.string().uuid()).optional(),
  blocks: z.array(z.string().uuid()).optional(),
  
  // Audit trail
  created_at: z.string().datetime(),
  updated_at: z.string().datetime(),
  created_by: z.string(),
  
  // Retry configuration
  max_retries: z.number().int().nonnegative().default(3),
  retry_count: z.number().int().nonnegative().default(0),
  retry_delay_ms: z.number().int().positive().default(5000)
}).strict();

// Job Creation Request
export const CreateJobRequest = z.object({
  type: JobType,
  priority: JobPriority.optional(),
  estimated_duration_ms: z.number().int().positive().optional(),
  max_duration_ms: z.number().int().positive().optional(),
  cpu_cores: z.number().int().positive().optional(),
  memory_mb: z.number().int().positive().optional(),
  requires_gpu: z.boolean().optional(),
  metadata: Job.shape.metadata.optional(),
  depends_on: z.array(z.string().uuid()).optional(),
  max_retries: z.number().int().nonnegative().optional()
}).strict();

// Job Update Request
export const UpdateJobRequest = z.object({
  status: JobStatus.optional(),
  progress_percent: z.number().min(0).max(100).optional(),
  progress_message: z.string().optional(),
  result: z.record(z.any()).optional(),
  error_message: z.string().optional(),
  error_code: z.string().optional()
}).strict();

// Job Query Request
export const JobQueryRequest = z.object({
  type: JobType.optional(),
  status: JobStatus.optional(),
  owner: z.string().optional(),
  created_after: z.string().datetime().optional(),
  created_before: z.string().datetime().optional(),
  limit: z.number().int().positive().max(1000).default(50),
  offset: z.number().int().nonnegative().default(0)
}).strict();

// Job Response Schemas
export const JobResponse = z.object({
  success: z.literal(true),
  data: Job,
  requestId: z.string(),
  timestamp: z.string().datetime()
}).strict();

export const JobsListResponse = z.object({
  success: z.literal(true),
  data: z.object({
    jobs: z.array(Job),
    total: z.number().int().nonnegative(),
    limit: z.number().int().positive(),
    offset: z.number().int().nonnegative(),
    has_more: z.boolean()
  }).strict(),
  requestId: z.string(),
  timestamp: z.string().datetime()
}).strict();

// Job Logs Schema
export const JobLog = z.object({
  id: z.string().uuid(),
  job_id: z.string().uuid(),
  level: z.enum(['debug', 'info', 'warn', 'error']),
  message: z.string(),
  metadata: z.record(z.any()).optional(),
  timestamp: z.string().datetime()
}).strict();

export const JobLogsResponse = z.object({
  success: z.literal(true),
  data: z.object({
    logs: z.array(JobLog),
    job_id: z.string().uuid(),
    total: z.number().int().nonnegative()
  }).strict(),
  requestId: z.string(),
  timestamp: z.string().datetime()
}).strict();

// Type exports
export type JobTypeEnum = z.infer<typeof JobType>;
export type JobStatusEnum = z.infer<typeof JobStatus>;
export type JobSchema = z.infer<typeof Job>;
export type CreateJobRequestType = z.infer<typeof CreateJobRequest>;
export type UpdateJobRequestType = z.infer<typeof UpdateJobRequest>;
export type JobQueryRequestType = z.infer<typeof JobQueryRequest>;
export type JobResponseType = z.infer<typeof JobResponse>;
export type JobsListResponseType = z.infer<typeof JobsListResponse>;
export type JobLogType = z.infer<typeof JobLog>;
export type JobLogsResponseType = z.infer<typeof JobLogsResponse>;