import { ContainerRepository, ImageRepository, SessionRepository, LLMProviderRepository, PrototypeRepository, ContainerRecord, ImageRecord, ImageMetadata, LLMProviderRecord, PrototypeRecord, SessionRecord } from '@agentxjs/core/persistence';
import { Storage } from 'unstorage';
import { Message } from '@agentxjs/core/agent';

/**
 * Persistence Types for Node Provider
 */

/**
 * Persistence driver interface
 *
 * Each driver must implement this interface.
 * The createStorage() method is called once during initialization.
 */
interface PersistenceDriver {
    /**
     * Create the underlying storage instance
     */
    createStorage(): Promise<Storage>;
}
/**
 * Persistence - Aggregated repositories
 */
interface Persistence {
    readonly containers: ContainerRepository;
    readonly images: ImageRepository;
    readonly sessions: SessionRepository;
    readonly llmProviders: LLMProviderRepository;
    readonly prototypes: PrototypeRepository;
}

/**
 * Memory Driver - In-memory storage
 *
 * Useful for testing and development.
 * Data is lost when the process exits.
 *
 * @example
 * ```typescript
 * import { createPersistence, memoryDriver } from "@agentxjs/node-platform/persistence";
 *
 * const persistence = await createPersistence(memoryDriver());
 * ```
 */

/**
 * Create a memory driver
 */
declare function memoryDriver(): PersistenceDriver;

/**
 * Persistence - Core persistence implementation
 *
 * Creates a Persistence instance from a driver.
 * Each driver provides a createStorage() method that returns an unstorage Storage instance.
 */

/**
 * Create a Persistence instance from a driver
 *
 * @param driver - The persistence driver to use
 * @returns Promise<Persistence> instance
 *
 * @example
 * ```typescript
 * import { createPersistence, memoryDriver } from "@agentxjs/node-platform/persistence";
 *
 * const persistence = await createPersistence(memoryDriver());
 * ```
 */
declare function createPersistence(driver: PersistenceDriver): Promise<Persistence>;

/**
 * StorageContainerRepository - unstorage-based ContainerRepository
 *
 * Uses unstorage for backend-agnostic storage (Memory, Redis, SQLite, etc.)
 */

/**
 * StorageContainerRepository - unstorage implementation
 */
declare class StorageContainerRepository implements ContainerRepository {
    private readonly storage;
    constructor(storage: Storage);
    private key;
    saveContainer(record: ContainerRecord): Promise<void>;
    findContainerById(containerId: string): Promise<ContainerRecord | null>;
    findAllContainers(): Promise<ContainerRecord[]>;
    deleteContainer(containerId: string): Promise<void>;
    containerExists(containerId: string): Promise<boolean>;
}

/**
 * StorageImageRepository - unstorage-based ImageRepository
 *
 * Uses unstorage for backend-agnostic storage (Memory, Redis, SQLite, etc.)
 */

/**
 * StorageImageRepository - unstorage implementation
 */
declare class StorageImageRepository implements ImageRepository {
    private readonly storage;
    constructor(storage: Storage);
    private key;
    private nameIndexKey;
    private containerIndexKey;
    saveImage(record: ImageRecord): Promise<void>;
    findImageById(imageId: string): Promise<ImageRecord | null>;
    findAllImages(): Promise<ImageRecord[]>;
    findImagesByName(name: string): Promise<ImageRecord[]>;
    findImagesByContainerId(containerId: string): Promise<ImageRecord[]>;
    deleteImage(imageId: string): Promise<void>;
    imageExists(imageId: string): Promise<boolean>;
    updateMetadata(imageId: string, metadata: Partial<ImageMetadata>): Promise<void>;
}

/**
 * StorageLLMProviderRepository - unstorage-based LLMProviderRepository
 *
 * Uses unstorage for backend-agnostic storage (Memory, Redis, SQLite, etc.)
 */

/**
 * StorageLLMProviderRepository - unstorage implementation
 */
declare class StorageLLMProviderRepository implements LLMProviderRepository {
    private readonly storage;
    constructor(storage: Storage);
    private key;
    private containerIndexKey;
    saveLLMProvider(record: LLMProviderRecord): Promise<void>;
    findLLMProviderById(id: string): Promise<LLMProviderRecord | null>;
    findLLMProvidersByContainerId(containerId: string): Promise<LLMProviderRecord[]>;
    deleteLLMProvider(id: string): Promise<void>;
    llmProviderExists(id: string): Promise<boolean>;
    findDefaultLLMProvider(containerId: string): Promise<LLMProviderRecord | null>;
    setDefaultLLMProvider(id: string): Promise<void>;
}

/**
 * StoragePrototypeRepository - unstorage-based PrototypeRepository
 *
 * Uses unstorage for backend-agnostic storage (Memory, Redis, SQLite, etc.)
 */

/**
 * StoragePrototypeRepository - unstorage implementation
 */
declare class StoragePrototypeRepository implements PrototypeRepository {
    private readonly storage;
    constructor(storage: Storage);
    private key;
    private containerIndexKey;
    savePrototype(record: PrototypeRecord): Promise<void>;
    findPrototypeById(prototypeId: string): Promise<PrototypeRecord | null>;
    findAllPrototypes(): Promise<PrototypeRecord[]>;
    findPrototypesByContainerId(containerId: string): Promise<PrototypeRecord[]>;
    deletePrototype(prototypeId: string): Promise<void>;
    prototypeExists(prototypeId: string): Promise<boolean>;
}

/**
 * StorageSessionRepository - unstorage-based SessionRepository
 *
 * Uses unstorage for backend-agnostic storage (Memory, Redis, SQLite, etc.)
 */

/**
 * StorageSessionRepository - unstorage implementation
 */
declare class StorageSessionRepository implements SessionRepository {
    private readonly storage;
    /** Per-session write lock to prevent concurrent addMessage race conditions */
    private writeLocks;
    constructor(storage: Storage);
    private key;
    private messagesKey;
    private imageIndexKey;
    private containerIndexKey;
    saveSession(record: SessionRecord): Promise<void>;
    findSessionById(sessionId: string): Promise<SessionRecord | null>;
    findSessionByImageId(imageId: string): Promise<SessionRecord | null>;
    findSessionsByContainerId(containerId: string): Promise<SessionRecord[]>;
    findAllSessions(): Promise<SessionRecord[]>;
    deleteSession(sessionId: string): Promise<void>;
    sessionExists(sessionId: string): Promise<boolean>;
    addMessage(sessionId: string, message: Message): Promise<void>;
    getMessages(sessionId: string): Promise<Message[]>;
    clearMessages(sessionId: string): Promise<void>;
}

/**
 * SQLite Driver - SQLite database storage
 *
 * Uses commonxjs SQLite abstraction with automatic runtime detection:
 * - Bun: uses bun:sqlite (built-in)
 * - Node.js 22+: uses node:sqlite (built-in)
 *
 * @example
 * ```typescript
 * import { createPersistence, sqliteDriver } from "@agentxjs/node-platform/persistence";
 *
 * const persistence = await createPersistence(
 *   sqliteDriver({ path: "./data/agentx.db" })
 * );
 * ```
 */

interface SqliteDriverOptions {
    /**
     * Path to SQLite database file
     * @example "./data/agentx.db"
     */
    path: string;
}
/**
 * Create a SQLite driver
 *
 * @param options - Driver options
 */
declare function sqliteDriver(options: SqliteDriverOptions): PersistenceDriver;

export { type Persistence, type PersistenceDriver, type SqliteDriverOptions, StorageContainerRepository, StorageImageRepository, StorageLLMProviderRepository, StoragePrototypeRepository, StorageSessionRepository, createPersistence, memoryDriver, sqliteDriver };