managarten/apps-archived/nutriphi/apps/mobile/services/UserPreferencesService.ts

import { SQLiteService } from './database/SQLiteService';

export interface UserPreferences {
	locationEnabled: boolean;
	locationPermissionAsked: boolean;
	defaultMealType: 'breakfast' | 'lunch' | 'dinner' | 'snack';
	healthGoalCalories?: number;
	healthGoalProtein?: number;
	healthGoalCarbs?: number;
	healthGoalFat?: number;
	notificationsEnabled: boolean;
	reminderTimes: string[]; // Array of times like ["08:00", "12:30", "19:00"]
	theme: 'light' | 'dark' | 'system';
	language: 'de' | 'en';
}

const DEFAULT_PREFERENCES: UserPreferences = {
	locationEnabled: true,
	locationPermissionAsked: false,
	defaultMealType: 'lunch',
	notificationsEnabled: true,
	reminderTimes: [],
	theme: 'system',
	language: 'de',
};

export class UserPreferencesService {
	private static instance: UserPreferencesService;
	private dbService: SQLiteService;
	private cachedPreferences: UserPreferences | null = null;

	private constructor() {
		this.dbService = SQLiteService.getInstance();
	}

	public static getInstance(): UserPreferencesService {
		if (!UserPreferencesService.instance) {
			UserPreferencesService.instance = new UserPreferencesService();
		}
		return UserPreferencesService.instance;
	}

	public async initialize(): Promise<void> {
		// Load preferences into cache
		await this.loadPreferences();
	}

	private async loadPreferences(): Promise<UserPreferences> {
		try {
			const db = await this.dbService.getDatabase();

			// Check if table exists first
			const tableExists = await db.getFirstAsync<{ name: string }>(
				"SELECT name FROM sqlite_master WHERE type='table' AND name='user_preferences'"
			);

			if (!tableExists) {
				console.log('User preferences table does not exist yet, using defaults');
				this.cachedPreferences = { ...DEFAULT_PREFERENCES };
				return this.cachedPreferences;
			}

			const rows = await db.getAllAsync<{ key: string; value: string; type: string }>(
				'SELECT key, value, type FROM user_preferences'
			);

			const preferences = { ...DEFAULT_PREFERENCES };

			for (const row of rows) {
				const value = this.parseValue(row.value, row.type);
				(preferences as any)[row.key] = value;
			}

			this.cachedPreferences = preferences;
			return preferences;
		} catch (error) {
			console.error('Failed to load preferences:', error);
			this.cachedPreferences = { ...DEFAULT_PREFERENCES };
			return this.cachedPreferences;
		}
	}

	private parseValue(value: string, type: string): any {
		switch (type) {
			case 'boolean':
				return value === 'true';
			case 'number':
				return parseFloat(value);
			case 'array':
				return JSON.parse(value);
			case 'string':
			default:
				return value;
		}
	}

	private getValueType(value: any): string {
		if (typeof value === 'boolean') return 'boolean';
		if (typeof value === 'number') return 'number';
		if (Array.isArray(value)) return 'array';
		return 'string';
	}

	public async getPreferences(): Promise<UserPreferences> {
		if (!this.cachedPreferences) {
			await this.loadPreferences();
		}
		return this.cachedPreferences!;
	}

	public async updatePreference<K extends keyof UserPreferences>(
		key: K,
		value: UserPreferences[K]
	): Promise<void> {
		try {
			// Update cache immediately for responsive UI
			if (!this.cachedPreferences) {
				this.cachedPreferences = { ...DEFAULT_PREFERENCES };
			}
			this.cachedPreferences[key] = value;

			const db = await this.dbService.getDatabase();

			// Check if table exists
			const tableExists = await db.getFirstAsync<{ name: string }>(
				"SELECT name FROM sqlite_master WHERE type='table' AND name='user_preferences'"
			);

			if (!tableExists) {
				console.log('User preferences table does not exist yet, cache updated only');
				return;
			}

			const type = this.getValueType(value);
			const serializedValue = type === 'array' ? JSON.stringify(value) : String(value);

			await db.runAsync(
				`INSERT OR REPLACE INTO user_preferences (key, value, type, updated_at) 
         VALUES (?, ?, ?, datetime('now'))`,
				[key, serializedValue, type]
			);
		} catch (error) {
			console.error(`Failed to update preference ${key}:`, error);
			// Don't throw - we already updated the cache
		}
	}

	public async updateMultiplePreferences(updates: Partial<UserPreferences>): Promise<void> {
		const db = await this.dbService.getDatabase();

		try {
			await db.execAsync('BEGIN TRANSACTION');

			for (const [key, value] of Object.entries(updates)) {
				const type = this.getValueType(value);
				const serializedValue = type === 'array' ? JSON.stringify(value) : String(value);

				await db.runAsync(
					`INSERT OR REPLACE INTO user_preferences (key, value, type, updated_at) 
           VALUES (?, ?, ?, datetime('now'))`,
					[key, serializedValue, type]
				);
			}

			await db.execAsync('COMMIT');

			// Update cache
			if (this.cachedPreferences) {
				Object.assign(this.cachedPreferences, updates);
			}
		} catch (error) {
			await db.execAsync('ROLLBACK');
			console.error('Failed to update preferences:', error);
			throw error;
		}
	}

	public async resetToDefaults(): Promise<void> {
		try {
			const db = await this.dbService.getDatabase();
			await db.execAsync('DELETE FROM user_preferences');
			this.cachedPreferences = { ...DEFAULT_PREFERENCES };
		} catch (error) {
			console.error('Failed to reset preferences:', error);
			throw error;
		}
	}

	// Convenience methods
	public async isLocationEnabled(): Promise<boolean> {
		const prefs = await this.getPreferences();
		return prefs.locationEnabled;
	}

	public async setLocationEnabled(enabled: boolean): Promise<void> {
		await this.updatePreference('locationEnabled', enabled);
	}

	public async hasAskedLocationPermission(): Promise<boolean> {
		const prefs = await this.getPreferences();
		return prefs.locationPermissionAsked;
	}

	public async markLocationPermissionAsked(): Promise<void> {
		await this.updatePreference('locationPermissionAsked', true);
	}
}