using AiDotNet;

// Build and train a model in one fluent chain
var result = await new AiModelBuilder<double, double[], double>()
    .ConfigureModel(new NeuralNetwork<double>(inputSize: 4, hiddenSize: 16, outputSize: 3))
    .ConfigureOptimizer(new AdamOptimizer<double>())
    .ConfigurePreprocessing()  // Auto-applies StandardScaler + Imputer
    .BuildAsync(features, labels);

// Make predictions using the facade pattern
var prediction = result.Predict(newSample);

var model = new AiModelBuilder<double, Tensor<double>, Tensor<double>>()
    .ConfigureModel(new ConvolutionalNeuralNetwork<double>(
        inputChannels: 3,
        numClasses: 1000,
        architecture: CNNArchitecture.ResNet50))
    .ConfigureOptimizer(new AdamWOptimizer<double>(learningRate: 0.001))
    .ConfigureMixedPrecision()  // FP16 training
    .ConfigureGpuAcceleration()
    .BuildAsync(trainImages, trainLabels);

var result = await new AiModelBuilder<double, double[], double>()
    .ConfigureModel(new RandomForestClassifier<double>(nEstimators: 100))
    .ConfigurePreprocessing(pipeline => pipeline
        .Add(new StandardScaler<double>())
        .Add(new SimpleImputer<double>()))
    .ConfigureCrossValidation(new KFoldCrossValidator<double>(k: 5))
    .BuildAsync(features, labels);

Console.WriteLine($"Accuracy: {result.CrossValidationResult?.MeanAccuracy:P2}");

var result = await new AiModelBuilder<double, double[], double>()
    .ConfigureModel(new GradientBoostingRegression<double>(
        nEstimators: 200,
        maxDepth: 5,
        learningRate: 0.1))
    .ConfigureHyperparameterOptimizer(
        new BayesianOptimizer<double>(),
        searchSpace: new HyperparameterSearchSpace()
            .AddContinuous("learning_rate", 0.01, 0.3)
            .AddInteger("max_depth", 3, 10),
        trials: 50)
    .BuildAsync(features, targets);

var result = await new AiModelBuilder<double, double[], int>()
    .ConfigureModel(new HDBSCAN<double>(minClusterSize: 15, minSamples: 5))
    .ConfigureAutoML(new ClusteringAutoML<double>())  // Auto-tune parameters
    .BuildAsync(features);

Console.WriteLine($"Clusters found: {result.Model.Labels.Distinct().Count()}");
Console.WriteLine($"Silhouette Score: {result.ClusteringMetrics?.SilhouetteScore:F3}");

var builder = new AiModelBuilder<float, Tensor<float>, DetectionResult[]>()
    .ConfigureObjectDetector(new YOLOv8Detector<float>(
        modelSize: YOLOModelSize.Medium,
        confidenceThreshold: 0.5f))
    .ConfigureVisualization(new VisualizationOptions { DrawLabels = true });

var result = await builder.BuildAsync();
var detections = result.Model.Detect(image);

foreach (var det in detections)
    Console.WriteLine($"{det.Label}: {det.Confidence:P1} at {det.BoundingBox}");

// Speech-to-Text with Whisper
var whisper = new WhisperModel<float>(WhisperModelSize.Medium, language: "en");
var transcription = await whisper.TranscribeAsync(audioFile);
Console.WriteLine(transcription.Text);

// Text-to-Speech
var tts = new VITSModel<float>(voice: "en-US-female");
var audio = await tts.SynthesizeAsync("Hello, world!");
await audio.SaveAsync("output.wav");

var videoGen = new StableVideoDiffusion<float>();
var video = await videoGen.GenerateAsync(
    prompt: "A cat playing piano",
    numFrames: 24,
    fps: 8);
await video.SaveAsync("output.mp4");

var env = new CartPoleEnvironment();
var agent = new PPOAgent<double>(
    stateSize: env.ObservationSpace,
    actionSize: env.ActionSpace,
    hiddenSize: 64,
    learningRate: 3e-4);

// Training loop
for (int episode = 0; episode < 1000; episode++)
{
    var state = env.Reset();
    double totalReward = 0;

    while (!env.IsDone)
    {
        var action = agent.SelectAction(state);
        var (nextState, reward, done) = env.Step(action);
        agent.Store(state, action, reward, nextState, done);
        state = nextState;
        totalReward += reward;
    }

    agent.Train();
    Console.WriteLine($"Episode {episode}: Reward = {totalReward}");
}

var result = await new AiModelBuilder<double, double[], double>()
    .ConfigureModel(new NBEATSModel<double>(
        stackTypes: new[] { StackType.Trend, StackType.Seasonality, StackType.Generic },
        horizonSize: 24))
    .ConfigureTrainingPipeline(new TrainingPipelineConfiguration<double>
    {
        EarlyStopping = new EarlyStoppingConfig { Patience = 10 }
    })
    .BuildAsync(historicalData);

var forecast = result.Model.Forecast(steps: 24);

var result = await new AiModelBuilder<float, string, string>()
    .ConfigureRetrievalAugmentedGeneration(
        retriever: new HybridRetriever<float>(
            denseRetriever: new DenseRetriever<float>(embeddingModel),
            sparseRetriever: new BM25Retriever(),
            alpha: 0.7f),
        reranker: new CrossEncoderReranker<float>(),
        generator: new LLMGenerator<float>(llmClient),
        queryProcessors: new[] { new QueryExpander() })
    .BuildAsync();

var answer = await result.Model.QueryAsync("What is the capital of France?", documents);

var result = await new AiModelBuilder<float, string, string>()
    .ConfigureLoRA(new QLoRAConfiguration<float>
    {
        Rank = 16,
        Alpha = 32,
        TargetModules = new[] { "q_proj", "v_proj", "k_proj", "o_proj" },
        QuantizationBits = 4,
        UseDoubleQuantization = true
    })
    .ConfigureFineTuning(new FineTuningConfiguration<float>
    {
        BaseModel = "meta-llama/Llama-2-7b-hf",
        TrainingArguments = new TrainingArguments
        {
            NumEpochs = 3,
            BatchSize = 4,
            GradientAccumulationSteps = 8
        }
    })
    .BuildAsync(trainingData);

var diffusion = new SDXLModel<float>();
var image = await diffusion.GenerateAsync(
    prompt: "A photorealistic cat astronaut on Mars",
    negativePrompt: "blurry, low quality",
    width: 1024,
    height: 1024,
    numInferenceSteps: 30,
    guidanceScale: 7.5f);

await image.SaveAsync("output.png");

var result = await new AiModelBuilder<float, Tensor<float>, Tensor<float>>()
    .ConfigureModel(largeModel)
    .ConfigureDistributedTraining(
        strategy: DistributedStrategy.FSDP,
        backend: new NCCLCommunicationBackend(),
        configuration: new FSDPConfiguration
        {
            ShardingStrategy = ShardingStrategy.FullShard,
            MixedPrecision = true,
            ActivationCheckpointing = true
        })
    .ConfigureGpuAcceleration(new GpuAccelerationConfig { DeviceIds = new[] { 0, 1, 2, 3 } })
    .BuildAsync(trainData);

var result = await new AiModelBuilder<float, Tensor<float>, Tensor<float>>()
    .ConfigureMetaLearning(new MAMLAlgorithm<float>(
        innerLearningRate: 0.01f,
        outerLearningRate: 0.001f,
        innerSteps: 5))
    .BuildAsync(metaTrainTasks);

// Few-shot learning on new task
var adapted = result.MetaLearner.Adapt(supportSet, numSteps: 10);
var predictions = adapted.Predict(querySet);