import { pb } from './pocketbaseService';

export const createNotification = async (userId, type, title, message, data = {}) => {
    try {
        // Проверяем настройки уведомлений пользователя
        const settings = await pb.collection('notification_settings').getFirstListItem(`user_id = "${userId}"`);
        
        // Проверяем, включены ли уведомления данного типа
        if (!settings[type]) {
            return null;
        }

        // Создаем уведомление
        const notification = await pb.collection('notifications').create({
            user_id: userId,
            type,
            title,
            message,
            data,
            is_read: false
        });

        // Если включены email-уведомления, отправляем email
        if (settings.email_notifications) {
            // TODO: Добавить отправку email
        }

        return notification;
    } catch (error) {
        console.error('Error creating notification:', error);
        if (error.status === 403) {
            console.error('Permission denied: User does not have access to notifications');
        }
        return null;
    }
};

export const createAchievementNotification = async (userId, achievement) => {
    return createNotification(
        userId,
        'achievement',
        'Новое достижение!',
        `Вы получили достижение "${achievement.name}"`,
        { achievement_id: achievement.id }
    );
};

export const createReviewLikeNotification = async (userId, review, likedBy) => {
    return createNotification(
        userId,
        'like',
        'Новый лайк',
        `${likedBy.username} оценил вашу рецензию на "${review.expand?.media_id?.title}"`,
        { review_id: review.id }
    );
};

export const createReviewCommentNotification = async (userId, review, comment, commentedBy) => {
    return createNotification(
        userId,
        'review_comment',
        'Новый комментарий',
        `${commentedBy.username} прокомментировал вашу рецензию на "${review.expand?.media_id?.title}"`,
        { review_id: review.id, comment_id: comment.id, commented_by_id: commentedBy.id }
    );
};

export const createLevelUpNotification = async (userId, newLevel) => {
    return createNotification(
        userId,
        'level_up',
        'Повышение уровня!',
        `Поздравляем! Вы достигли ${newLevel} уровня`,
        { level: newLevel }
    );
};

export const createSystemNotification = async (userId, title, message, data = {}) => {
    return createNotification(
        userId,
        'system',
        title,
        message,
        data
    );
};

export const createNewFollowerNotification = async (userId, follower) => {
    return createNotification(
        userId,
        'follower',
        'Новый подписчик',
        `${follower.username} подписался на вас`,
        { follower_id: follower.id }
    );
};

export const createCommentReplyNotification = async (userId, comment, reply, repliedBy) => {
    return createNotification(
        userId,
        'comment_reply',
        'Новый ответ на комментарий',
        `${repliedBy.username} ответил на ваш комментарий`,
        { comment_id: comment.id, reply_id: reply.id, replied_by_id: repliedBy.id }
    );
};

export const createModerationNotification = async (userId, type, content) => {
    const messages = {
        review_approved: 'Ваша рецензия была одобрена',
        review_rejected: 'Ваша рецензия была отклонена',
        comment_approved: 'Ваш комментарий был одобрен',
        comment_rejected: 'Ваш комментарий был отклонен'
    };

    return createNotification(
        userId,
        'moderation',
        'Модерация контента',
        messages[type] || 'Ваш контент был проверен модератором',
        { type, content_id: content.id }
    );
};

export const markNotificationAsRead = async (notificationId) => {
    try {
        return await pb.collection('notifications').update(notificationId, { is_read: true });
    } catch (error) {
        console.error('Error marking notification as read:', error);
        return null;
    }
};

export const markAllNotificationsAsRead = async (userId) => {
    try {
        const notifications = await pb.collection('notifications').getList(1, 1000, {
            filter: `user_id = "${userId}" && is_read = false`
        });

        await Promise.all(
            notifications.items.map(n => 
                pb.collection('notifications').update(n.id, { is_read: true })
            )
        );

        return true;
    } catch (error) {
        console.error('Error marking all notifications as read:', error);
        return false;
    }
};

export const getNotificationSettings = async (userId) => {
    try {
        // Сначала проверяем, есть ли уже настройки
        const existingSettings = await pb.collection('notification_settings').getList(1, 1, {
            filter: `user_id = "${userId}"`
        });

        if (existingSettings.items.length > 0) {
            return existingSettings.items[0];
        }

        // Если настроек нет, создаем новые
        return await pb.collection('notification_settings').create({
            user_id: userId,
            achievement: true,
            like: true,
            review_comment: true,
            system: true,
            level_up: true,
            follower: true,
            comment_reply: true,
            moderation: true,
            email_notifications: false
        });
    } catch (error) {
        console.error('Error in getNotificationSettings:', error);
        throw error;
    }
};

export const updateNotificationSettings = async (settingsId, settings) => {
    try {
        return await pb.collection('notification_settings').update(settingsId, settings);
    } catch (error) {
        console.error('Error updating notification settings:', error);
        if (error.status === 403) {
            throw new Error('Нет доступа к настройкам уведомлений');
        }
        throw error;
    }
}; 