import type { APIContext } from 'astro';
import { authService } from '@/lib/authService';

export async function GET({ request }: APIContext) {
    try {
        const pb = authService.createClientFromRequest(request);

        // Получаем отзывы без обязательной аутентификации для публичного доступа
        let reviews;
        try {
            reviews = await pb.collection('reviews').getFullList({
                sort: '-created',
                expand: 'author'
            });
        } catch (error) {
            console.error('Ошибка при получении отзывов из PocketBase:', error);
            return new Response(
                JSON.stringify({
                    error: 'Ошибка при получении отзывов из базы данных'
                }),
                {
                    status: 500,
                    headers: { 'Content-Type': 'application/json' }
                }
            );
        }

        // Преобразуем отзывы в нужный формат
        const formattedReviews = reviews.map(review => {
            const authorName = review.expand?.author?.name ||
                review.expand?.author?.email?.split('@')[0] ||
                'Anonym';
            const authorAvatar = review.expand?.author?.avatar || null;

            return {
                id: review.id,
                title: review.title,
                content: review.content,
                rating: review.rating,
                author: authorName,
                authorId: review.author, // ID автора для проверки владельца
                authorAvatar: authorAvatar, // Добавляем аватар автора
                createdAt: review.created
            };
        });

        return new Response(
            JSON.stringify({ reviews: formattedReviews }),
            {
                status: 200,
                headers: {
                    'Content-Type': 'application/json',
                    'Cache-Control': 'public, max-age=60'
                }
            }
        );
    } catch (error: unknown) {
        console.error('Ошибка при получении отзывов:', error);
        return new Response(
            JSON.stringify({
                error: 'Ошибка при получении отзывов'
            }),
            {
                status: 500,
                headers: { 'Content-Type': 'application/json' }
            }
        );
    }
}

export async function POST({ request }: APIContext) {
    try {
        const pb = authService.createClientFromRequest(request);

        // Проверяем аутентификацию для создания отзыва
        const user = await authService.validateAndRefreshSession(pb);

        if (!user) {
            return new Response(
                JSON.stringify({
                    error: 'Необходимо войти в систему для создания отзыва'
                }),
                {
                    status: 401,
                    headers: { 'Content-Type': 'application/json' }
                }
            );
        }

        // Получаем данные отзыва из тела запроса
        const body = await request.json();
        const { title, content, rating } = body;

        // Валидация данных
        if (!title || !content || !rating || rating < 1 || rating > 5) {
            return new Response(
                JSON.stringify({
                    error: 'Некорректные данные отзыва'
                }),
                {
                    status: 400,
                    headers: { 'Content-Type': 'application/json' }
                }
            );
        }

        // Дополнительная валидация: проверка длины и безопасности
        const trimmedTitle = title.trim();
        const trimmedContent = content.trim();

        if (trimmedTitle.length < 5 || trimmedTitle.length > 100) {
            return new Response(
                JSON.stringify({
                    error: 'Заголовок должен содержать от 5 до 100 символов'
                }),
                {
                    status: 400,
                    headers: { 'Content-Type': 'application/json' }
                }
            );
        }

        if (trimmedContent.length < 10 || trimmedContent.length > 1000) {
            return new Response(
                JSON.stringify({
                    error: 'Комментарий должен содержать от 10 до 1000 символов'
                }),
                {
                    status: 400,
                    headers: { 'Content-Type': 'application/json' }
                }
            );
        }

        // Проверка на наличие HTML тегов в заголовке для предотвращения XSS
        if (/<[^>]*>/g.test(trimmedTitle)) {
            return new Response(
                JSON.stringify({
                    error: 'Заголовок содержит недопустимые HTML теги'
                }),
                {
                    status: 400,
                    headers: { 'Content-Type': 'application/json' }
                }
            );
        }

        // Создаем отзыв в PocketBase
        const newReview = await pb.collection('reviews').create({
            title: trimmedTitle,
            content: trimmedContent,
            rating: parseInt(rating),
            author: user.id
        });

        // Форматируем ответ
        const formattedReview = {
            id: newReview.id,
            title: newReview.title,
            content: newReview.content,
            rating: newReview.rating,
            author: user.name || user.email?.split('@')[0] || 'Benutzer',
            authorId: user.id,
            authorAvatar: user.avatar || null, // Добавляем аватар автора
            createdAt: newReview.created
        };

        return new Response(
            JSON.stringify({
                success: true,
                review: formattedReview
            }),
            {
                status: 201,
                headers: {
                    'Content-Type': 'application/json'
                }
            }
        );
    } catch (error: unknown) {
        console.error('Ошибка при создании отзыва:', error);
        return new Response(
            JSON.stringify({
                success: false,
                error: 'Ошибка при создании отзыва'
            }),
            {
                status: 500,
                headers: { 'Content-Type': 'application/json' }
            }
        );
    }
}

export async function DELETE({ request }: APIContext) {
    try {
        const pb = authService.createClientFromRequest(request);

        // Проверяем аутентификацию
        const user = await authService.validateAndRefreshSession(pb);

        if (!user) {
            return new Response(
                JSON.stringify({
                    error: 'Необходимо войти в систему для удаления отзыва'
                }),
                {
                    status: 401,
                    headers: { 'Content-Type': 'application/json' }
                }
            );
        }

        // Получаем ID отзыва из URL
        const url = new URL(request.url);
        const reviewId = url.pathname.split('/').pop();

        if (!reviewId) {
            return new Response(
                JSON.stringify({
                    error: 'ID отзыва не указан'
                }),
                {
                    status: 400,
                    headers: { 'Content-Type': 'application/json' }
                }
            );
        }

        // Получаем отзыв для проверки
        const review = await pb.collection('reviews').getOne(reviewId);

        if (!review) {
            return new Response(
                JSON.stringify({
                    error: 'Отзыв nicht gefunden'
                }),
                {
                    status: 404,
                    headers: { 'Content-Type': 'application/json' }
                }
            );
        }

        // Проверяем права доступа
        const isAdmin = user.role === 'admin';
        const isOwner = review.author === user.id;

        if (!isAdmin && !isOwner) {
            return new Response(
                JSON.stringify({
                    error: 'Keine Berechtigung zum Löschen dieser Bewertung'
                }),
                {
                    status: 403,
                    headers: { 'Content-Type': 'application/json' }
                }
            );
        }

        // Удаляем отзыв
        await pb.collection('reviews').delete(reviewId);

        return new Response(
            JSON.stringify({
                success: true,
                message: 'Bewertung erfolgreich gelöscht'
            }),
            {
                status: 200,
                headers: { 'Content-Type': 'application/json' }
            }
        );
    } catch (error: unknown) {
        console.error('Ошибка при удалении отзыва:', error);

        return new Response(
            JSON.stringify({
                success: false,
                error: 'Fehler beim Löschen der Bewertung'
            }),
            {
                status: 500,
                headers: { 'Content-Type': 'application/json' }
            }
        );
    }
}