import { NextApiRequest, NextApiResponse } from 'next'
import { IncomingForm, File as FormidableFile } from 'formidable'
import type { Fields, Files } from 'formidable'
import FormData from 'form-data'
import fs from 'fs'
import https from 'https'
import http from 'http'
import { URL } from 'url'

const MAX_FILE_SIZE = 50 * 1024 * 1024 // 50MB

export const config = {
  api: {
    bodyParser: false, // Disable bodyParser to handle multipart
  },
}

interface ParseResult {
  fields: Fields
  files: Files
}

function isRecord(value: unknown): value is Record<string, unknown> {
  return typeof value === 'object' && value !== null
}

function readString(value: unknown): string | undefined {
  return typeof value === 'string' ? value : undefined
}

function getFirstFile(files: Files, fieldName: string): FormidableFile | null {
  const value = files[fieldName]
  if (!value) {
    return null
  }
  if (Array.isArray(value)) {
    const first = value[0]
    return first ?? null
  }
  return value
}

function getFormDataHeaders(formData: FormData): http.OutgoingHttpHeaders {
  const raw: unknown = formData.getHeaders()
  if (!isRecord(raw)) {
    return {}
  }
  const headers: http.OutgoingHttpHeaders = {}
  for (const [key, value] of Object.entries(raw)) {
    const str = readString(value)
    if (str !== undefined) {
      headers[key] = str
    }
  }
  return headers
}

function getRedirectLocation(headers: unknown): string | undefined {
  if (!isRecord(headers)) {
    return undefined
  }
  const {location} = headers
  if (typeof location === 'string') {
    return location
  }
  if (Array.isArray(location) && typeof location[0] === 'string') {
    return location[0]
  }
  return undefined
}

export default async function handler(req: NextApiRequest, res: NextApiResponse): Promise<void> {
  if (req.method !== 'POST') {
    return res.status(405).json({ error: 'Method not allowed' })
  }

  // Get target endpoint and auth token from query
  const targetEndpoint = (req.query.endpoint as string) ?? 'https://void.cat/upload'
  const authToken = req.query.auth as string | undefined

  try {
    // Parse multipart form data
    // formidable needs the raw Node.js IncomingMessage, which NextApiRequest extends
    const form = new IncomingForm({
      maxFileSize: MAX_FILE_SIZE,
      keepExtensions: true,
    })

    const parseResult = await new Promise<ParseResult>((resolve, reject) => {
      form.parse(req, (err, fields, files) => {
        if (err) {
          console.error('Formidable parse error:', err)
          reject(err)
        } else {
          resolve({ fields, files })
        }
      })
    })

    const { files } = parseResult

    // Get the file from the parsed form
    const fileField = getFirstFile(files, 'file')
    if (!fileField) {
      return res.status(400).json({ error: 'No file provided' })
    }

    // Forward to target endpoint using https/http native modules
    // Support redirects (301, 302, 307, 308)
    const currentUrl = new URL(targetEndpoint)
    const MAX_REDIRECTS = 5

    let response: { statusCode: number; statusMessage: string; body: string }
    try {
      response = await new Promise<{ statusCode: number; statusMessage: string; body: string }>((resolve, reject) => {
        function makeRequest(url: URL, redirectCount: number, file: FormidableFile, token?: string): void {
          if (redirectCount > MAX_REDIRECTS) {
            reject(new Error(`Too many redirects (max ${MAX_REDIRECTS})`))
            return
          }

          // Recreate FormData for each request (needed for redirects)
          const requestFormData = new FormData()
          const fileStream = fs.createReadStream(file.filepath)

          // Use 'file' as field name (standard for NIP-95, but some endpoints may use different names)
          // Note: nostrimg.com might expect a different field name - if issues persist, try 'image' or 'upload'
          const fieldName = 'file'
          requestFormData.append(fieldName, fileStream, {
      filename: file.originalFilename ?? file.newFilename ?? 'upload',
      contentType: file.mimetype ?? 'application/octet-stream',
    })

          const isHttps = url.protocol === 'https:'
          const clientModule = isHttps ? https : http
          const headers = getFormDataHeaders(requestFormData)

          // Add standard headers that some endpoints require
          headers['Accept'] = 'application/json'
          headers['User-Agent'] = 'zapwall.fr/1.0'

          // Add NIP-98 Authorization header if token is provided
          if (token) {
            headers['Authorization'] = `Nostr ${token}`
          }

          // Log request details for debugging (only for problematic endpoints)
          if (url.hostname.includes('nostrimg.com')) {
            console.warn('NIP-95 proxy request to nostrimg.com:', {
              url: url.toString(),
        method: 'POST',
              fieldName,
              filename: file.originalFilename ?? file.newFilename ?? 'upload',
              contentType: file.mimetype ?? 'application/octet-stream',
              fileSize: file.size,
        headers: {
                'Content-Type': headers['content-type'],
                'Accept': headers['Accept'],
                'User-Agent': headers['User-Agent'],
                'Authorization': token ? '[present]' : '[absent]',
              },
            })
          }

          const requestOptions: http.RequestOptions = {
            hostname: url.hostname,
            port: url.port ?? (isHttps ? 443 : 80),
            path: url.pathname + url.search,
            method: 'POST',
            headers,
            timeout: 30000, // 30 seconds timeout
          }

          const proxyRequest = clientModule.request(requestOptions, (proxyResponse: http.IncomingMessage) => {
            // Handle redirects (301, 302, 307, 308)
            const statusCode = proxyResponse.statusCode ?? 500
            if ((statusCode === 301 || statusCode === 302 || statusCode === 307 || statusCode === 308) && proxyResponse.headers.location) {
              const location = getRedirectLocation(proxyResponse.headers as unknown)
              if (!location) {
                reject(new Error('Redirect response missing location header'))
                return
              }
              let redirectUrl: URL
              try {
                // Handle relative and absolute URLs
                redirectUrl = new URL(location, url.toString())
                console.warn('NIP-95 proxy redirect:', {
                  from: url.toString(),
                  to: redirectUrl.toString(),
                  statusCode,
                  redirectCount: redirectCount + 1,
                })
                // Drain the response before redirecting
                proxyResponse.resume()
                // Make new request to redirect location (preserve auth token for redirects)
                makeRequest(redirectUrl, redirectCount + 1, file, token)
                return
              } catch (urlError) {
                console.error('NIP-95 proxy invalid redirect URL:', {
                  location,
                  error: urlError instanceof Error ? urlError.message : 'Unknown error',
                })
                reject(new Error(`Invalid redirect URL: ${location}`))
                return
              }
            }

            let body = ''
            proxyResponse.setEncoding('utf8')
            proxyResponse.on('data', (chunk) => {
              body += chunk
            })
            proxyResponse.on('end', () => {
              // Log response details for debugging problematic endpoints
              if (url.hostname.includes('nostrimg.com')) {
                console.warn('NIP-95 proxy response from nostrimg.com:', {
                  url: url.toString(),
                  statusCode,
                  statusMessage: proxyResponse.statusMessage,
                  responseHeaders: {
                    'content-type': proxyResponse.headers['content-type'],
                    'content-length': proxyResponse.headers['content-length'],
                  },
                  bodyPreview: body.substring(0, 500),
                  bodyLength: body.length,
                  isHtml: body.trim().startsWith('<!DOCTYPE') || body.trim().startsWith('<html') || body.trim().startsWith('<!'),
                })
              }

              resolve({
                statusCode,
                statusMessage: proxyResponse.statusMessage ?? 'Internal Server Error',
                body,
      })
            })
            proxyResponse.on('error', (error) => {
              reject(error)
            })
          })

          // Set timeout on the request
          proxyRequest.setTimeout(30000, () => {
            proxyRequest.destroy()
            reject(new Error('Request timeout after 30 seconds'))
          })

          proxyRequest.on('error', (error) => {
            // Check for DNS errors specifically
            const errorCode = getErrnoCode(error)
            if (errorCode === 'ENOTFOUND' || errorCode === 'EAI_AGAIN') {
              console.error('NIP-95 proxy DNS error:', {
                targetEndpoint,
                hostname: url.hostname,
                errorCode,
                errorMessage: error.message,
                suggestion: 'Check DNS resolution or network connectivity on the server',
              })
              reject(new Error(`DNS resolution failed for ${url.hostname}: ${error.message}`))
            } else {
              reject(error)
            }
          })

          requestFormData.on('error', (error) => {
            console.error('NIP-95 proxy FormData error:', {
              targetEndpoint,
              hostname: url.hostname,
              error: error instanceof Error ? error.message : 'Unknown FormData error',
            })
            reject(error)
          })

          fileStream.on('error', (error) => {
            console.error('NIP-95 proxy file stream error:', {
              targetEndpoint,
              hostname: url.hostname,
              filepath: file.filepath,
              error: error instanceof Error ? error.message : 'Unknown file stream error',
            })
            reject(error)
          })

          requestFormData.pipe(proxyRequest)
        }

        makeRequest(currentUrl, 0, fileField, authToken)
      })
    } catch (requestError) {
      // Clean up temporary file before returning error
      try {
        fs.unlinkSync(fileField.filepath)
      } catch (unlinkError) {
        console.error('Error deleting temp file:', unlinkError)
      }
      const errorMessage = requestError instanceof Error ? requestError.message : 'Unknown request error'
      const isDnsError = errorMessage.includes('DNS resolution failed') || errorMessage.includes('ENOTFOUND') || errorMessage.includes('EAI_AGAIN')

      console.error('NIP-95 proxy request error:', {
        targetEndpoint,
        hostname: currentUrl.hostname,
        error: errorMessage,
        isDnsError,
        fileSize: fileField.size,
        fileName: fileField.originalFilename,
        suggestion: isDnsError ? 'The server cannot resolve the domain name. Check DNS configuration and network connectivity.' : undefined,
      })

      // Return a more specific error message for DNS issues
      if (isDnsError) {
        return res.status(500).json({
          error: `DNS resolution failed for ${currentUrl.hostname}. The server cannot resolve the domain name. Please check DNS configuration and network connectivity.`,
        })
      }

      return res.status(500).json({
        error: `Failed to connect to upload endpoint: ${errorMessage}`,
      })
    }

    // Clean up temporary file
    try {
      fs.unlinkSync(fileField.filepath)
    } catch (unlinkError) {
      console.error('Error deleting temp file:', unlinkError)
    }

    if (response.statusCode < 200 || response.statusCode >= 300) {
      const errorText = response.body.substring(0, 200) // Limit log size
      console.error('NIP-95 proxy response error:', {
        targetEndpoint,
        finalUrl: currentUrl.toString(),
        status: response.statusCode,
        statusText: response.statusMessage,
        errorText,
      })

      // Provide more specific error messages for common HTTP status codes
      let userFriendlyError = errorText || `Upload failed: ${response.statusCode} ${response.statusMessage}`
      if (response.statusCode === 401) {
        userFriendlyError = 'Authentication required. This endpoint requires authorization headers.'
      } else if (response.statusCode === 403) {
        userFriendlyError = 'Access forbidden. This endpoint may require authentication or have restrictions.'
      } else if (response.statusCode === 405) {
        userFriendlyError = 'Method not allowed. This endpoint may not support POST requests or the URL may be incorrect.'
      } else if (response.statusCode === 413) {
        userFriendlyError = 'File too large. The file exceeds the maximum size allowed by this endpoint.'
      } else if (response.statusCode >= 500) {
        userFriendlyError = `Server error (${response.statusCode}). The endpoint server encountered an error.`
      }

      return res.status(response.statusCode).json({
        error: userFriendlyError,
      })
    }

    // Check if response is HTML (error page) instead of JSON
    const trimmedBody = response.body.trim()
    const isHtml = trimmedBody.startsWith('<!DOCTYPE') || trimmedBody.startsWith('<html') || trimmedBody.startsWith('<!')

    if (isHtml) {
      // Try to extract error message from HTML if possible
      const titleMatch = response.body.match(/<title[^>]*>([^<]+)<\/title>/i)
      const h1Match = response.body.match(/<h1[^>]*>([^<]+)<\/h1>/i)
      const errorText = titleMatch?.[1] ?? h1Match?.[1] ?? 'HTML error page returned'

      // Check if it's a 404 or other error page
      const is404 = response.body.includes('404') || response.body.includes('Not Found') || titleMatch?.[1]?.includes('404')
      const is403 = response.body.includes('403') || response.body.includes('Forbidden') || titleMatch?.[1]?.includes('403')
      const is500 = response.body.includes('500') || response.body.includes('Internal Server Error') || titleMatch?.[1]?.includes('500')

      console.error('NIP-95 proxy HTML response error:', {
        targetEndpoint,
        finalUrl: currentUrl.toString(),
        status: response.statusCode,
        errorText,
        is404,
        is403,
        is500,
        bodyPreview: response.body.substring(0, 500),
        contentType: 'HTML (expected JSON)',
        suggestion: is404
          ? 'The endpoint URL may be incorrect or the endpoint does not exist'
          : is403
          ? 'The endpoint may require authentication or have access restrictions'
          : is500
          ? 'The endpoint server encountered an error'
          : 'The endpoint may not be a valid NIP-95 upload endpoint or may require specific headers',
      })

      let userMessage = `Endpoint returned an HTML error page instead of JSON`
      if (is404) {
        userMessage = `Endpoint not found (404). The URL may be incorrect: ${currentUrl.toString()}`
      } else if (is403) {
        userMessage = `Access forbidden (403). The endpoint may require authentication or have restrictions.`
      } else if (is500) {
        userMessage = `Server error (500). The endpoint server encountered an error.`
      } else {
        userMessage = `Endpoint returned an HTML error page instead of JSON. The endpoint may be unavailable, the URL may be incorrect, or specific headers may be required. Error: ${errorText}`
      }

      return res.status(500).json({
        error: userMessage,
      })
    }

    let result: unknown
    try {
      result = JSON.parse(response.body)
    } catch (parseError) {
      const errorMessage = parseError instanceof Error ? parseError.message : 'Invalid JSON response'
      console.error('NIP-95 proxy JSON parse error:', {
        targetEndpoint,
        error: errorMessage,
        bodyPreview: response.body.substring(0, 100),
      })
      return res.status(500).json({
        error: `Invalid upload response: ${errorMessage}. The endpoint may not be a valid NIP-95 upload endpoint.`,
      })
    }

    return res.status(200).json(result)
  } catch (error) {
    console.error('NIP-95 proxy error:', error)
    return res.status(500).json({
      error: error instanceof Error ? error.message : 'Internal server error',
    })
  }
}

function getErrnoCode(error: unknown): string | undefined {
  if (typeof error !== 'object' || error === null) {
    return undefined
  }
  const maybe = error as { code?: unknown }
  return typeof maybe.code === 'string' ? maybe.code : undefined
}