import type { NextApiRequest, NextApiResponse } from "next";
import type { File as FormidableFile } from "formidable";
import formidable from "formidable";
import fs from "fs/promises";
import path from "path";
import { createReport } from "@/lib/pdftron/serverSDK/createReport";

export const config = {
  api: {
    bodyParser: false,
  },
};

// 보안 설정
const SECURITY_CONFIG = {
  ALLOWED_EXTENSIONS: new Set([
    'pdf', 'doc', 'docx', 'xls', 'xlsx', 'ppt', 'pptx',
    'txt', 'csv', 'png', 'jpg', 'jpeg', 'gif', 'bmp', 'webp'
  ]),
  FORBIDDEN_EXTENSIONS: new Set([
    'exe', 'bat', 'cmd', 'scr', 'vbs', 'js', 'jar', 'com', 'pif',
    'msi', 'reg', 'ps1', 'sh', 'php', 'asp', 'jsp', 'py', 'pl',
    'html', 'htm', 'xhtml', 'xml', 'svg'
  ]),
  MAX_FILE_SIZE: 100 * 1024 * 1024, // 100MB
  MAX_FILENAME_LENGTH: 255,
};

// 간단한 보안 검증 함수들
function validateExtension(fileName: string): { valid: boolean; error?: string } {
  const extension = path.extname(fileName).toLowerCase().substring(1);
  
  if (!extension) {
    return { valid: false, error: "파일 확장자가 없습니다" };
  }
  
  if (SECURITY_CONFIG.FORBIDDEN_EXTENSIONS.has(extension)) {
    return { valid: false, error: `금지된 파일 형식입니다: .${extension}` };
  }
  
  if (!SECURITY_CONFIG.ALLOWED_EXTENSIONS.has(extension)) {
    return { valid: false, error: `허용되지 않은 파일 형식입니다: .${extension}` };
  }
  
  return { valid: true };
}

function validateFileName(fileName: string): { valid: boolean; error?: string } {
  if (fileName.length > SECURITY_CONFIG.MAX_FILENAME_LENGTH) {
    return { valid: false, error: "파일명이 너무 깁니다" };
  }
  
  // 위험한 문자 체크
  const dangerousPatterns = [
    /[<>:"'|?*]/,
    /[\x00-\x1f]/,
    /^\./,
    /\.\./,
    /\/|\\$/,
    /javascript:/i,
    /data:/i,
    /vbscript:/i,
    /on\w+=/i,
    /<script/i,
    /<iframe/i,
  ];
  
  for (const pattern of dangerousPatterns) {
    if (pattern.test(fileName)) {
      return { valid: false, error: "안전하지 않은 파일명입니다" };
    }
  }
  
  return { valid: true };
}

function validateFileSize(size: number): { valid: boolean; error?: string } {
  if (size <= 0) {
    return { valid: false, error: "파일이 비어있습니다" };
  }
  
  if (size > SECURITY_CONFIG.MAX_FILE_SIZE) {
    const maxSizeMB = Math.round(SECURITY_CONFIG.MAX_FILE_SIZE / (1024 * 1024));
    return { valid: false, error: `파일 크기가 너무 큽니다 (최대 ${maxSizeMB}MB)` };
  }
  
  return { valid: true };
}

function validateDirectory(directory: string): { valid: boolean; error?: string } {
  const normalizedDir = path.normalize(directory).replace(/^\/+/, '');
  
  // 경로 탐색 공격 방지
  if (normalizedDir.includes('..') || normalizedDir.includes('//')) {
    return { valid: false, error: "안전하지 않은 디렉터리 경로입니다" };
  }
  
  // 절대 경로 검증 (단, 허용된 웹 경로 패턴은 제외)
  const allowedPatterns = [
    /^\/api\/files\//,           // 운영 환경: /api/files/vendorFormData/...
    /^\/vendorFormData\//,       // 개발 환경: /vendorFormData/...
    /^\/[\w-]+\//,               // 기타 상대 웹 경로: /directory/...
  ];
  
  const isAllowedWebPath = allowedPatterns.some(pattern => pattern.test(directory));
  
  // Windows 절대 경로(C:\...) 또는 허용되지 않은 Unix 절대 경로 차단
  if (path.isAbsolute(directory) && !isAllowedWebPath) {
    return { valid: false, error: "절대 파일 시스템 경로는 사용할 수 없습니다" };
  }
  
  return { valid: true };
}

async function validateFileContent(buffer: Buffer, fileName: string): Promise<{ valid: boolean; error?: string }> {
  try {
    // 실행 파일 패턴 검색
    const executablePatterns = [
      Buffer.from([0x4D, 0x5A]), // MZ (Windows executable)
      Buffer.from([0x7F, 0x45, 0x4C, 0x46]), // ELF (Linux executable)
    ];
    
    for (const pattern of executablePatterns) {
      if (buffer.subarray(0, pattern.length).equals(pattern)) {
        return { valid: false, error: "실행 파일은 업로드할 수 없습니다" };
      }
    }
    
    // 텍스트 기반 파일의 XSS 패턴 검사
    const textBasedExtensions = ['txt', 'csv', 'xml'];
    const extension = path.extname(fileName).toLowerCase().substring(1);
    
    if (textBasedExtensions.includes(extension)) {
      const content = buffer.toString('utf8', 0, Math.min(buffer.length, 8192));
      
      const xssPatterns = [
        /<script[\s\S]*?>/i,
        /<iframe[\s\S]*?>/i,
        /on\w+\s*=\s*["'][^"']*["']/i,
        /javascript\s*:/i,
        /vbscript\s*:/i,
        /data\s*:\s*text\/html/i,
      ];
      
      for (const pattern of xssPatterns) {
        if (pattern.test(content)) {
          return { valid: false, error: "파일에 잠재적으로 위험한 스크립트가 포함되어 있습니다" };
        }
      }
    }
    
    return { valid: true };
  } catch (error) {
    console.error("파일 내용 검증 오류:", error);
    return { valid: false, error: "파일 내용을 검증할 수 없습니다" };
  }
}

function validateReportData(reportDatas: any[]): { valid: boolean; error?: string } {
  try {
    if (!Array.isArray(reportDatas)) {
      return { valid: false, error: "리포트 데이터는 배열이어야 합니다" };
    }

    if (reportDatas.length === 0) {
      return { valid: false, error: "리포트 데이터가 비어있습니다" };
    }

    // 데이터 개수 제한 (DoS 방지)
    if (reportDatas.length > 1000) {
      return { valid: false, error: "리포트 데이터가 너무 많습니다 (최대 1000개)" };
    }

    // 각 데이터 항목 검증
    for (let i = 0; i < reportDatas.length; i++) {
      const item = reportDatas[i];
      
      if (typeof item !== 'object' || item === null) {
        return { valid: false, error: `리포트 데이터 ${i + 1}번째 항목이 유효하지 않습니다` };
      }

      // 객체 크기 제한
      const itemString = JSON.stringify(item);
      if (itemString.length > 50000) { // 50KB per item
        return { valid: false, error: `리포트 데이터 ${i + 1}번째 항목이 너무 큽니다` };
      }

      // XSS 방지 검증
      const dangerousPatterns = [
        /<script[\s\S]*?>/i,
        /<iframe[\s\S]*?>/i,
        /javascript\s*:/i,
        /vbscript\s*:/i,
        /on\w+\s*=/i,
      ];

      for (const pattern of dangerousPatterns) {
        if (pattern.test(itemString)) {
          return { valid: false, error: `리포트 데이터에 잠재적으로 위험한 스크립트가 포함되어 있습니다` };
        }
      }
    }

    return { valid: true };
  } catch (error) {
    return { valid: false, error: "리포트 데이터 검증 중 오류가 발생했습니다" };
  }
}

// 보안이 강화된 DRM 복호화 함수
async function decryptBufferWithDRM(buffer: Buffer, originalFileName: string): Promise<Buffer> {
  try {
    // 1. 기본 보안 검증
    const extensionCheck = validateExtension(originalFileName);
    if (!extensionCheck.valid) {
      console.error(`🚨 파일 확장자 보안 위반: ${originalFileName} - ${extensionCheck.error}`);
      throw new Error(extensionCheck.error);
    }

    const fileNameCheck = validateFileName(originalFileName);
    if (!fileNameCheck.valid) {
      console.error(`🚨 파일명 보안 위반: ${originalFileName} - ${fileNameCheck.error}`);
      throw new Error(fileNameCheck.error);
    }

    const sizeCheck = validateFileSize(buffer.length);
    if (!sizeCheck.valid) {
      console.error(`🚨 파일 크기 보안 위반: ${originalFileName} - ${sizeCheck.error}`);
      throw new Error(sizeCheck.error);
    }

    // 2. 파일 내용 기본 검증
    const contentCheck = await validateFileContent(buffer, originalFileName);
    if (!contentCheck.valid) {
      console.error(`🚨 파일 내용 보안 위반: ${originalFileName} - ${contentCheck.error}`);
      throw new Error(contentCheck.error);
    }

    console.log(`✅ 보안 검증 완료: ${originalFileName}`);

    // 3. DRM 복호화 진행
    const blob = new Blob([buffer]);
    const file = new File([blob], originalFileName);
    
    const formData = new FormData();
    formData.append('file', file);

    const backendUrl = "http://localhost:6543/api/drm-proxy/decrypt";
        
    console.log(`[DRM] 서버에서 파일 복호화 시도: ${originalFileName} (크기: ${buffer.length} bytes)`);
        
    const response = await fetch(backendUrl, {
      method: "POST",
      body: formData,
    });

    if (!response.ok) {
      const errorText = await response.text().catch(() => '응답 텍스트를 가져올 수 없음');
      throw new Error(`DRM 서버 응답 오류 [${response.status}]: ${errorText}`);
    }

    const arrayBuffer = await response.arrayBuffer();
    const decryptedBuffer = Buffer.from(arrayBuffer);
    
    // 4. 복호화된 파일 재검증
    const decryptedContentCheck = await validateFileContent(decryptedBuffer, originalFileName);
    if (!decryptedContentCheck.valid) {
      console.warn(`⚠️ 복호화된 파일 내용 경고: ${originalFileName} - ${decryptedContentCheck.error}`);
      // DRM 파일은 내용이 변형될 수 있으므로 경고만 하고 계속 진행
    }
    
    console.log(`[DRM] 서버에서 파일 복호화 성공: ${originalFileName} (결과 크기: ${decryptedBuffer.length} bytes)`);
        
    return decryptedBuffer;
    
  } catch (error) {
    const errorMessage = error instanceof Error 
      ? `${error.name}: ${error.message}` 
      : String(error);
        
    console.error(`[DRM] 서버 복호화 오류: ${errorMessage}`, {
      fileName: originalFileName,
      fileSize: buffer.length,
      remark: `
        [정상 동작 안내]
        DTS 개발 서버나 로컬 환경에서는 에러가 발생하는 것이 정상적인 동작입니다.
        이 경우 원본 파일 버퍼가 그대로 반환됩니다.

        [발생 가능한 에러 케이스]
        1. DRM 백엔드 서버가 없는 경우 - CONNECTION_REJECTED 발생
        2. DRM 중앙 서버와 통신 불가한 경우 - PARENT CERT 속성 추가 불가로 인한 백엔드측 500 에러
        3. 보안 검증 실패 - 파일 형식, 크기, 내용 검증 오류
      `,
      error
    });

    // 보안 검증 실패인 경우 원본도 반환하지 않음
    if (errorMessage.includes('보안') || errorMessage.includes('위반') || errorMessage.includes('금지된') || errorMessage.includes('허용되지')) {
      throw error; // 보안 오류는 재throw
    }
        
    return buffer; // 일반적인 DRM 오류는 원본 버퍼 반환 (폴백)
  }
}

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

  // 요청 ID 생성 (로깅용)
  const requestId = `req_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
  console.log(`🚀 [${requestId}] 리포트 생성 요청 시작`);

  try {
    const form = formidable({ 
      multiples: false,
      maxFileSize: SECURITY_CONFIG.MAX_FILE_SIZE,
      maxFieldsSize: 10 * 1024 * 1024, // 10MB 필드 크기 제한
      maxFields: 50, // 최대 필드 수 제한
    });

    form.parse(req, async (err, fields, files) => {
      if (err) {
        console.error(`❌ [${requestId}] Form parsing 오류:`, err);
        return res.status(500).json({ 
          error: "파일 업로드 처리 중 오류가 발생했습니다",
          requestId 
        });
      }

      try {
        const fileName = fields?.customFileName?.[0] ?? "";
        const reportTempPath = fields?.reportTempPath?.[0] ?? "";
        const reportCoverPage: FormidableFile | undefined = files?.file?.[0];

        // 1. 기본 필드 검증
        if (!reportCoverPage || fileName.length === 0 || reportTempPath.length === 0) {
          return res.status(400).json({ 
            error: "필수 데이터가 누락되었습니다",
            requestId 
          });
        }

        // 2. 파일명 보안 검증
        const fileNameCheck = validateFileName(fileName);
        if (!fileNameCheck.valid) {
          console.error(`🚨 [${requestId}] 출력 파일명 보안 위반:`, fileNameCheck.error);
          return res.status(400).json({ 
            error: `출력 파일명 오류: ${fileNameCheck.error}`,
            requestId 
          });
        }

        // 3. 템플릿 경로 보안 검증
        const dirCheck = validateDirectory(reportTempPath);
        if (!dirCheck.valid) {
          console.error(`🚨 [${requestId}] 템플릿 경로 보안 위반:`, dirCheck.error);
          return res.status(400).json({ 
            error: `템플릿 경로 오류: ${dirCheck.error}`,
            requestId 
          });
        }

        // 4. 리포트 데이터 파싱 및 검증
        let reportDatas: any[];
        try {
          const reportDataString = fields?.reportDatas?.[0] ?? "[]";
          reportDatas = JSON.parse(reportDataString);
        } catch (parseError) {
          console.error(`❌ [${requestId}] 리포트 데이터 파싱 오류:`, parseError);
          return res.status(400).json({ 
            error: "리포트 데이터 형식이 올바르지 않습니다",
            requestId 
          });
        }

        const dataValidation = validateReportData(reportDatas);
        if (!dataValidation.valid) {
          console.error(`🚨 [${requestId}] 리포트 데이터 보안 위반:`, dataValidation.error);
          return res.status(400).json({ 
            error: `리포트 데이터 오류: ${dataValidation.error}`,
            requestId 
          });
        }

        console.log(`✅ [${requestId}] 모든 보안 검증 완료 - 파일 처리 시작`);

        // 5. 원본 파일 읽기
        const originalBuffer = await fs.readFile(reportCoverPage.filepath);
        
        // 6. DRM 복호화 처리 (보안 검증 포함)
        console.log(`🔐 [${requestId}] DRM 복호화 시작: ${reportCoverPage.originalFilename || 'unknown'}`);
        const decryptedBuffer = await decryptBufferWithDRM(
          originalBuffer, 
          reportCoverPage.originalFilename || 'document.docx'
        );

        // 7. 복호화된 버퍼로 리포트 생성
        console.log(`📄 [${requestId}] 리포트 생성 시작`);
        const {
          result,
          buffer: pdfBuffer,
          error,
        } = await createReport(decryptedBuffer, reportTempPath, reportDatas);

        if (result && pdfBuffer) {
          console.log(`✅ [${requestId}] 리포트 생성 성공: ${fileName}`);

          // 보안 헤더 설정
          res.setHeader("Content-Type", "application/pdf");
          res.setHeader("Content-Disposition", `attachment; filename="${fileName}"`);
          res.setHeader("X-Content-Type-Options", "nosniff");
          res.setHeader("X-Frame-Options", "DENY");
          res.setHeader("Cache-Control", "no-cache, no-store, must-revalidate");

          return res.send(Buffer.from(pdfBuffer));
        }

        console.error(`❌ [${requestId}] 리포트 생성 실패:`, error);
        return res.status(500).json({
          success: false,
          message: "리포트 생성에 실패하였습니다.",
          error,
          requestId,
        });

      } catch (e) {
        console.error(`❌ [${requestId}] 처리 중 오류:`, e);
        
        // 보안 오류와 일반 오류 구분
        const errorMessage = e instanceof Error ? e.message : "처리 중 오류가 발생했습니다";
        const isSecurityError = errorMessage.includes('보안') || errorMessage.includes('위반') || 
                               errorMessage.includes('금지된') || errorMessage.includes('허용되지');
        
        return res.status(isSecurityError ? 400 : 500).json({ 
          error: isSecurityError ? errorMessage : "처리 중 오류가 발생했습니다",
          requestId 
        });
      }
    });
  } catch (err) {
    console.error(`❌ [${requestId}] 전역 오류:`, err);
    return res.status(500).json({ 
      error: "서버 내부 오류가 발생했습니다",
      requestId 
    });
  }
}