managarten/apps-archived/memoro/apps/mobile/features/settings/services/userSettingsService.ts

export interface MemoroSettings {
	dataUsageAcceptance?: boolean;
	emailNewsletterOptIn?: boolean;
	language?: string;
	defaultSpaceId?: string;
	migration?: {
		migrated_at: string;
		subscription_plan_id: string | null;
		is_active_subscription: boolean;
		memos_count?: number;
		memories_count?: number;
		images_count?: number;
		tags_count?: number;
		showMigratedNotification: boolean;
	};
}
export interface UserProfile {
	firstName?: string;
	lastName?: string;
	avatarUrl?: string;
}

export interface UserSettingsResponse {
	settings: {
		memoro?: MemoroSettings;
		[key: string]: any;
	};
	subscription_plan_id?: string;
	is_b2b?: boolean;
}

interface ProfileUpdateResponse {
	success: boolean;
	user: {
		id: string;
		email: string;
		first_name?: string;
		last_name?: string;
		avatar_url?: string;
		app_settings?: any;
	};
	message: string;
}

class UserSettingsService {
	private baseUrl = process.env.EXPO_PUBLIC_MEMORO_MIDDLEWARE_URL || 'http://localhost:3001';

	private async getAuthHeaders() {
		const { tokenManager } = await import('~/features/auth/services/tokenManager');
		const token = await tokenManager.getValidToken();
		if (!token) {
			throw new Error('Not authenticated');
		}
		return {
			Authorization: `Bearer ${token}`,
			'Content-Type': 'application/json',
		};
	}

	async getAllSettings(): Promise<UserSettingsResponse> {
		const headers = await this.getAuthHeaders();

		const response = await fetch(`${this.baseUrl}/settings`, {
			method: 'GET',
			headers,
		});

		if (!response.ok) {
			throw new Error(`Failed to get settings: ${response.statusText}`);
		}

		return response.json();
	}

	async getMemoroSettings(): Promise<MemoroSettings> {
		const headers = await this.getAuthHeaders();

		const response = await fetch(`${this.baseUrl}/settings/memoro`, {
			method: 'GET',
			headers,
		});

		if (!response.ok) {
			throw new Error(`Failed to get Memoro settings: ${response.statusText}`);
		}

		const data = await response.json();
		return data.settings || {};
	}

	async updateMemoroSettings(settings: Partial<MemoroSettings>): Promise<UserSettingsResponse> {
		const headers = await this.getAuthHeaders();

		const response = await fetch(`${this.baseUrl}/settings/memoro`, {
			method: 'PATCH',
			headers,
			body: JSON.stringify(settings),
		});

		if (!response.ok) {
			throw new Error(`Failed to update Memoro settings: ${response.statusText}`);
		}

		return response.json();
	}

	async updateDataUsageAcceptance(accepted: boolean): Promise<UserSettingsResponse> {
		const headers = await this.getAuthHeaders();

		const response = await fetch(`${this.baseUrl}/settings/memoro/data-usage`, {
			method: 'PATCH',
			headers,
			body: JSON.stringify({ accepted }),
		});

		if (!response.ok) {
			throw new Error(`Failed to update data usage acceptance: ${response.statusText}`);
		}

		return response.json();
	}

	async updateEmailNewsletterOptIn(optIn: boolean): Promise<UserSettingsResponse> {
		const headers = await this.getAuthHeaders();

		const response = await fetch(`${this.baseUrl}/settings/memoro/email-newsletter`, {
			method: 'PATCH',
			headers,
			body: JSON.stringify({ optIn }),
		});

		if (!response.ok) {
			throw new Error(`Failed to update email newsletter opt-in: ${response.statusText}`);
		}

		return response.json();
	}

	async updateUserProfile(profile: UserProfile): Promise<ProfileUpdateResponse> {
		const headers = await this.getAuthHeaders();

		const response = await fetch(`${this.baseUrl}/settings/profile`, {
			method: 'PATCH',
			headers,
			body: JSON.stringify(profile),
		});

		if (!response.ok) {
			throw new Error(`Failed to update user profile: ${response.statusText}`);
		}

		return response.json();
	}
}

export const userSettingsService = new UserSettingsService();