database.js

// IndexedDB Database Management Module
class TLNotesDB {
    constructor() {
        this.db = null;
        this.DB_NAME = 'TLNotesDB';
        this.DB_VERSION = 1;
    }

    async init() {
        return new Promise((resolve, reject) => {
            const request = indexedDB.open(this.DB_NAME, this.DB_VERSION);

            request.onerror = () => {
                console.error('Database error:', request.error);
                reject(request.error);
            };

            request.onsuccess = () => {
                this.db = request.result;
                console.log('Database initialized successfully');
                resolve(this.db);
            };

            request.onupgradeneeded = (event) => {
                this.db = event.target.result;
                console.log('Upgrading database...');

                // Create notes store
                if (!this.db.objectStoreNames.contains('notes')) {
                    const notesStore = this.db.createObjectStore('notes', { keyPath: 'id' });
                    notesStore.createIndex('created', 'created', { unique: false });
                    notesStore.createIndex('type', 'type', { unique: false });
                    notesStore.createIndex('edited', 'edited', { unique: false });
                    console.log('Notes store created');
                }

                // Create trash store
                if (!this.db.objectStoreNames.contains('trash')) {
                    const trashStore = this.db.createObjectStore('trash', { keyPath: 'id' });
                    trashStore.createIndex('trashedAt', 'trashedAt', { unique: false });
                    console.log('Trash store created');
                }

                // Create settings store
                if (!this.db.objectStoreNames.contains('settings')) {
                    const settingsStore = this.db.createObjectStore('settings', { keyPath: 'key' });
                    console.log('Settings store created');
                }
            };
        });
    }

    // Notes operations
    async getAllNotes() {
        return new Promise((resolve, reject) => {
            const transaction = this.db.transaction(['notes'], 'readonly');
            const store = transaction.objectStore('notes');
            const request = store.getAll();

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

    async saveNote(note) {
        return new Promise((resolve, reject) => {
            const transaction = this.db.transaction(['notes'], 'readwrite');
            const store = transaction.objectStore('notes');
            const request = store.put(note);

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

    async deleteNote(id) {
        return new Promise((resolve, reject) => {
            const transaction = this.db.transaction(['notes'], 'readwrite');
            const store = transaction.objectStore('notes');
            const request = store.delete(id);

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

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

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

    // Trash operations
    async getAllTrash() {
        return new Promise((resolve, reject) => {
            const transaction = this.db.transaction(['trash'], 'readonly');
            const store = transaction.objectStore('trash');
            const request = store.getAll();

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

    async moveToTrash(note) {
        note.trashedAt = Date.now();
        return new Promise((resolve, reject) => {
            const transaction = this.db.transaction(['trash', 'notes'], 'readwrite');
            const trashStore = transaction.objectStore('trash');
            const notesStore = transaction.objectStore('notes');

            const addToTrash = trashStore.put(note);
            const removeFromNotes = notesStore.delete(note.id);

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

    async restoreFromTrash(id) {
        return new Promise((resolve, reject) => {
            const transaction = this.db.transaction(['trash', 'notes'], 'readwrite');
            const trashStore = transaction.objectStore('trash');
            const notesStore = transaction.objectStore('notes');

            const getFromTrash = trashStore.get(id);

            getFromTrash.onsuccess = () => {
                const note = getFromTrash.result;
                if (note) {
                    delete note.trashedAt;
                    notesStore.put(note);
                    trashStore.delete(id);
                }
            };

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

    async deleteFromTrash(id) {
        return new Promise((resolve, reject) => {
            const transaction = this.db.transaction(['trash'], 'readwrite');
            const store = transaction.objectStore('trash');
            const request = store.delete(id);

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

    async emptyTrash() {
        return new Promise((resolve, reject) => {
            const transaction = this.db.transaction(['trash'], 'readwrite');
            const store = transaction.objectStore('trash');
            const request = store.clear();

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

    async restoreAllFromTrash() {
        return new Promise(async (resolve, reject) => {
            try {
                const trashItems = await this.getAllTrash();
                const transaction = this.db.transaction(['trash', 'notes'], 'readwrite');
                const trashStore = transaction.objectStore('trash');
                const notesStore = transaction.objectStore('notes');

                trashItems.forEach(note => {
                    delete note.trashedAt;
                    notesStore.put(note);
                    trashStore.delete(note.id);
                });

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

    // Settings operations
    async getSetting(key) {
        return new Promise((resolve, reject) => {
            const transaction = this.db.transaction(['settings'], 'readonly');
            const store = transaction.objectStore('settings');
            const request = store.get(key);

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

    async setSetting(key, value) {
        return new Promise((resolve, reject) => {
            const transaction = this.db.transaction(['settings'], 'readwrite');
            const store = transaction.objectStore('settings');
            const request = store.put({ key, value });

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

    // Data management operations
    async exportData() {
        try {
            const notes = await this.getAllNotes();
            const trash = await this.getAllTrash();

            return {
                notes,
                trash,
                exportDate: new Date().toISOString(),
                version: this.DB_VERSION
            };
        } catch (error) {
            throw new Error('Failed to export data: ' + error.message);
        }
    }

    async importData(data) {
        return new Promise((resolve, reject) => {
            const transaction = this.db.transaction(['notes', 'trash'], 'readwrite');
            const notesStore = transaction.objectStore('notes');
            const trashStore = transaction.objectStore('trash');

            // Clear existing data
            notesStore.clear();
            trashStore.clear();

            // Import notes
            if (data.notes && Array.isArray(data.notes)) {
                data.notes.forEach(note => notesStore.put(note));
            }

            // Import trash
            if (data.trash && Array.isArray(data.trash)) {
                data.trash.forEach(note => trashStore.put(note));
            }

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

    async clearAllData() {
        return new Promise((resolve, reject) => {
            const transaction = this.db.transaction(['notes', 'trash', 'settings'], 'readwrite');
            const notesStore = transaction.objectStore('notes');
            const trashStore = transaction.objectStore('trash');
            const settingsStore = transaction.objectStore('settings');

            notesStore.clear();
            trashStore.clear();
            settingsStore.clear();

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

    // Database statistics
    async getStats() {
        try {
            const notes = await this.getAllNotes();
            const trash = await this.getAllTrash();

            const stats = {
                totalNotes: notes.length,
                trashCount: trash.length,
                notesByType: {},
                oldestNote: null,
                newestNote: null
            };

            // Calculate notes by type
            notes.forEach(note => {
                stats.notesByType[note.type] = (stats.notesByType[note.type] || 0) + 1;
            });

            // Find oldest and newest notes
            if (notes.length > 0) {
                const sortedByCreated = notes.sort((a, b) => a.created - b.created);
                stats.oldestNote = sortedByCreated[0].created;
                stats.newestNote = sortedByCreated[sortedByCreated.length - 1].created;
            }

            return stats;
        } catch (error) {
            throw new Error('Failed to get stats: ' + error.message);
        }
    }

    // Calculate approximate database size
    async getDatabaseSize() {
        try {
            const data = await this.exportData();
            const dataString = JSON.stringify(data);
            const sizeInBytes = new Blob([dataString]).size;

            if (sizeInBytes < 1024) {
                return sizeInBytes + ' B';
            } else if (sizeInBytes < 1024 * 1024) {
                return Math.round(sizeInBytes / 1024 * 100) / 100 + ' KB';
            } else {
                return Math.round(sizeInBytes / (1024 * 1024) * 100) / 100 + ' MB';
            }
        } catch (error) {
            return 'Unknown';
        }
    }
}

// Create global database instance
const database = new TLNotesDB();