dependencies: [
    .package(url: "https://github.com/yangchenlarkin/Monstra.git", from: "1.0.0")
]

import Monstore

// Create an LRU cache with capacity 100
let cache = LRUQueue<String, Int>(capacity: 100)

// Set values
cache.setValue(42, for: "answer")
cache.setValue(100, for: "score")

// Get values
let answer = cache.getValue(for: "answer") // Returns 42

// Remove values
let removed = cache.removeValue(for: "score") // Returns 100

// Check status
print(cache.count) // Current number of items
print(cache.isEmpty) // Whether cache is empty
print(cache.isFull) // Whether cache is at capacity

import Monstore

// Create TTL cache with automatic expiration
let ttlCache = TTLPriorityLRUQueue<String, Int>(capacity: 100)

// Set value with TTL (expires in 5 seconds)
ttlCache.unsafeSet(value: 42, for: "answer", expiredIn: 5.0)

// Get value (returns nil if expired)
let answer = ttlCache.getValue(for: "answer")

// Wait for expiration...
Thread.sleep(forTimeInterval: 6.0)
let expired = ttlCache.getValue(for: "answer") // Returns nil

import Monstask

// Create a task with caching and retry logic
let networkTask = MonoTask<Data>(
    retry: .count(count: 3, intervalProxy: .exponentialBackoff(initialTimeInterval: 1.0)),
    resultExpireDuration: 300.0 // 5 minutes cache
) { callback in
    // Your network request logic here
    URLSession.shared.dataTask(with: url) { data, response, error in
        if let error = error {
            callback(.failure(error))
        } else if let data = data {
            callback(.success(data))
        }
    }.resume()
}

// Execute with async/await
let result = await networkTask.asyncExecute()
switch result {
case .success(let data):
    print("Got data: \(data.count) bytes")
case .failure(let error):
    print("Error: \(error)")
}

// Multiple concurrent calls - only one network request
let result1 = await networkTask.asyncExecute() // Network call happens
let result2 = await networkTask.asyncExecute() // Returns cached result
let result3 = await networkTask.asyncExecute() // Returns cached result

class LRUQueue<K: Hashable, Element> {
    init(capacity: Int)
    
    func setValue(_ value: Element, for key: K) -> Element?
    func getValue(for key: K) -> Element?
    func removeValue(for key: K) -> Element?
    
    var count: Int { get }
    var isEmpty: Bool { get }
    var isFull: Bool { get }
}

class TTLPriorityLRUQueue<Key: Hashable, Value> {
    init(capacity: Int)
    
    func unsafeSet(value: Value, for key: Key, expiredIn duration: TimeInterval) -> Value?
    func getValue(for key: Key) -> Value?
    func unsafeRemoveValue(for key: Key) -> Value?
}

class MonoTask<TaskResult> {
    init(retry: RetryCount, resultExpireDuration: Double, taskQueue: DispatchQueue, callbackQueue: DispatchQueue, task: @escaping CallbackExecution)
    
    func execute(then completionHandler: ResultCallback?)
    func asyncExecute() async -> Result<TaskResult, Error>
    func executeThrows() async throws -> TaskResult
    func justExecute()
    func clearResult(ongoingExecutionStrategy: OngoingExecutionStrategy)
    
    var currentResult: TaskResult? { get }
    var isExecuting: Bool { get }
}