// 🔥 This code automatically scales from 1 to 40 threads based on environment
var context = VortexContext.ForProduction("enterprise-corp", VortexScale.Auto);
var result = await orderProcessor.ExecuteAsync(context, orderData);

// 💡 Same code, different behavior:
// Development → 1 thread, debug logging
// Production → 40 threads, distributed processing
// Testing → Predictable, sequential execution

using VortexProgramming.Core.Context;
using VortexProgramming.Extensions.FluentApi;

// 🎯 Create context-aware execution environment
var context = VortexContext.ForProduction("my-company");
// Automatically configures: 40 threads, monitoring enabled, resilience patterns

// 🔗 Build composable process chain without classes
var builder = new VortexBuilder();
var dataProcessor = builder.CreateChain("ETL-Pipeline")
    .AddTransform<string, string>(data => data.Trim(), "CleanData")
    .AddTransform<string, DataRecord>(data => ParseData(data), "ParseData")  
    .AddTransform<DataRecord, DataRecord>(record => ValidateData(record), "ValidateData");

// 🚀 Execute with automatic scaling
var results = await dataProcessor.ExecuteAsync<string, DataRecord>(context, rawData);

// 📊 Results: 
// - Development: Sequential execution, debug logs
// - Production: 40 parallel threads, monitoring events
// - Testing: Predictable, repeatable execution

using VortexProgramming.Core.Context;
using VortexProgramming.Core.Processing;

public class IntelligentOrderProcessor : VortexProcess<Order, OrderResult>
{
    public override string ProcessName => "IntelligentOrderProcessor";

    protected override async Task<OrderResult> ExecuteInternalAsync(Order order, CancellationToken cancellationToken)
    {
        // 🧠 Framework automatically chooses execution strategy:
        // Small scale: Sequential processing
        // Large scale: Parallel + distributed processing
        
        await ProcessItemsAsync(order.Items, async (item, ct) =>
        {
            await ProcessOrderItem(item, ct);
        }, cancellationToken);

        return new OrderResult { Status = "Processed", ItemCount = ItemsProcessed };
    }
}

// 🎯 Usage - same code, different behavior per environment
var devContext = VortexContext.ForDevelopment("my-tenant");     // 1 thread, debug mode
var prodContext = VortexContext.ForProduction("my-tenant");     // 40 threads, monitoring

var processor = new IntelligentOrderProcessor();
var result = await processor.ExecuteAsync(prodContext, order);  // Automatically scales!

// 🎯 Automatically configures based on environment
var context = VortexContext.ForProduction("enterprise-tenant", VortexScale.Auto);

Console.WriteLine($"Threads: {context.GetRecommendedParallelism()}");        // 40
Console.WriteLine($"Distributed: {context.ShouldUseDistributedExecution()}"); // true
Console.WriteLine($"Monitoring: {context.GetProperty<bool>("monitoring.enabled")}"); // true

var etlPipeline = builder.CreateChain("DataPipeline")
    .AddStep(extractProcess)
    .AddStep(transformProcess)  
    .AddStep(validateProcess)
    .AddStep(loadProcess);

// 📊 Real results from our demo:
// ✅ 3,500 records processed in 3.35 seconds
// ✅ 4-stage pipeline with automatic batching
// ✅ Context-aware scaling per stage

var orderProcessor = new HandleOrderProcess();
var context = VortexContext.ForProduction("enterprise-corp", VortexScale.Large);

var order = new OrderRequest
{
    OrderId = "ORD-2024-001", 
    CustomerId = "CUST-12345",
    Items = new[] { 
        new OrderItem { ProductId = "PROD-001", Quantity = 2, Price = 29.99m }
    }
};

// 🚀 Executes: Validate → Inventory → Payment → Reserve → Ship
var result = await orderProcessor.ExecuteAsync(context, order);

// 📊 Results:
// ✅ Order confirmed in 1.1 seconds
// ✅ 5 parallel processing steps  
// ✅ Full transaction and shipment tracking

var pipeline = new DataPipelineProcess();
var context = VortexContext.ForProduction("data-corp", VortexScale.Large);

var pipelineInput = new DataPipelineInput
{
    PipelineId = "PIPE-2024-001",
    DataSources = new[] {
        new DataSource { Type = "database", RecordCount = 1000 },
        new DataSource { Type = "api", RecordCount = 500 },
        new DataSource { Type = "file", RecordCount = 2000 }
    },
    TargetSystem = "warehouse"
};

// 🚀 Executes: Extract → Transform → Validate → Load
var result = await pipeline.ExecuteAsync(context, pipelineInput);

// 📊 Results:
// ✅ 3,500 records processed in 3.35 seconds
// ✅ Automatic batching: 10/50/100 based on scale
// ✅ Zero data loss with validation errors captured

// 🔥 Create complex processes without writing classes
var statisticsProcessor = builder.CreateProcess<List<int>, Dictionary<string, object>>("StatsCalculator")
    .WithMetadata("version", "1.0")
    .WithMetadata("author", "Data Team")
    .When(numbers => numbers.Count > 0)  // Conditional execution
    .Initialize(async (ctx, ct) => {
        Console.WriteLine("🔧 Initializing statistics calculation...");
        await Task.Delay(100, ct);
    })
    .Execute(async (numbers, ct) => {
        return new Dictionary<string, object>
        {
            ["count"] = numbers.Count,
            ["sum"] = numbers.Sum(), 
            ["average"] = numbers.Average(),
            ["variance"] = CalculateVariance(numbers)
        };
    })
    .Build();

var numbers = Enumerable.Range(1, 100).ToList();
var stats = await statisticsProcessor.ExecuteAsync(context, numbers);
// 📊 Results: count=100, sum=5050, avg=50.5, variance=833.25

// 🎯 Define processes using JSON
var processJson = """
{
    "Name": "TextProcessor",
    "Type": "transform", 
    "Parameters": { "transformType": "uppercase" },
    "Conditions": [
        { "Type": "environment", "Parameters": { "environment": "Development" } }
    ]
}
""";

var dslProcess = VortexDsl.FromJson(processJson);
var result = await dslProcess.ExecuteAsync(context, "hello world");
// Result: "HELLO WORLD"

// 🔔 Subscribe to real-time events
context.EventStream.Subscribe(evt => 
{
    switch (evt)
    {
        case ProcessStartedEvent started:
            Console.WriteLine($"🚀 {started.ProcessName} started at {started.Scale} scale");
            break;
        case ProcessCompletedEvent completed:
            Console.WriteLine($"✅ Completed in {completed.Duration.TotalMilliseconds}ms");
            Console.WriteLine($"📊 Processed {completed.ItemsProcessed} items");
            break;
        case ProcessFailedEvent failed:
            Console.WriteLine($"❌ Failed: {failed.ErrorMessage}");
            break;
    }
});

var enterpriseContext = VortexContext.ForProduction("enterprise-tenant")
    .SetProperty("feature.advancedAnalytics", true)
    .SetProperty("limits.maxConcurrency", 100);

var startupContext = VortexContext.ForProduction("startup-tenant")
    .SetProperty("feature.advancedAnalytics", false) 
    .SetProperty("limits.maxConcurrency", 20);

context.EventStream
    .OfType<ProcessCompletedEvent>()
    .Subscribe(evt => {
        metrics.RecordDuration(evt.ProcessName, evt.Duration);
        metrics.RecordThroughput(evt.ProcessName, evt.ItemsProcessed);
    });

// ✅ Let the framework choose optimal execution
var context = VortexContext.ForProduction("my-tenant", VortexScale.Auto);

// ✅ Compose complex workflows from simple processes
var workflow = builder.CreateChain("OrderWorkflow")
    .AddStep(validateProcess)
    .AddStep(inventoryProcess)
    .AddStep(paymentProcess);

// ✅ Monitor everything with reactive streams
context.EventStream.Subscribe(evt => telemetry.Track(evt));

// ❌ Don't write environment-specific code
if (Environment.GetEnvironmentVariable("ENV") == "PROD") 
{
    // Manual scaling logic - let Vortex handle this!
}