Neah/app/api/nextcloud/status/route.ts

import { NextResponse } from 'next/server';
import { getServerSession } from 'next-auth';
import { authOptions } from '@/app/api/auth/[...nextauth]/route';
import { DOMParser } from '@xmldom/xmldom';

// Simple in-memory cache for Nextcloud tokens
const tokenCache = new Map<string, { token: string; expires: number }>();

async function sleep(ms: number) {
  return new Promise(resolve => setTimeout(resolve, ms));
}

async function establishNextcloudSession(nextcloudUrl: string, keycloakToken: string, maxRetries = 3) {
  // Check cache first
  const cacheKey = `${nextcloudUrl}:${keycloakToken}`;
  const cached = tokenCache.get(cacheKey);
  if (cached && cached.expires > Date.now()) {
    return cached.token;
  }

  let lastError;
  for (let attempt = 0; attempt < maxRetries; attempt++) {
    try {
      // Add exponential backoff
      if (attempt > 0) {
        await sleep(Math.pow(2, attempt) * 1000);
      }

      const sessionResponse = await fetch(`${nextcloudUrl}/index.php/apps/oauth2/api/v1/token`, {
        method: 'POST',
        headers: {
          'Content-Type': 'application/x-www-form-urlencoded',
          'Authorization': `Bearer ${keycloakToken}`,
        },
        body: new URLSearchParams({
          grant_type: 'urn:ietf:params:oauth:grant-type:token-exchange',
          subject_token: keycloakToken,
          subject_token_type: 'urn:ietf:params:oauth:token-type:access_token',
          client_id: process.env.NEXTCLOUD_CLIENT_ID || '',
          client_secret: process.env.NEXTCLOUD_CLIENT_SECRET || '',
        }).toString(),
      });

      if (sessionResponse.status === 429) {
        // Rate limited, wait and retry
        const retryAfter = sessionResponse.headers.get('Retry-After');
        await sleep((retryAfter ? parseInt(retryAfter) : 5) * 1000);
        continue;
      }

      if (!sessionResponse.ok) {
        const errorText = await sessionResponse.text();
        console.error('Failed to establish Nextcloud session:', errorText);
        throw new Error('Failed to establish Nextcloud session');
      }

      const sessionData = await sessionResponse.json();
      
      // Cache the token for 5 minutes
      tokenCache.set(cacheKey, {
        token: sessionData.access_token,
        expires: Date.now() + 5 * 60 * 1000
      });

      return sessionData.access_token;
    } catch (error) {
      lastError = error;
      console.error(`Attempt ${attempt + 1} failed:`, error);
    }
  }

  throw lastError || new Error('Failed to establish Nextcloud session after retries');
}

export async function GET() {
  try {
    const session = await getServerSession(authOptions);

    if (!session?.user?.email || !session?.accessToken) {
      return NextResponse.json(
        { error: 'Unauthorized' },
        { status: 401 }
      );
    }

    const nextcloudUrl = process.env.NEXTCLOUD_URL;
    if (!nextcloudUrl) {
      console.error('Missing Nextcloud configuration');
      return NextResponse.json(
        { error: 'Nextcloud configuration is missing' },
        { status: 500 }
      );
    }

    // Test Nextcloud connectivity
    const testResponse = await fetch(`${nextcloudUrl}/status.php`);
    if (!testResponse.ok) {
      console.error('Nextcloud is not accessible:', await testResponse.text());
      return NextResponse.json(
        { error: "Nextcloud n'est pas accessible" },
        { status: 503 }
      );
    }

    try {
      // Establish Nextcloud session with retries
      const nextcloudToken = await establishNextcloudSession(nextcloudUrl, session.accessToken);
      
      // Get user's folders using WebDAV with Nextcloud token
      const webdavUrl = `${nextcloudUrl}/remote.php/dav/files/${encodeURIComponent(session.user.email)}/`;
      console.log('Requesting WebDAV URL:', webdavUrl);

      const foldersResponse = await fetch(webdavUrl, {
        headers: {
          'Authorization': `Bearer ${nextcloudToken}`,
          'Depth': '1',
          'Content-Type': 'application/xml',
        },
      });

      if (!foldersResponse.ok) {
        const errorText = await foldersResponse.text();
        console.error('Failed to fetch folders. Status:', foldersResponse.status);
        console.error('Response:', errorText);
        console.error('Response headers:', Object.fromEntries(foldersResponse.headers.entries()));
        throw new Error(`Failed to fetch folders: ${errorText}`);
      }

      const folderData = await foldersResponse.text();
      console.log('Folder data:', folderData);

      // Parse the XML response to get folder names and filter only directories
      const parser = new DOMParser();
      const xmlDoc = parser.parseFromString(folderData, 'text/xml');
      const responses = Array.from(xmlDoc.getElementsByTagName('d:response'));
      
      const folders: string[] = [];
      for (const response of responses) {
        const resourceType = response.getElementsByTagName('d:resourcetype')[0];
        const isCollection = resourceType?.getElementsByTagName('d:collection').length > 0;
        
        if (isCollection) {
          const displayName = response.getElementsByTagName('d:displayname')[0]?.textContent;
          if (displayName && displayName !== session.user.email) {
            folders.push(displayName);
          }
        }
      }

      console.log('Parsed folders:', folders);

      return NextResponse.json({
        isConnected: true,
        folders
      });
    } catch (error: any) {
      console.error('Error accessing Nextcloud WebDAV:', error);
      return NextResponse.json(
        { error: "Erreur d'accès aux dossiers Nextcloud", details: error?.message || String(error) },
        { status: 503 }
      );
    }
  } catch (error: any) {
    console.error('Error checking Nextcloud status:', error);
    return NextResponse.json(
      { error: 'Failed to check Nextcloud status', details: error?.message || String(error) },
      { status: 500 }
    );
  }
}