using uniffi.strathweb_phi_engine;

// define inference options
var inferenceOptionsBuilder = new InferenceOptionsBuilder();
inferenceOptionsBuilder.WithTemperature(0.9);
inferenceOptionsBuilder.WithTokenCount(100);
var inferenceOptions = inferenceOptionsBuilder.Build();

// set up cache directory for the model
var cacheDir = Path.Combine(Directory.GetCurrentDirectory(), ".cache");

var modelBuilder = new PhiEngineBuilder();

// attach an optional event handler which will be called during inference
// this allows streaming tokens as they are generated
modelBuilder.WithEventHandler(new BoxedPhiEventHandler(new ModelEventsHandler()));

// build the model with a system instruction
var model = modelBuilder.BuildStateful(cacheDir, "You are a hockey poet");

// run inference
var result = model.RunInference("Write a haiku about ice hockey", inferenceOptions);

// inference result and stats are available in the result object
// however, when streaming was used, the result itself should not be needed
Console.WriteLine($"{Environment.NewLine}Tokens Generated: {result.tokenCount}{Environment.NewLine}Tokens per second: {result.tokensPerSecond}{Environment.NewLine}Duration: {result.duration}s");

class ModelEventsHandler : PhiEventHandler
{
    public void OnInferenceToken(string token)
    {
        Console.Write(token);
    }

    public void OnModelLoaded()
    {
        Console.WriteLine("Model loaded!");
    }
}

import Foundation

// define inference options
let inferenceOptionsBuilder = InferenceOptionsBuilder()
try! inferenceOptionsBuilder.withTemperature(temperature: 0.9)
try! inferenceOptionsBuilder.withSeed(seed: 146628346)
let inferenceOptions = try! inferenceOptionsBuilder.build()

// set up cache directory for the model
let cacheDir = FileManager.default.currentDirectoryPath.appending("/.cache")

let modelBuilder = PhiEngineBuilder()

// attach an optional event handler which will be called during inference
// this allows streaming tokens as they are generated
try! modelBuilder.withEventHandler(eventHandler: BoxedPhiEventHandler(handler: ModelEventsHandler()))

// try enabling GPU - Metal is supported on MacOS
let gpuEnabled = try! modelBuilder.tryUseGpu()

// build the model with a system instruction
let model = try! modelBuilder.buildStateful(cacheDir: cacheDir, systemInstruction: "You are a hockey poet")

// run inference
let result = try! model.runInference(promptText: "Write a haiku about ice hockey", inferenceOptions: inferenceOptions)

// inference result and stats are available in the result object
// however, when streaming was used, the result itself should not be needed
print("""

****************************************
 📝 Tokens Generated: \(result.tokenCount)
 🖥️ Tokens per second: \(result.tokensPerSecond)
 ⏱️ Duration: \(result.duration)s
 🏎️ GPU enabled: \(gpuEnabled)
""")

class ModelEventsHandler: PhiEventHandler {
    func onInferenceToken(token: String) {
        print(token, terminator: "")
    }

    func onModelLoaded() {
        print("""
 🧠 Model loaded!
****************************************
""")
    }
}

// define inference options
val inferenceOptionsBuilder = InferenceOptionsBuilder()
inferenceOptionsBuilder.withTemperature(0.9)
inferenceOptionsBuilder.withSeed(146628346.toULong())
val inferenceOptions = inferenceOptionsBuilder.build()

// set up cache directory for the model
val cacheDir = File(System.getProperty("user.dir"), ".cache").absolutePath

val modelBuilder = PhiEngineBuilder()

// attach an optional event handler which will be called during inference
// this allows streaming tokens as they are generated
modelBuilder.withEventHandler(BoxedPhiEventHandler(ModelEventsHandler()))
val gpuEnabled = modelBuilder.tryUseGpu()

// build the model with a system instruction
val model = modelBuilder.buildStateful(cacheDir, "You are a hockey poet")

// run inference
val result = model.runInference("Write a haiku about ice hockey", inferenceOptions)

// inference result and stats are available in the result object
// however, when streaming was used, the result itself should not be needed
println(
    """
    
    ****************************************
    📝 Tokens Generated: ${result.tokenCount}
    🖥️ Tokens per second: ${result.tokensPerSecond}
    ⏱️ Duration: ${result.duration}s
    🏎️ GPU enabled: $gpuEnabled
    """.trimIndent()
)

class ModelEventsHandler : PhiEventHandler {
    override fun onInferenceToken(token: String) {
        print(token)
    }

    override fun onModelLoaded() {
        println(
            """
            🧠 Model loaded!
            ****************************************
            """.trimIndent()
        )
    }
}

let engineBuilder = PhiEngineBuilder()
engineBuilder.withModelProvider(modelProvider: 
    PhiModelProvider.huggingFace(
        modelRepo: "...repo...", 
        modelFileName: "...model name...", 
        modelRevision: "...revision..."))

// or

let engineBuilder = PhiEngineBuilder()
engineBuilder.withModelProvider(modelProvider: 
    PhiModelProvider.fileSystem(
        modelPath: "...path to GGUF..."))