/**
 * @ruvector/edge-net Model Loader
 *
 * Smart model loading with:
 * - IndexedDB caching
 * - Automatic source selection (CDN -> GCS -> IPFS -> fallback)
 * - Streaming download with progress
 * - Model validation before use
 * - Lazy loading support
 *
 * @module @ruvector/edge-net/models/model-loader
 */

import { EventEmitter } from 'events';
import { createHash, randomBytes } from 'crypto';
import { promises as fs } from 'fs';
import path from 'path';

import { ModelRegistry } from './model-registry.js';
import { DistributionManager, ProgressTracker } from './distribution.js';

// ============================================
// CONSTANTS
// ============================================

const DEFAULT_CACHE_DIR = process.env.HOME
    ? `${process.env.HOME}/.ruvector/models/cache`
    : '/tmp/.ruvector/models/cache';

const CACHE_VERSION = 1;
const MAX_CACHE_SIZE_BYTES = 10 * 1024 * 1024 * 1024; // 10GB default
const CACHE_CLEANUP_THRESHOLD = 0.9; // Cleanup when 90% full

// ============================================
// CACHE STORAGE INTERFACE
// ============================================

/**
 * Cache storage interface for different backends
 */
class CacheStorage {
    async get(key) { throw new Error('Not implemented'); }
    async set(key, value, metadata) { throw new Error('Not implemented'); }
    async delete(key) { throw new Error('Not implemented'); }
    async has(key) { throw new Error('Not implemented'); }
    async list() { throw new Error('Not implemented'); }
    async getMetadata(key) { throw new Error('Not implemented'); }
    async clear() { throw new Error('Not implemented'); }
    async getSize() { throw new Error('Not implemented'); }
}

// ============================================
// FILE SYSTEM CACHE
// ============================================

/**
 * File system-based cache storage for Node.js
 */
class FileSystemCache extends CacheStorage {
    constructor(cacheDir) {
        super();
        this.cacheDir = cacheDir;
        this.metadataDir = path.join(cacheDir, '.metadata');
        this.initialized = false;
    }

    async init() {
        if (this.initialized) return;
        await fs.mkdir(this.cacheDir, { recursive: true });
        await fs.mkdir(this.metadataDir, { recursive: true });
        this.initialized = true;
    }

    _getFilePath(key) {
        // Sanitize key for filesystem
        const safeKey = key.replace(/[^a-zA-Z0-9._-]/g, '_');
        return path.join(this.cacheDir, safeKey);
    }

    _getMetadataPath(key) {
        const safeKey = key.replace(/[^a-zA-Z0-9._-]/g, '_');
        return path.join(this.metadataDir, `${safeKey}.json`);
    }

    async get(key) {
        await this.init();
        const filePath = this._getFilePath(key);

        try {
            const data = await fs.readFile(filePath);

            // Update access time in metadata
            await this._updateAccessTime(key);

            return data;
        } catch (error) {
            if (error.code === 'ENOENT') return null;
            throw error;
        }
    }

    async set(key, value, metadata = {}) {
        await this.init();
        const filePath = this._getFilePath(key);
        const metadataPath = this._getMetadataPath(key);

        // Write data
        await fs.writeFile(filePath, value);

        // Write metadata
        const fullMetadata = {
            key,
            size: value.length,
            hash: `sha256:${createHash('sha256').update(value).digest('hex')}`,
            createdAt: new Date().toISOString(),
            accessedAt: new Date().toISOString(),
            accessCount: 1,
            cacheVersion: CACHE_VERSION,
            ...metadata,
        };

        await fs.writeFile(metadataPath, JSON.stringify(fullMetadata, null, 2));

        return fullMetadata;
    }

    async delete(key) {
        await this.init();
        const filePath = this._getFilePath(key);
        const metadataPath = this._getMetadataPath(key);

        try {
            await fs.unlink(filePath);
            await fs.unlink(metadataPath).catch(() => {});
            return true;
        } catch (error) {
            if (error.code === 'ENOENT') return false;
            throw error;
        }
    }

    async has(key) {
        await this.init();
        const filePath = this._getFilePath(key);

        try {
            await fs.access(filePath);
            return true;
        } catch {
            return false;
        }
    }

    async list() {
        await this.init();

        try {
            const files = await fs.readdir(this.cacheDir);
            return files.filter(f => !f.startsWith('.'));
        } catch {
            return [];
        }
    }

    async getMetadata(key) {
        await this.init();
        const metadataPath = this._getMetadataPath(key);

        try {
            const data = await fs.readFile(metadataPath, 'utf-8');
            return JSON.parse(data);
        } catch {
            return null;
        }
    }

    async _updateAccessTime(key) {
        const metadataPath = this._getMetadataPath(key);

        try {
            const data = await fs.readFile(metadataPath, 'utf-8');
            const metadata = JSON.parse(data);

            metadata.accessedAt = new Date().toISOString();
            metadata.accessCount = (metadata.accessCount || 0) + 1;

            await fs.writeFile(metadataPath, JSON.stringify(metadata, null, 2));
        } catch {
            // Ignore metadata update errors
        }
    }

    async clear() {
        await this.init();
        const files = await this.list();

        for (const file of files) {
            await this.delete(file);
        }
    }

    async getSize() {
        await this.init();
        const files = await this.list();
        let totalSize = 0;

        for (const file of files) {
            const filePath = this._getFilePath(file);
            try {
                const stats = await fs.stat(filePath);
                totalSize += stats.size;
            } catch {
                // Ignore missing files
            }
        }

        return totalSize;
    }

    async getEntriesWithMetadata() {
        await this.init();
        const files = await this.list();
        const entries = [];

        for (const file of files) {
            const metadata = await this.getMetadata(file);
            if (metadata) {
                entries.push(metadata);
            }
        }

        return entries;
    }
}

// ============================================
// INDEXEDDB CACHE (BROWSER)
// ============================================

/**
 * IndexedDB-based cache storage for browsers
 */
class IndexedDBCache extends CacheStorage {
    constructor(dbName = 'ruvector-models') {
        super();
        this.dbName = dbName;
        this.storeName = 'models';
        this.metadataStoreName = 'metadata';
        this.db = null;
    }

    async init() {
        if (this.db) return;

        if (typeof indexedDB === 'undefined') {
            throw new Error('IndexedDB not available');
        }

        return new Promise((resolve, reject) => {
            const request = indexedDB.open(this.dbName, CACHE_VERSION);

            request.onerror = () => reject(request.error);

            request.onsuccess = () => {
                this.db = request.result;
                resolve();
            };

            request.onupgradeneeded = (event) => {
                const db = event.target.result;

                // Models store
                if (!db.objectStoreNames.contains(this.storeName)) {
                    db.createObjectStore(this.storeName);
                }

                // Metadata store
                if (!db.objectStoreNames.contains(this.metadataStoreName)) {
                    const metaStore = db.createObjectStore(this.metadataStoreName);
                    metaStore.createIndex('accessedAt', 'accessedAt');
                    metaStore.createIndex('size', 'size');
                }
            };
        });
    }

    async get(key) {
        await this.init();

        return new Promise((resolve, reject) => {
            const transaction = this.db.transaction([this.storeName], 'readonly');
            const store = transaction.objectStore(this.storeName);
            const request = store.get(key);

            request.onerror = () => reject(request.error);
            request.onsuccess = () => {
                if (request.result) {
                    this._updateAccessTime(key);
                }
                resolve(request.result || null);
            };
        });
    }

    async set(key, value, metadata = {}) {
        await this.init();

        const fullMetadata = {
            key,
            size: value.length || value.byteLength,
            hash: await this._computeHash(value),
            createdAt: new Date().toISOString(),
            accessedAt: new Date().toISOString(),
            accessCount: 1,
            cacheVersion: CACHE_VERSION,
            ...metadata,
        };

        return new Promise((resolve, reject) => {
            const transaction = this.db.transaction(
                [this.storeName, this.metadataStoreName],
                'readwrite'
            );

            const modelStore = transaction.objectStore(this.storeName);
            const metaStore = transaction.objectStore(this.metadataStoreName);

            modelStore.put(value, key);
            metaStore.put(fullMetadata, key);

            transaction.oncomplete = () => resolve(fullMetadata);
            transaction.onerror = () => reject(transaction.error);
        });
    }

    async _computeHash(data) {
        if (typeof crypto !== 'undefined' && crypto.subtle) {
            const buffer = data instanceof ArrayBuffer ? data : data.buffer;
            const hashBuffer = await crypto.subtle.digest('SHA-256', buffer);
            const hashArray = Array.from(new Uint8Array(hashBuffer));
            const hashHex = hashArray.map(b => b.toString(16).padStart(2, '0')).join('');
            return `sha256:${hashHex}`;
        }
        return null;
    }

    async delete(key) {
        await this.init();

        return new Promise((resolve, reject) => {
            const transaction = this.db.transaction(
                [this.storeName, this.metadataStoreName],
                'readwrite'
            );

            transaction.objectStore(this.storeName).delete(key);
            transaction.objectStore(this.metadataStoreName).delete(key);

            transaction.oncomplete = () => resolve(true);
            transaction.onerror = () => reject(transaction.error);
        });
    }

    async has(key) {
        const value = await this.get(key);
        return value !== null;
    }

    async list() {
        await this.init();

        return new Promise((resolve, reject) => {
            const transaction = this.db.transaction([this.storeName], 'readonly');
            const store = transaction.objectStore(this.storeName);
            const request = store.getAllKeys();

            request.onerror = () => reject(request.error);
            request.onsuccess = () => resolve(request.result);
        });
    }

    async getMetadata(key) {
        await this.init();

        return new Promise((resolve, reject) => {
            const transaction = this.db.transaction([this.metadataStoreName], 'readonly');
            const store = transaction.objectStore(this.metadataStoreName);
            const request = store.get(key);

            request.onerror = () => reject(request.error);
            request.onsuccess = () => resolve(request.result || null);
        });
    }

    async _updateAccessTime(key) {
        const metadata = await this.getMetadata(key);
        if (!metadata) return;

        metadata.accessedAt = new Date().toISOString();
        metadata.accessCount = (metadata.accessCount || 0) + 1;

        const transaction = this.db.transaction([this.metadataStoreName], 'readwrite');
        transaction.objectStore(this.metadataStoreName).put(metadata, key);
    }

    async clear() {
        await this.init();

        return new Promise((resolve, reject) => {
            const transaction = this.db.transaction(
                [this.storeName, this.metadataStoreName],
                'readwrite'
            );

            transaction.objectStore(this.storeName).clear();
            transaction.objectStore(this.metadataStoreName).clear();

            transaction.oncomplete = () => resolve();
            transaction.onerror = () => reject(transaction.error);
        });
    }

    async getSize() {
        await this.init();

        return new Promise((resolve, reject) => {
            const transaction = this.db.transaction([this.metadataStoreName], 'readonly');
            const store = transaction.objectStore(this.metadataStoreName);
            const request = store.getAll();

            request.onerror = () => reject(request.error);
            request.onsuccess = () => {
                const totalSize = request.result.reduce((sum, meta) => sum + (meta.size || 0), 0);
                resolve(totalSize);
            };
        });
    }
}

// ============================================
// MODEL LOADER
// ============================================

/**
 * ModelLoader - Smart model loading with caching
 */
export class ModelLoader extends EventEmitter {
    /**
     * Create a new ModelLoader
     * @param {object} options - Configuration options
     */
    constructor(options = {}) {
        super();

        this.id = `loader-${randomBytes(6).toString('hex')}`;

        // Create registry if not provided
        this.registry = options.registry || new ModelRegistry({
            registryPath: options.registryPath,
        });

        // Create distribution manager if not provided
        this.distribution = options.distribution || new DistributionManager({
            gcsBucket: options.gcsBucket,
            gcsProjectId: options.gcsProjectId,
            cdnBaseUrl: options.cdnBaseUrl,
            ipfsGateway: options.ipfsGateway,
        });

        // Cache configuration
        this.cacheDir = options.cacheDir || DEFAULT_CACHE_DIR;
        this.maxCacheSize = options.maxCacheSize || MAX_CACHE_SIZE_BYTES;

        // Initialize cache storage based on environment
        this.cache = this._createCacheStorage(options);

        // Loaded models (in-memory)
        this.loadedModels = new Map();

        // Loading promises (prevent duplicate loads)
        this.loadingPromises = new Map();

        // Lazy load queue
        this.lazyLoadQueue = [];
        this.lazyLoadActive = false;

        // Stats
        this.stats = {
            cacheHits: 0,
            cacheMisses: 0,
            downloads: 0,
            validationErrors: 0,
            lazyLoads: 0,
        };
    }

    /**
     * Create appropriate cache storage for environment
     * @private
     */
    _createCacheStorage(options) {
        // Browser environment
        if (typeof window !== 'undefined' && typeof indexedDB !== 'undefined') {
            return new IndexedDBCache(options.dbName || 'ruvector-models');
        }

        // Node.js environment
        return new FileSystemCache(this.cacheDir);
    }

    /**
     * Initialize the loader
     */
    async initialize() {
        // Initialize cache
        if (this.cache.init) {
            await this.cache.init();
        }

        // Load registry if path provided
        if (this.registry.registryPath) {
            try {
                await this.registry.load();
            } catch (error) {
                this.emit('warning', { message: 'Failed to load registry', error });
            }
        }

        this.emit('initialized', { loaderId: this.id });

        return this;
    }

    /**
     * Get cache key for a model
     * @private
     */
    _getCacheKey(name, version) {
        return `${name}@${version}`;
    }

    /**
     * Load a model
     * @param {string} name - Model name
     * @param {string} version - Version (default: latest)
     * @param {object} options - Load options
     * @returns {Promise<Buffer|Uint8Array>}
     */
    async load(name, version = 'latest', options = {}) {
        const key = this._getCacheKey(name, version);

        // Return cached in-memory model
        if (this.loadedModels.has(key) && !options.forceReload) {
            this.stats.cacheHits++;
            return this.loadedModels.get(key);
        }

        // Return existing loading promise
        if (this.loadingPromises.has(key)) {
            return this.loadingPromises.get(key);
        }

        // Start loading
        const loadPromise = this._loadModel(name, version, options);
        this.loadingPromises.set(key, loadPromise);

        try {
            const model = await loadPromise;
            this.loadedModels.set(key, model);
            return model;
        } finally {
            this.loadingPromises.delete(key);
        }
    }

    /**
     * Internal model loading logic
     * @private
     */
    async _loadModel(name, version, options = {}) {
        const { onProgress, skipCache = false, skipValidation = false } = options;

        // Get metadata from registry
        let metadata = this.registry.get(name, version);

        if (!metadata) {
            // Try to fetch from remote registry
            this.emit('warning', { message: `Model ${name}@${version} not in local registry` });
            throw new Error(`Model not found: ${name}@${version}`);
        }

        const resolvedVersion = metadata.version;
        const key = this._getCacheKey(name, resolvedVersion);

        // Check cache first (unless skipped)
        if (!skipCache) {
            const cached = await this.cache.get(key);
            if (cached) {
                // Validate cached data
                if (!skipValidation && metadata.hash) {
                    const isValid = this.distribution.verifyIntegrity(cached, metadata.hash);
                    if (isValid) {
                        this.stats.cacheHits++;
                        this.emit('cache_hit', { name, version: resolvedVersion });
                        return cached;
                    } else {
                        this.stats.validationErrors++;
                        this.emit('cache_invalid', { name, version: resolvedVersion });
                        await this.cache.delete(key);
                    }
                } else {
                    this.stats.cacheHits++;
                    return cached;
                }
            }
        }

        this.stats.cacheMisses++;

        // Download model
        this.emit('download_start', { name, version: resolvedVersion });

        const data = await this.distribution.download(metadata, {
            onProgress: (progress) => {
                this.emit('progress', { name, version: resolvedVersion, ...progress });
                if (onProgress) onProgress(progress);
            },
        });

        // Validate downloaded data
        if (!skipValidation) {
            const validation = this.distribution.verifyModel(data, metadata);
            if (!validation.valid) {
                this.stats.validationErrors++;
                throw new Error(`Model validation failed: ${JSON.stringify(validation.checks)}`);
            }
        }

        // Store in cache
        await this.cache.set(key, data, {
            modelName: name,
            version: resolvedVersion,
            format: metadata.format,
        });

        this.stats.downloads++;
        this.emit('loaded', { name, version: resolvedVersion, size: data.length });

        // Cleanup cache if needed
        await this._cleanupCacheIfNeeded();

        return data;
    }

    /**
     * Lazy load a model (load in background)
     * @param {string} name - Model name
     * @param {string} version - Version
     * @param {object} options - Load options
     */
    async lazyLoad(name, version = 'latest', options = {}) {
        const key = this._getCacheKey(name, version);

        // Already loaded or loading
        if (this.loadedModels.has(key) || this.loadingPromises.has(key)) {
            return;
        }

        // Check cache
        const cached = await this.cache.has(key);
        if (cached) {
            return; // Already in cache
        }

        // Add to queue
        this.lazyLoadQueue.push({ name, version, options });
        this.stats.lazyLoads++;

        this.emit('lazy_queued', { name, version, queueLength: this.lazyLoadQueue.length });

        // Start processing if not active
        if (!this.lazyLoadActive) {
            this._processLazyLoadQueue();
        }
    }

    /**
     * Process lazy load queue
     * @private
     */
    async _processLazyLoadQueue() {
        if (this.lazyLoadActive || this.lazyLoadQueue.length === 0) return;

        this.lazyLoadActive = true;

        while (this.lazyLoadQueue.length > 0) {
            const { name, version, options } = this.lazyLoadQueue.shift();

            try {
                await this.load(name, version, {
                    ...options,
                    lazy: true,
                });
            } catch (error) {
                this.emit('lazy_error', { name, version, error: error.message });
            }

            // Small delay between lazy loads
            await new Promise(resolve => setTimeout(resolve, 100));
        }

        this.lazyLoadActive = false;
    }

    /**
     * Preload multiple models
     * @param {Array<{name: string, version?: string}>} models - Models to preload
     */
    async preload(models) {
        const results = await Promise.allSettled(
            models.map(({ name, version }) => this.load(name, version || 'latest'))
        );

        return {
            total: models.length,
            loaded: results.filter(r => r.status === 'fulfilled').length,
            failed: results.filter(r => r.status === 'rejected').length,
            results,
        };
    }

    /**
     * Check if a model is loaded in memory
     * @param {string} name - Model name
     * @param {string} version - Version
     * @returns {boolean}
     */
    isLoaded(name, version = 'latest') {
        const metadata = this.registry.get(name, version);
        if (!metadata) return false;

        const key = this._getCacheKey(name, metadata.version);
        return this.loadedModels.has(key);
    }

    /**
     * Check if a model is cached on disk
     * @param {string} name - Model name
     * @param {string} version - Version
     * @returns {Promise<boolean>}
     */
    async isCached(name, version = 'latest') {
        const metadata = this.registry.get(name, version);
        if (!metadata) return false;

        const key = this._getCacheKey(name, metadata.version);
        return this.cache.has(key);
    }

    /**
     * Unload a model from memory
     * @param {string} name - Model name
     * @param {string} version - Version
     */
    unload(name, version = 'latest') {
        const metadata = this.registry.get(name, version);
        if (!metadata) return false;

        const key = this._getCacheKey(name, metadata.version);
        return this.loadedModels.delete(key);
    }

    /**
     * Unload all models from memory
     */
    unloadAll() {
        const count = this.loadedModels.size;
        this.loadedModels.clear();
        return count;
    }

    /**
     * Remove a model from cache
     * @param {string} name - Model name
     * @param {string} version - Version
     */
    async removeFromCache(name, version = 'latest') {
        const metadata = this.registry.get(name, version);
        if (!metadata) return false;

        const key = this._getCacheKey(name, metadata.version);
        return this.cache.delete(key);
    }

    /**
     * Clear all cached models
     */
    async clearCache() {
        await this.cache.clear();
        this.emit('cache_cleared');
    }

    /**
     * Cleanup cache if over size limit
     * @private
     */
    async _cleanupCacheIfNeeded() {
        const currentSize = await this.cache.getSize();
        const threshold = this.maxCacheSize * CACHE_CLEANUP_THRESHOLD;

        if (currentSize < threshold) return;

        this.emit('cache_cleanup_start', { currentSize, maxSize: this.maxCacheSize });

        // Get entries sorted by last access time
        let entries;
        if (this.cache.getEntriesWithMetadata) {
            entries = await this.cache.getEntriesWithMetadata();
        } else {
            const keys = await this.cache.list();
            entries = [];
            for (const key of keys) {
                const meta = await this.cache.getMetadata(key);
                if (meta) entries.push(meta);
            }
        }

        // Sort by access time (oldest first)
        entries.sort((a, b) =>
            new Date(a.accessedAt).getTime() - new Date(b.accessedAt).getTime()
        );

        // Remove oldest entries until under 80% capacity
        const targetSize = this.maxCacheSize * 0.8;
        let removedSize = 0;
        let removedCount = 0;

        for (const entry of entries) {
            if (currentSize - removedSize <= targetSize) break;

            await this.cache.delete(entry.key);
            removedSize += entry.size;
            removedCount++;
        }

        this.emit('cache_cleanup_complete', {
            removedCount,
            removedSize,
            newSize: currentSize - removedSize,
        });
    }

    /**
     * Get cache statistics
     * @returns {Promise<object>}
     */
    async getCacheStats() {
        const size = await this.cache.getSize();
        const keys = await this.cache.list();

        return {
            entries: keys.length,
            sizeBytes: size,
            sizeMB: Math.round(size / (1024 * 1024) * 100) / 100,
            maxSizeBytes: this.maxCacheSize,
            usagePercent: Math.round((size / this.maxCacheSize) * 100),
        };
    }

    /**
     * Get loader statistics
     * @returns {object}
     */
    getStats() {
        return {
            ...this.stats,
            loadedModels: this.loadedModels.size,
            pendingLoads: this.loadingPromises.size,
            lazyQueueLength: this.lazyLoadQueue.length,
            hitRate: this.stats.cacheHits + this.stats.cacheMisses > 0
                ? Math.round(
                    (this.stats.cacheHits / (this.stats.cacheHits + this.stats.cacheMisses)) * 100
                )
                : 0,
        };
    }

    /**
     * Get model from registry (without loading)
     * @param {string} name - Model name
     * @param {string} version - Version
     * @returns {object|null}
     */
    getModelInfo(name, version = 'latest') {
        return this.registry.get(name, version);
    }

    /**
     * Search for models
     * @param {object} criteria - Search criteria
     * @returns {Array}
     */
    searchModels(criteria) {
        return this.registry.search(criteria);
    }

    /**
     * List all available models
     * @returns {string[]}
     */
    listModels() {
        return this.registry.listModels();
    }
}

// ============================================
// EXPORTS
// ============================================

export { FileSystemCache, IndexedDBCache, CacheStorage };

export default ModelLoader;