// settings.gradle.kts
dependencyResolutionManagement {
    repositoriesMode.set(RepositoriesMode.FAIL_ON_PROJECT_REPOS)
    repositories {
        mavenCentral()
        maven { url = uri("https://jitpack.io") }
    }
}

// build.gradle.kts
dependencies {
    implementation("com.github.no-ai-labs.spice-framework:spice-core:Tag")
    
    // Optional modules
    implementation("com.github.no-ai-labs.spice-framework:spice-springboot:Tag")
    implementation("com.github.no-ai-labs.spice-framework:spice-eventsourcing:Tag")
}

import io.github.spice.*
import io.github.spice.dsl.*
import kotlinx.coroutines.runBlocking

fun main() = runBlocking {
    // Create a simple agent
    val assistant = buildAgent {
        id = "assistant-1"
        name = "AI Assistant"
        description = "A helpful AI assistant"
        
        // Add an inline tool
        tool("greet") {
            description = "Greet someone"
            parameter("name", "string", "Person's name")
            execute { params ->
                "Hello, ${params["name"]}! How can I help you today?"
            }
        }
        
        // Define message handling
        handle { comm ->
            when {
                comm.content.startsWith("greet ") -> {
                    val name = comm.content.removePrefix("greet ").trim()
                    val result = run("greet", mapOf("name" to name))
                    comm.reply(result.result.toString(), id)
                }
                else -> comm.reply("Say 'greet NAME' to get a greeting!", id)
            }
        }
    }
    
    // Use the agent
    val response = assistant.processComm(
        Comm(content = "greet Alice", from = "user")
    )
    println(response.content) // "Hello, Alice! How can I help you today?"
}

// OpenAI Integration
val gptAgent = buildOpenAIAgent {
    id = "gpt-4"
    name = "GPT-4 Assistant"
    apiKey = System.getenv("OPENAI_API_KEY")
    model = "gpt-4"
    systemPrompt = "You are a helpful coding assistant."
}

// Anthropic Integration
val claudeAgent = buildClaudeAgent {
    id = "claude-3"
    name = "Claude Assistant"
    apiKey = System.getenv("ANTHROPIC_API_KEY")
    model = "claude-3-opus-20240229"
}

// Use them just like any other agent
val response = gptAgent.processComm(
    Comm(content = "Explain coroutines in Kotlin", from = "user")
)

import io.github.noailabs.spice.swarm.*

// Create a swarm with AI coordinator
val llmCoordinator = buildAgent {
    name = "GPT-4 Coordinator"
    // Configure your GPT-4 or Claude agent
}

val aiSwarm = buildSwarmAgent {
    name = "AI Research Swarm"
    description = "Multi-agent research and analysis"

    // Use AI for intelligent coordination
    aiCoordinator(llmCoordinator)

    // Add member agents
    quickSwarm {
        researchAgent("researcher", "Lead Researcher")
        analysisAgent("analyst", "Data Analyst")
        specialist("expert", "Domain Expert", "Expert analysis")
    }

    config {
        debug(true)
        timeout(60000)
    }
}

// Execute with automatic strategy selection
val result = aiSwarm.processComm(Comm(
    content = "Analyze the impact of AI on healthcare",
    from = "user",
    type = CommType.TEXT
))

// Or use pre-configured swarms
val research = researchSwarm(name = "Research Team")
val creative = creativeSwarm(name = "Creative Team")
val decision = decisionSwarm(name = "Decision Team")

import io.github.noailabs.spice.observability.*

// Initialize observability at startup
ObservabilityConfig.initialize(
    ObservabilityConfig.Config(
        serviceName = "my-ai-app",
        serviceVersion = "1.0.0",
        otlpEndpoint = "http://localhost:4317",
        enableTracing = true,
        enableMetrics = true
    )
)

// Add tracing to any agent
val tracedAgent = buildAgent {
    name = "Research Agent"
    handle { comm ->
        // Your agent logic
        SpiceResult.success(comm.reply("Result", id))
    }
}.traced()  // Add tracing with one line!

// Create observable swarm
val observableSwarm = buildSwarmAgent {
    name = "Observable Swarm"

    quickSwarm {
        val agent1 = buildAgent { ... }.traced()
        val agent2 = buildAgent { ... }.traced()
        addAgent("agent1", agent1)
        addAgent("agent2", agent2)
    }
}

// View complete traces in Jaeger
// Track metrics in Grafana
// Monitor LLM costs in real-time

import io.github.noailabs.spice.context.*

// Set context once at HTTP boundary
suspend fun handleRequest(request: HttpRequest) {
    withAgentContext(
        "tenantId" to request.tenantId,
        "userId" to request.userId,
        "correlationId" to UUID.randomUUID().toString()
    ) {
        // ✅ Context flows automatically through ALL operations!
        agent.processComm(request.toComm())
    }
}

// Create context-aware tools
val agent = buildAgent {
    id = "order-agent"
    val orderService = OrderService()  // Context-aware service

    contextAwareTool("create_order") {
        description = "Create new order"
        param("items", "array", "Order items")

        execute { params, context ->
            // ✅ Context automatically injected!
            val tenantId = context.tenantId!!
            val userId = context.userId!!

            // Service call automatically scoped to tenant!
            orderService.createOrder(params["items"] as List<*>)
        }
    }
}

// Context-aware services
class OrderRepository : BaseContextAwareService() {

    // Automatic tenant scoping - no manual parameters!
    suspend fun findOrders() = withTenant { tenantId ->
        database.query("WHERE tenant_id = ?", tenantId)
    }

    // Automatic tenant + user scoping
    suspend fun createOrder(items: List<String>) = withTenantAndUser { tenantId, userId ->
        Order(
            tenantId = tenantId,   // ✅ From context
            userId = userId,       // ✅ From context
            items = items
        )
    }
}

// Result: -20 lines of boilerplate per operation! 🚀

// Create specialized agents
val researcher = buildAgent {
    id = "researcher"
    name = "Research Agent"
    // ... configuration
}

val analyzer = buildAgent {
    id = "analyzer"
    name = "Analysis Agent"
    // ... configuration
}

// Register them
AgentRegistry.register(researcher)
AgentRegistry.register(analyzer)

// Create a workflow
val researchFlow = buildFlow {
    id = "research-flow"
    name = "Research and Analyze"

    step("research", "researcher")
    step("analyze", "analyzer") { comm ->
        // Only analyze if research found something
        comm.content.isNotEmpty()
    }
}

val ragAgent = buildAgent {
    id = "rag-agent"
    name = "RAG Assistant"
    
    // Configure vector store
    vectorStore("knowledge") {
        provider("qdrant")
        connection("localhost", 6333)
        collection("documents")
    }
    
    handle { comm ->
        // Automatic vector search tool available
        val results = run("search-knowledge", mapOf(
            "query" to comm.content,
            "topK" to 5
        ))
        // Process results...
    }
}

import io.github.noailabs.spice.serialization.SpiceSerializer.toJson
import io.github.noailabs.spice.serialization.SpiceSerializer.toJsonSchema

// Serialize any component to JSON
val agentJson = myAgent.toJson()
val toolJson = myTool.toJson()
val vectorStoreJson = myVectorStore.toJson()

// Export tool as JSON Schema
val schema = myAgentTool.toJsonSchema()

// Handle complex metadata properly
val metadata = mapOf(
    "tags" to listOf("ai", "agent"),
    "config" to mapOf("timeout" to 30, "retries" to 3)
)
// Preserves structure instead of toString()!
val jsonMetadata = SpiceSerializer.toJsonMetadata(metadata)

import io.github.noailabs.spice.tenant.*

// Set tenant context
TenantContext.set("tenant-123", mapOf("tier" to "premium"))

// Use tenant-aware runtime
val runtime = TenantAwareAgentRuntime(
    context = agentContext { 
        this["locale"] = "en-US"
    },
    tenantId = "tenant-123"
)

// Create tenant-aware agent
class MyTenantAgent : TenantAwareAgent(
    id = "my-agent",
    name = "Multi-Tenant Agent"
) {
    override suspend fun processCommInternal(comm: Comm): Comm {
        val tenantId = requireTenantId() // Automatically gets current tenant
        // Process with tenant isolation
        return comm.reply("Processing for tenant: $tenantId", id)
    }
}

// Tenant context propagates across coroutines
coroutineScope {
    launch(coroutineContext.withTenant("tenant-456")) {
        // This coroutine sees tenant-456
        val agent = agentRegistry.get("my-agent")
        agent.processComm(comm) // Processes in tenant-456 context
    }
}

import io.github.noailabs.spice.platform.*

// Create platform manager
val platformManager = DefaultPlatformManager()

// Register a platform
platformManager.registerPlatform(
    PlatformInfo(
        id = "shopify",
        name = "Shopify",
        type = PlatformType.MARKETPLACE,
        capabilities = setOf("orders", "inventory", "customers"),
        metadata = mapOf("apiVersion" to "2024-01")
    )
)

// Tenant-specific platform configuration
val tenantPlatformManager = DefaultTenantPlatformManager(platformManager)

tenantPlatformManager.registerPlatformForTenant(
    tenantId = "tenant-123",
    platformId = "shopify",
    config = PlatformConfig(
        platformId = "shopify",
        credentials = mapOf("apiKey" to "xxx", "apiSecret" to "yyy"),
        endpoints = mapOf("base" to "https://mystore.myshopify.com"),
        rateLimits = RateLimitConfig(
            requestsPerMinute = 40,
            burstSize = 10
        )
    )
)

// Check platform health
val health = platformManager.checkPlatformHealth("shopify")
println("Platform status: ${health.status}")

import io.github.noailabs.spice.policy.*
import kotlinx.serialization.json.*

// Create policy manager
val policyManager = DefaultPolicyManager()

// Save a policy with version tracking
val v1 = policyManager.savePolicy(
    policyId = "refund-policy",
    content = buildJsonObject {
        put("maxRefundDays", 30)
        put("autoApprove", true)
        put("maxAmount", 1000)
    },
    createdBy = "admin",
    comment = "Initial refund policy"
)

// Update policy (creates v2)
val v2 = policyManager.savePolicy(
    policyId = "refund-policy",
    content = buildJsonObject {
        put("maxRefundDays", 60)  // Changed
        put("autoApprove", false) // Changed
        put("maxAmount", 1000)
    },
    createdBy = "admin",
    comment = "Extended refund period, manual approval required"
)

// View history
val history = policyManager.getPolicyHistory("refund-policy")
history.forEach { entry ->
    println("v${entry.version}: ${entry.comment} by ${entry.createdBy}")
}

// Rollback to v1
val v3 = policyManager.rollbackPolicy(
    policyId = "refund-policy",
    targetVersion = 1,
    rolledBackBy = "admin",
    comment = "Reverting to original policy"
)

import io.github.noailabs.spice.eventsourcing.*
import javax.sql.DataSource

// Create event store with Kafka and PostgreSQL
val eventStore = EventStoreFactory.kafkaWithPostgres(
    kafkaCommHub = kafkaCommHub,
    dataSource = dataSource,
    config = EventStoreConfig(
        topicPrefix = "events",
        snapshotFrequency = 100
    )
)

// Or use in-memory for testing
val testEventStore = EventStoreFactory.inMemory(dataSource)

// Or use custom event publisher (e.g., RabbitMQ)
val customEventStore = EventStoreFactory.withCustomPublisher(
    dataSource = dataSource,
    eventPublisher = MyRabbitMQEventPublisher()
)

// Define domain events
class OrderCreatedEvent(
    orderId: String,
    val customerId: String,
    val items: List<OrderItem>
) : EntityCreatedEvent(
    aggregateId = orderId,
    aggregateType = "Order"
)

// Create event-sourced aggregate
class OrderAggregate(
    override val aggregateId: String
) : Aggregate() {
    
    override val aggregateType = "Order"
    
    // State
    var customerId: String? = null
    var items: MutableList<OrderItem> = mutableListOf()
    var status: OrderStatus = OrderStatus.DRAFT
    
    // Business operations
    suspend fun create(customerId: String, items: List<OrderItem>) {
        raiseEvent(OrderCreatedEvent(aggregateId, customerId, items))
    }
    
    // Apply events to update state
    override fun apply(event: DomainEvent) {
        when (event) {
            is OrderCreatedEvent -> {
                this.customerId = event.customerId
                this.items.addAll(event.items)
                this.status = OrderStatus.CREATED
            }
        }
    }
}

// Use repository for loading/saving
val repository = AggregateRepository(eventStore)

// Create and save aggregate
val order = OrderAggregate("order-123")
order.create("customer-456", items)
repository.save(order)

// Load aggregate from events
val loadedOrder = repository.load("order-123") { OrderAggregate(it) }

import io.github.noailabs.spice.eventsourcing.*

// Define a memento for your aggregate
data class CartMemento(
    override val aggregateId: String,
    override val version: Long,
    override val timestamp: Instant,
    val customerId: String,
    val items: List<CartItem>,
    val totalAmount: Money,
    val appliedCoupons: List<String>
) : AggregateMemento, Serializable {
    
    override val aggregateType = "ShoppingCart"
    
    override fun restoreState(aggregate: Aggregate) {
        require(aggregate is ShoppingCartAggregate)
        aggregate.restoreFromMemento(this)
    }
}

// Create aggregate with memento support
class ShoppingCartAggregate(
    override val aggregateId: String
) : MementoAggregate() {
    
    override val aggregateType = "ShoppingCart"
    
    // State
    private var customerId: String? = null
    private val items = mutableListOf<CartItem>()
    private var totalAmount = Money(0, "USD")
    private val appliedCoupons = mutableListOf<String>()
    
    // Create memento
    override fun doCreateMemento(): AggregateMemento {
        return CartMemento(
            aggregateId = aggregateId,
            version = version,
            timestamp = Instant.now(),
            customerId = customerId ?: "",
            items = items.toList(),
            totalAmount = totalAmount,
            appliedCoupons = appliedCoupons.toList()
        )
    }
    
    // Restore from memento
    override fun doRestoreFromMemento(memento: AggregateMemento) {
        require(memento is CartMemento)
        this.customerId = memento.customerId
        this.items.clear()
        this.items.addAll(memento.items)
        this.totalAmount = memento.totalAmount
        this.appliedCoupons.clear()
        this.appliedCoupons.addAll(memento.appliedCoupons)
    }
    
    // Event handling...
    override fun apply(event: DomainEvent) {
        // Apply events to update state
    }
}

// Use memento-aware repository
val repository = MementoAggregateRepository(
    eventStore = eventStore,
    snapshotStore = MementoSnapshotStoreFactory.inMemory(),
    snapshotFrequency = 50  // Create snapshot every 50 events
)

// Load aggregate (uses snapshot if available)
val cart = repository.load("cart-123") { ShoppingCartAggregate(it) }

// Save aggregate (creates snapshot automatically if needed)
repository.save(cart)

import io.github.noailabs.spice.eventsourcing.*

// Define a saga for order fulfillment
class OrderFulfillmentSaga(
    override val sagaId: String,
    private val orderId: String
) : Saga() {
    
    override val sagaType = "OrderFulfillment"
    
    override suspend fun execute(context: SagaContext) {
        // Step 1: Reserve inventory
        executeStep(ReserveInventoryStep(orderId), context)
        
        // Step 2: Process payment
        executeStep(ProcessPaymentStep(orderId), context)
        
        // Step 3: Create shipment
        executeStep(CreateShipmentStep(orderId), context)
        
        // Step 4: Send confirmation
        executeStep(SendConfirmationStep(orderId), context)
    }
}

// Define saga steps with compensation logic
class ProcessPaymentStep(private val orderId: String) : SagaStep {
    override val name = "ProcessPayment"
    
    override suspend fun execute(context: SagaContext) {
        // Process payment
        val paymentId = paymentService.charge(orderId)
        context.set("paymentId", paymentId)
    }
    
    override suspend fun compensate(context: SagaContext) {
        // Refund if saga fails
        val paymentId = context.get<String>("paymentId")
        paymentService.refund(paymentId)
    }
}

// Execute saga
val sagaManager = SagaManager(eventStore, InMemorySagaStore())
val saga = OrderFulfillmentSaga("saga-123", "order-123")
sagaManager.startSaga(saga, SagaContext())

@SpringBootApplication
@EnableSpice
class MyApplication

@Component
class MyService(
    @Autowired private val agentRegistry: AgentRegistry
) {
    fun processRequest(message: String): String {
        val agent = agentRegistry.get("my-agent")
        val response = runBlocking {
            agent?.processComm(Comm(content = message, from = "user"))
        }
        return response?.content ?: "No response"
    }
}