import { MemoryRecord, MemoryState } from '@celiums/memory-types';

/**
 * packages/core/src/store.ts
 *
 * The HIPPOCAMPUS — Central memory store.
 * Handles encoding, storage, retrieval, and lifecycle management
 * across PostgreSQL (long-term), Qdrant (semantic), and Valkey (working memory).
 */

interface StoreConfig {
    postgres: {
        host: string;
        port: number;
        database: string;
        user: string;
        password: string;
        max?: number;
        ssl?: boolean;
    };
    qdrant: {
        url: string;
        apiKey?: string;
        collectionName?: string;
    };
    valkey: {
        host: string;
        port: number;
        password?: string;
        db?: number;
        keyPrefix?: string;
    };
    embedding: {
        endpoint: string;
        apiKey?: string;
        model?: string;
        dimensions?: number;
    };
}
declare class MemoryStore {
    private pg;
    private qdrant;
    private redis;
    private config;
    private collectionName;
    private valkeyPrefix;
    private vectorDimensions;
    constructor(config: StoreConfig);
    initialize(): Promise<void>;
    saveMemory(memory: MemoryRecord): Promise<MemoryRecord>;
    getMemory(id: string): Promise<MemoryRecord | null>;
    searchByImportance(userId: string, minImportance: number, limit?: number): Promise<MemoryRecord[]>;
    deleteMemories(ids: string[]): Promise<number>;
    updateLifecycle(id: string, importance: number, state: MemoryState): Promise<MemoryRecord | null>;
    reactivate(id: string): Promise<MemoryRecord | null>;
    getForLifecycle(userId: string, batchSize?: number): Promise<MemoryRecord[]>;
    health(): Promise<{
        postgres: boolean;
        qdrant: boolean;
        valkey: boolean;
        overall: boolean;
    }>;
    embed(text: string): Promise<number[]>;
    /**
     * Deterministic word-level embedding fallback.
     * Same algorithm as InMemoryMemoryStore — similar texts produce
     * similar vectors via word hashing with TF-like weighting.
     * Not as good as a real embedding model, but keeps the system
     * operational when the embedding service is down.
     */
    private deterministicEmbed;
    getUserProfile(userId: string): Promise<{
        id: string;
        externalId: string;
        timezone: string;
        communicationStyle: string | null;
        preferences: Record<string, any>;
        knownPatterns: string[];
        sleepSchedule: {
            start: string;
            end: string;
        };
        lastActiveAt: Date;
    } | null>;
    getProjectContext(projectId: string): Promise<{
        id: string;
        userId: string;
        name: string;
        description: string | null;
        techStack: string[];
        conventions: string[];
        currentGoals: string[];
        recentDecisions: string[];
        isActive: boolean;
    } | null>;
    semanticSearch(vector: number[], userId: string, projectId: string | null, limit?: number, scoreThreshold?: number): Promise<Array<{
        id: string;
        score: number;
    }>>;
    fullTextSearch(query: string, userId: string, projectId: string | null, limit?: number): Promise<Array<{
        id: string;
        score: number;
    }>>;
    getMemoriesByIds(ids: string[]): Promise<MemoryRecord[]>;
    getRecentSessionMemories(userId: string, sessionId: string, limit?: number): Promise<MemoryRecord[]>;
    findSimilarMemories(vector: number[], userId: string, threshold?: number, limit?: number): Promise<Array<{
        id: string;
        score: number;
    }>>;
    updateMemory(id: string, updates: Partial<Pick<MemoryRecord, 'content' | 'summary' | 'importance' | 'emotionalValence' | 'emotionalArousal' | 'emotionalDominance' | 'confidence' | 'strength' | 'state' | 'consolidatedAt' | 'consolidationCount' | 'linkedMemoryIds' | 'tags' | 'entities'>>): Promise<MemoryRecord | null>;
    updateSession(sessionId: string, updates: {
        endedAt?: Date;
        isConsolidated?: boolean;
        consolidationStartedAt?: Date;
        consolidationCompletedAt?: Date;
        summary?: string;
        messageCount?: number;
    }): Promise<void>;
    bulkUpdateLifecycle(updates: Array<{
        id: string;
        importance: number;
        strength: number;
        state: MemoryState;
    }>): Promise<void>;
    /**
     * Load a user's circadian profile + persisted PAD/factors.
     * Returns null if the user has no row yet.
     */
    loadCircadianProfile(userId: string): Promise<{
        userId: string;
        circadian: {
            timezoneIana: string;
            timezoneOffset: number;
            peakHour: number;
            amplitude: number;
            baseArousal: number;
            lethargyRate: number;
            hemisphere: 1 | -1;
            seasonalAmplitude: number;
        };
        pad: {
            pleasure: number;
            arousal: number;
            dominance: number;
        };
        factors: {
            sessionActivity: number;
            stressLevel: number;
            caffeineLevel: number;
            sleepDebt: number;
            cognitiveLoad: number;
            emotionalAccumulator: number;
            exerciseLevel: number;
            motivationTrend: number;
        };
        lastInteraction: Date;
        interactionCount: number;
        communicationStyle: string;
        preferences: Record<string, any>;
        knownPatterns: string[];
        createdAt: Date;
        updatedAt: Date;
    } | null>;
    /**
     * Get-or-create. If the profile doesn't exist, insert with sane defaults
     * (UTC timezone, peakHour 11) and return it.
     */
    ensureCircadianProfile(userId: string): Promise<{
        userId: string;
        circadian: {
            timezoneIana: string;
            timezoneOffset: number;
            peakHour: number;
            amplitude: number;
            baseArousal: number;
            lethargyRate: number;
            hemisphere: 1 | -1;
            seasonalAmplitude: number;
        };
        pad: {
            pleasure: number;
            arousal: number;
            dominance: number;
        };
        factors: {
            sessionActivity: number;
            stressLevel: number;
            caffeineLevel: number;
            sleepDebt: number;
            cognitiveLoad: number;
            emotionalAccumulator: number;
            exerciseLevel: number;
            motivationTrend: number;
        };
        lastInteraction: Date;
        interactionCount: number;
        communicationStyle: string;
        preferences: Record<string, any>;
        knownPatterns: string[];
        createdAt: Date;
        updatedAt: Date;
    }>;
    /**
     * Update circadian config (timezone, peakHour, amplitude, etc.).
     * Only the fields present in `patch` are touched. Returns the updated row.
     */
    updateCircadianConfig(userId: string, patch: Partial<{
        timezoneIana: string;
        timezoneOffset: number;
        peakHour: number;
        amplitude: number;
        baseArousal: number;
        lethargyRate: number;
        hemisphere: 1 | -1;
        seasonalAmplitude: number;
    }>): Promise<{
        userId: string;
        circadian: {
            timezoneIana: string;
            timezoneOffset: number;
            peakHour: number;
            amplitude: number;
            baseArousal: number;
            lethargyRate: number;
            hemisphere: 1 | -1;
            seasonalAmplitude: number;
        };
        pad: {
            pleasure: number;
            arousal: number;
            dominance: number;
        };
        factors: {
            sessionActivity: number;
            stressLevel: number;
            caffeineLevel: number;
            sleepDebt: number;
            cognitiveLoad: number;
            emotionalAccumulator: number;
            exerciseLevel: number;
            motivationTrend: number;
        };
        lastInteraction: Date;
        interactionCount: number;
        communicationStyle: string;
        preferences: Record<string, any>;
        knownPatterns: string[];
        createdAt: Date;
        updatedAt: Date;
    }>;
    /**
     * Persist a user's PAD vector after the limbic engine processes an event.
     * Also bumps last_interaction and interaction_count.
     */
    persistUserPad(userId: string, pad: {
        pleasure: number;
        arousal: number;
        dominance: number;
    }): Promise<void>;
    /**
     * Persist updated factor accumulators (caffeine, stress, etc.).
     */
    persistUserFactors(userId: string, factors: {
        sessionActivity: number;
        stressLevel: number;
        caffeineLevel: number;
        sleepDebt: number;
        cognitiveLoad: number;
        emotionalAccumulator: number;
        exerciseLevel: number;
        motivationTrend: number;
    }): Promise<void>;
    /**
     * Lightweight last_interaction bump (no PAD change). Used by /recall when
     * we want to count the user as active without altering emotional state.
     */
    touchUserInteraction(userId: string): Promise<void>;
    shutdown(): Promise<void>;
}

export { MemoryStore, type StoreConfig };