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

// Use a single PrismaClient instance
declare global {
  var prisma: PrismaClient | undefined;
}

const prisma = global.prisma || new PrismaClient();
if (process.env.NODE_ENV !== 'production') global.prisma = prisma;

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

async function parseXMLResponse(response: Response): Promise<any> {
  const text = await response.text();
  console.log('XML Response:', text);
  
  const parser = new DOMParser();
  const xmlDoc = parser.parseFromString(text, 'text/xml');
  
  // Check for parsing errors
  const parserError = xmlDoc.getElementsByTagName('parsererror');
  if (parserError.length > 0) {
    console.error('XML Parsing Error:', parserError[0].textContent);
    throw new Error('Failed to parse XML response');
  }
  
  const result: any = {};
  const root = xmlDoc.documentElement;
  
  if (root && root.nodeName === 'ocs') {
    const data = root.getElementsByTagName('data')[0];
    if (data) {
      const children = data.childNodes;
      for (let i = 0; i < children.length; i++) {
        const child = children[i];
        if (child.nodeType === 1) { // Element node
          result[child.nodeName] = child.textContent;
        }
      }
    }
  }
  
  return result;
}

async function createFolder(nextcloudUrl: string, username: string, password: string, folderPath: string) {
  const response = await fetch(`${nextcloudUrl}/remote.php/dav/files/${encodeURIComponent(username)}/${encodeURIComponent(folderPath)}`, {
    method: 'MKCOL',
    headers: {
      'Authorization': `Basic ${Buffer.from(`${username}:${password}`).toString('base64')}`,
    },
  });

  if (!response.ok && response.status !== 405) { // 405 means folder already exists
    throw new Error(`Failed to create folder ${folderPath}: ${response.status} ${response.statusText}`);
  }
}

async function getWebDAVCredentials(nextcloudUrl: string, username: string, adminUsername: string, adminPassword: string, userId: string) {
  try {
    // Check if credentials exist in database
    let credentials = await prisma.webDAVCredentials.findUnique({
      where: { userId },
    });

    if (credentials) {
      // Verify existing credentials still work
      const verifyResponse = await fetch(`${nextcloudUrl}/remote.php/dav/files/${encodeURIComponent(username)}/`, {
        method: 'PROPFIND',
        headers: {
          'Authorization': `Basic ${Buffer.from(`${username}:${credentials.password}`).toString('base64')}`,
          'Depth': '1',
          'Content-Type': 'application/xml',
        },
        body: '<?xml version="1.0" encoding="UTF-8"?><d:propfind xmlns:d="DAV:"><d:prop><d:resourcetype/></d:prop></d:propfind>',
      });

      if (verifyResponse.ok) {
        return credentials.password;
      }

      // If verification failed, delete the old credentials
      await prisma.webDAVCredentials.delete({
        where: { userId },
      });
    }

    // Get user info from Nextcloud
    const userInfoResponse = await fetch(`${nextcloudUrl}/ocs/v1.php/cloud/users/${encodeURIComponent(username)}`, {
      headers: {
        'Authorization': `Basic ${Buffer.from(`${adminUsername}:${adminPassword}`).toString('base64')}`,
        'OCS-APIRequest': 'true',
      },
    });

    if (!userInfoResponse.ok) {
      throw new Error(`Failed to get user info: ${userInfoResponse.status} ${userInfoResponse.statusText}`);
    }

    // Generate a new password
    const newPassword = Math.random().toString(36).slice(-12);
    console.log('Setting new password for user');

    // Set the user's password
    const setPasswordResponse = await fetch(`${nextcloudUrl}/ocs/v1.php/cloud/users/${encodeURIComponent(username)}`, {
      method: 'PUT',
      headers: {
        'Authorization': `Basic ${Buffer.from(`${adminUsername}:${adminPassword}`).toString('base64')}`,
        'OCS-APIRequest': 'true',
        'Content-Type': 'application/x-www-form-urlencoded',
      },
      body: new URLSearchParams({
        key: 'password',
        value: newPassword,
      }).toString(),
    });

    if (!setPasswordResponse.ok) {
      throw new Error(`Failed to set password: ${setPasswordResponse.status} ${setPasswordResponse.statusText}`);
    }

    // Store the new credentials
    credentials = await prisma.webDAVCredentials.create({
      data: {
        userId,
        username,
        password: newPassword,
      },
    });

    // Create required folder structure
    await createFolder(nextcloudUrl, username, newPassword, 'Private');
    await createFolder(nextcloudUrl, username, newPassword, 'Private/Diary');
    await createFolder(nextcloudUrl, username, newPassword, 'Private/Health');

    return newPassword;
  } catch (error) {
    console.error('Error in getWebDAVCredentials:', error);
    throw error;
  }
}

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

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

    const nextcloudUrl = process.env.NEXTCLOUD_URL;
    const adminUsername = process.env.NEXTCLOUD_ADMIN_USERNAME;
    const adminPassword = process.env.NEXTCLOUD_ADMIN_PASSWORD;

    if (!nextcloudUrl || !adminUsername || !adminPassword) {
      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 {
      // Use the Keycloak ID as the Nextcloud username
      const nextcloudUsername = `cube-${session.user.id}`;
      console.log('Using Nextcloud username:', nextcloudUsername);

      // Get or create WebDAV credentials
      const webdavPassword = await getWebDAVCredentials(
        nextcloudUrl,
        nextcloudUsername,
        adminUsername,
        adminPassword,
        session.user.id
      );

      if (!webdavPassword) {
        throw new Error('Failed to get WebDAV credentials');
      }

      // Get user's folders using WebDAV with Basic authentication
      const webdavUrl = `${nextcloudUrl}/remote.php/dav/files/${encodeURIComponent(nextcloudUsername)}/Private/`;
      console.log('Requesting WebDAV URL:', webdavUrl);

      const foldersResponse = await fetch(webdavUrl, {
        method: 'PROPFIND',
        headers: {
          'Authorization': `Basic ${Buffer.from(`${nextcloudUsername}:${webdavPassword}`).toString('base64')}`,
          'Depth': '1',
          'Content-Type': 'application/xml',
        },
        body: '<?xml version="1.0" encoding="UTF-8"?><d:propfind xmlns:d="DAV:"><d:prop><d:resourcetype/><d:displayname/></d:prop></d:propfind>',
      });

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

      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
      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 href = response.getElementsByTagName('d:href')[0]?.textContent;
        if (href) {
          // Extract folder name from href
          const folderName = decodeURIComponent(href.split('/').filter(Boolean).pop() || '');
          if (folderName && folderName !== 'Private') {
            folders.push(folderName);
          }
        }
      }

      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 }
    );
  }
}