// /app/api/refresh-facebook-token/route.ts
import { NextResponse } from "next/server";
import { getAll, has, get } from '@vercel/edge-config';

// On récupère les identifiants de l'app Facebook
const facebook_app_id = process.env.FACEBOOK_APP_ID!;
const facebook_app_secret = process.env.FACEBOOK_APP_SECRET!;

// Route GET appelée par une tâche cron Vercel
export async function GET() {
    try {
        // Vérifie si un token existe déjà dans l'Edge Config
        const hasFacebookToken = await has('facebook_token');

        if (hasFacebookToken) {
            const oldToken = await get('facebook_token') as string;

            // On tente de renouveler le token
            const result = await updateFacebookToken(oldToken);

            if (result?.success) {
                return NextResponse.json({
                    facebookToken: result.newToken,
                    status: 'success',
                    message: 'Token Facebook renouvelé.'
                });
            } else {
                return NextResponse.json({
                    status: 'error',
                    message: 'Échec du renouvellement du token Facebook.'
                }, { status: 500 });
            }
        }

        // Aucun token Facebook trouvé → retour d'état
        const configItems = await getAll();
        return NextResponse.json({
            configItems,
            status: 'ok',
            message: 'Aucun token Facebook à rafraîchir.'
        });
    } catch (err: any) {
        console.error('Erreur lors du rafraîchissement du token :', err);
        return NextResponse.json({
            status: 'error',
            message: 'Erreur serveur lors de la tentative de rafraîchissement.'
        }, { status: 500 });
    }
}

// Fonction qui appelle l'API Facebook pour renouveler le token
async function updateFacebookToken(oldToken: string): Promise<{ success: boolean, newToken?: string }> {
    try {
        // Appel à Facebook pour échanger le token
        const res = await fetch(`https://graph.facebook.com/v21.0/oauth/access_token?grant_type=fb_exchange_token&client_id=${facebook_app_id}&client_secret=${facebook_app_secret}&fb_exchange_token=${oldToken}`);
        const data = await res.json();

        if (!data.access_token) {
            console.error('Réponse invalide de Facebook :', data);
            return { success: false };
        }

        // Mise à jour dans l’Edge Config
        const updateRes = await fetch(
            `https://api.vercel.com/v1/edge-config/${process.env.VERCEL_EDGE_ID}/items?teamId=${process.env.VERCEL_TEAM_ID}`,
            {
                method: 'PATCH',
                headers: {
                    Authorization: `Bearer ${process.env.VERCEL_API_TOKEN}`,
                    'Content-Type': 'application/json',
                },
                body: JSON.stringify({
                    items: [
                        {
                            operation: 'update',
                            key: 'facebook_token',
                            value: data.access_token,
                        },
                    ],
                }),
            }
        );

        const result = await updateRes.json();

        if (updateRes.ok) {
            return { success: true, newToken: data.access_token };
        } else {
            console.error('Échec de la mise à jour Vercel Edge:', result);
            return { success: false };
        }
    } catch (error) {
        console.error('Erreur dans updateFacebookToken:', error);
        return { success: false };
    }
}

import { baseURL } from '@/app/resources';
import { getPosts } from '@/app/utils/serverActions';
import { NextResponse } from 'next/server';
import { postToFacebook } from './postToFacebook';
import { postToLinkedIn } from './postToLinkedIn';

const env = process.env.NODE_ENV

export async function GET(req: Request) {
    if (!(env === 'development') && req.headers.get('Authorization') !== `Bearer ${process.env.CRON_SECRET}`) {
        return NextResponse.json({ status: 'Unauthorized', code: 401 });
    }
    // 1. Récupère les articles publiés dans les dernières 24h
    const articles = await getPosts({ limit: 1 });

    // 2. Pour chaque article, publier sur les médias sociaux
    for (const article of articles) {
        if (article.metadata.publishedAt && isLessThan24HoursOld(article.metadata.publishedAt)) {
            const postData = {
                title: article.metadata.title as string,
                description: article.metadata.description as string,
                url: `${baseURL}/blog/${article.slug}`
            };
            await Promise.all([
                // postToLinkedIn(postData),
                postToFacebook(postData)
            ]);
            console.log(`Partage de l'article ${article.slug} sur les média sociaux.`);
            return NextResponse.json({ status: 'done', count: articles.length });
        } else {
            console.log(`L'article ${article.slug} a plus de 24 heures il ne sera pas diffusé !.`);
            return NextResponse.json({ status: 'skipped', message: articles.length + ' article(s) ils ont plus de 24h et ont déjà était diffusés.' });
        }
    }

}

function isLessThan24HoursOld(dateString: string): boolean {
    const publishedDate = new Date(dateString);
    const now = new Date();
    const diffMs = now.getTime() - publishedDate.getTime();
    const diffHours = diffMs / (1000 * 60 * 60);
    return diffHours < 24;
}

import { get } from '@vercel/edge-config';
import ogs from 'open-graph-scraper';

export async function postToLinkedIn(article: any) {
    const accessToken = (await get('linkedin_token')) as string;
    const personURN = process.env.LINKEDIN_AUTHOR_URN!; // ex: urn:li:person:abc123

    // 1️⃣ Récupérer les données OpenGraph
    const ogResult = await ogs({ url: article.url });
    const ogData = ogResult.result;

    // console.log('OpenGraph Data:', ogData);

    // fallback en cas de champs manquants
    const ogTitle = ogData.ogTitle || article.title;
    const ogDescription = ogData.ogDescription || article.description;
    let ogImage: string | undefined;
    if (ogData.ogImage && Array.isArray(ogData.ogImage) && typeof ogData.ogImage[0] === 'object' && ogData.ogImage[0] !== null && 'url' in ogData.ogImage[0]) {
        ogImage = ogData.ogImage[0].url;
    }

    // 2️⃣ Construire le post UGC avec OG
    const postBody = {
        author: personURN,
        lifecycleState: 'DRAFT',
        specificContent: {
            'com.linkedin.ugc.ShareContent': {
                shareCommentary: {
                    text: ogTitle
                },
                shareMediaCategory: 'ARTICLE',
                media: [
                    {
                        status: 'READY',
                        description: {
                            text: ogDescription
                        },
                        originalUrl: article.url,
                        title: {
                            text: ogTitle
                        },
                        ...(ogImage && {
                            thumbnails: [
                                { resolvedUrl: ogImage }
                            ]
                        })
                    }
                ]
            }
        },
        visibility: {
            'com.linkedin.ugc.MemberNetworkVisibility': 'PUBLIC'
        }
    };

    // 3️⃣ Envoi vers LinkedIn
    const res = await fetch('https://api.linkedin.com/v2/ugcPosts', {
        method: 'POST',
        headers: {
            Authorization: `Bearer ${accessToken}`,
            'X-Restli-Protocol-Version': '2.0.0',
            'Content-Type': 'application/json'
        },
        body: JSON.stringify(postBody)
    });

    if (!res.ok) {
        const error = await res.text();
        console.error(`LinkedIn post failed: ${res.status}`, error);
        throw new Error(`LinkedIn post failed: ${res.status} - ${error}`);
    }

    console.log('LinkedIn post succeeded!');
}

import { get } from '@vercel/edge-config';

export async function postToFacebook(article: any) {
    const accessToken = await get('facebook_token') as string;
    const pageId = process.env.FACEBOOK_PAGE_ID!;

    const url = `https://graph.facebook.com/${pageId}/feed`;

    const params = new URLSearchParams({
        message:
            `${article.title}

${article.description}`,
        link: article.url,
        access_token: accessToken
    });
    const res = await fetch(`${url}?${params.toString()}`, {
        method: 'POST'
    });

    if (!res.ok) {
        const error = await res.text();
        console.error(`Facebook post failed: ${res.status}`, error);
        throw new Error(`Facebook post failed: ${res.status} - ${error}`);
    }
}

{
    "crons": [
        {
            "path": "/api/cron/social-share",
            "schedule": "0 7 * * *"
        },
        {
            "path": "/api/cron/refresh-facebook-token",
            "schedule": "0 4 20 * *"
        }
    ]
}