Inputs

// One workflow definition
let task = ORTask(
    description: "Analyze {company} stock performance in {year}",
    expectedOutput: "Analysis report"
)

// Multiple executions with different inputs
let inputs1 = OrbitInput(Metadata([
    "company": .string("Apple"),
    "year": .int(2024)
]))

let inputs2 = OrbitInput(Metadata([
    "company": .string("Microsoft"),
    "year": .int(2023)
]))

let task = ORTask(
    description: """
    Generate report with {detail_level} detail.
    Include {sections} sections.
    Format: {output_format}
    """,
    expectedOutput: "Report"
)

// Different configurations
let detailedConfig = OrbitInput(Metadata([
    "detail_level": .string("comprehensive"),
    "sections": .int(10),
    "output_format": .string("PDF")
]))

let summaryConfig = OrbitInput(Metadata([
    "detail_level": .string("summary"),
    "sections": .int(3),
    "output_format": .string("markdown")
]))

// Compile-time type safety
let inputs = OrbitInput(Metadata([
    "count": .int(100),           // Integer
    "threshold": .double(0.85),   // Double
    "enabled": .bool(true),       // Boolean
    "name": .string("Analysis")   // String
]))

// Type mismatches caught early

let inputs = OrbitInput(Metadata([
    "config": .dictionary([
        "api": .dictionary([
            "endpoint": .string("https://api.example.com"),
            "timeout": .int(30),
            "retries": .int(3)
        ]),
        "features": .array([
            .string("analytics"),
            .string("reporting"),
            .string("alerts")
        ])
    ])
]))

// Define task with placeholders
let task = ORTask(
    description: """
    Write a {length}-word article about {topic}.
    Audience: {audience}
    Tone: {tone}
    """,
    expectedOutput: "Article"
)

// Provide inputs
let inputs = OrbitInput(Metadata([
    "length": .int(1500),
    "topic": .string("AI in healthcare"),
    "audience": .string("medical professionals"),
    "tone": .string("professional and informative")
]))

// Interpolated result:
// "Write a 1500-word article about AI in healthcare.
//  Audience: medical professionals
//  Tone: professional and informative"

// Define complex input structure
struct AnalysisConfig: Codable {
    let company: String
    let metrics: [String]
    let timeframe: TimeFrame
    let thresholds: Thresholds

    struct TimeFrame: Codable {
        let start: String
        let end: String
    }

    struct Thresholds: Codable {
        let minConfidence: Double
        let maxRisk: Double
    }
}

let config = AnalysisConfig(
    company: "TechCorp",
    metrics: ["revenue", "growth", "profit"],
    timeframe: .init(start: "2024-01-01", end: "2024-12-31"),
    thresholds: .init(minConfidence: 0.85, maxRisk: 0.3)
)

let inputs = try OrbitInput(from: config)

// Use in task
let task = ORTask(
    description: """
    Analyze {company} performance:
    - Metrics: {metrics}
    - Period: {timeframe.start} to {timeframe.end}
    - Min confidence: {thresholds.minConfidence}
    - Max risk: {thresholds.maxRisk}
    """,
    expectedOutput: "Analysis"
)

let inputs = OrbitInput(Metadata([
    "includeCharts": .bool(true),
    "includeData": .bool(false),
    "format": .string("PDF")
]))

let task = ORTask(
    description: """
    Generate report in {format} format.
    {if includeCharts}Include visual charts and graphs.{endif}
    {if includeData}Include raw data tables.{endif}
    {if format=PDF}Ensure proper pagination.{endif}
    """,
    expectedOutput: "Report"
)

// Interpolated result:
// "Generate report in PDF format.
//  Include visual charts and graphs.
//  Ensure proper pagination."

// Define typed input structure
struct AnalysisInputs: Codable {
    let company: String
    let year: Int
    let metrics: [String]
    let thresholds: Thresholds

    struct Thresholds: Codable {
        let minConfidence: Double
        let maxRisk: Double
    }
}

// Create and validate at compile-time
let inputs = AnalysisInputs(
    company: "TechCorp",
    year: 2024,
    metrics: ["revenue", "growth"],
    thresholds: .init(minConfidence: 0.85, maxRisk: 0.3)
)

// Convert to OrbitInput
let orbitInputs = try OrbitInput(from: inputs)

// Type errors caught by compiler
// let badInputs = AnalysisInputs(
//     company: 123,  // Error: Cannot convert Int to String
//     year: "2024"   // Error: Cannot convert String to Int
// )

// Validate types at runtime
func validateInputTypes(
    inputs: OrbitInput,
    schema: [String: MetadataType]
) throws {
    for (key, expectedType) in schema {
        guard let value = inputs.metadata[key] else {
            continue  // Missing handled separately
        }

        let actualType = value.type
        if actualType != expectedType {
            throw OrbitAIError.invalidInput(
                "Input '\(key)' expected type \(expectedType), " +
                "got \(actualType)"
            )
        }
    }
}

enum MetadataType {
    case string, int, double, bool, array, dictionary
}

// Usage
let schema: [String: MetadataType] = [
    "company": .string,
    "year": .int,
    "threshold": .double,
    "enabled": .bool,
    "metrics": .array
]

try validateInputTypes(inputs: inputs, schema: schema)

// Check exact key match
let task = ORTask(
    description: "Analyze {Company}",  // Capital C
    expectedOutput: "Report"
)

let inputs = OrbitInput(Metadata([
    "company": .string("TechCorp")  // Lowercase c - won't match!
]))

// Fix: Match case exactly
let inputs = OrbitInput(Metadata([
    "Company": .string("TechCorp")  // Now matches
]))

// Or fix task
let task = ORTask(
    description: "Analyze {company}",  // Lowercase to match
    expectedOutput: "Report"
)

// 1. Print available keys
print("Available keys:", inputs.metadata.keys)

// 2. Extract placeholders from task
let placeholders = extractPlaceholders(task.description)
print("Required placeholders:", placeholders)

// 3. Check for missing
for placeholder in placeholders {
    if inputs.metadata[placeholder] == nil {
        print("Missing: \(placeholder)")
    }
}

// Define structure
let inputs = OrbitInput(Metadata([
    "config": .dictionary([
        "api": .dictionary([
            "endpoint": .string("https://api.example.com"),
            "version": .string("v2")
        ])
    ])
]))

// Wrong: Missing level
// {config.endpoint} ❌

// Correct: Full path
// {config.api.endpoint} ✅

// Debug nested structure
func printStructure(_ metadata: Metadata, indent: Int = 0) {
    let spacing = String(repeating: "  ", count: indent)

    switch metadata {
    case .dictionary(let dict):
        for (key, value) in dict {
            print("\(spacing)\(key):")
            printStructure(value, indent: indent + 1)
        }
    default:
        print("\(spacing)\(metadata)")
    }
}

// Print to see structure
printStructure(inputs.metadata)
// Output:
// config:
//   api:
//     endpoint:
//       https://api.example.com
//     version:
//       v2

let inputs = OrbitInput(Metadata([
    "items": .array([
        .string("first"),
        .string("second")
    ])
]))

// Check array size first
if let array = inputs.metadata["items"]?.arrayValue {
    print("Array size: \(array.count)")  // 2 (indices 0, 1)

    // Safe access
    if array.count > 2 {
        // {items[2]} would be safe
    } else {
        // Use default or adjust
    }
}

// Use conditional access
let task = ORTask(
    description: """
    Primary: {items[0]}
    {if items[1]}Secondary: {items[1]}{endif}
    {if items[2]}Tertiary: {items[2]}{endif}
    """,
    expectedOutput: "List"
)

// Control number formatting
let inputs = OrbitInput(Metadata([
    "price": .double(1234.56)
]))

// In task
let task = ORTask(
    description: "Price: ${price}",
    expectedOutput: "Info"
)
// Result: "Price: $1234.56"

// For custom formatting, pre-format
let formattedInputs = OrbitInput(Metadata([
    "price": .string("$1,234.56")  // Pre-formatted
]))

// Arrays convert to comma-separated
let arrayInputs = OrbitInput(Metadata([
    "tags": .array([
        .string("ai"),
        .string("ml"),
        .string("data")
    ])
]))

// In task: {tags}
// Result: "ai, ml, data"

// For custom format, pre-join
let tags = ["ai", "ml", "data"]
let customFormat = tags.joined(separator: " | ")
let formattedInputs = OrbitInput(Metadata([
    "tags": .string(customFormat)
]))
// Result: "ai | ml | data"

// Create input validator
struct InputValidator {
    let requiredKeys: [String]
    let optionalKeys: [String]

    func validate(_ inputs: OrbitInput) throws {
        for key in requiredKeys {
            guard inputs.metadata[key] != nil else {
                throw OrbitAIError.missingInput(
                    "Required input '\(key)' not provided"
                )
            }
        }
    }

    func printMissing(_ inputs: OrbitInput) {
        let missing = requiredKeys.filter {
            inputs.metadata[$0] == nil
        }

        if !missing.isEmpty {
            print("Missing required inputs:")
            for key in missing {
                print("  - \(key)")
            }
        }
    }
}

// Usage
let validator = InputValidator(
    requiredKeys: ["company", "year", "metrics"],
    optionalKeys: ["format", "detail"]
)

// Validate before execution
do {
    try validator.validate(inputs)
    let result = try await orbit.start(inputs: inputs)
} catch {
    validator.printMissing(inputs)
    // Missing required inputs:
    //   - company
    //   - metrics
}

// Cache interpolation results
actor InterpolationCache {
    private var cache: [String: String] = [:]

    func get(_ key: String) -> String? {
        return cache[key]
    }

    func set(_ key: String, value: String) {
        cache[key] = value
    }

    func clear() {
        cache.removeAll()
    }
}

// Use cache for repeated interpolations
let cache = InterpolationCache()

func interpolateWithCache(
    template: String,
    inputs: OrbitInput,
    cache: InterpolationCache
) async throws -> String {
    // Check cache
    if let cached = await cache.get(template) {
        return cached
    }

    // Interpolate
    let result = try interpolate(template, inputs: inputs)

    // Cache result
    await cache.set(template, value: result)

    return result
}

// Or pre-interpolate static parts
// Only interpolate dynamic sections