/**
 * 메일 라우터
 * 메일 CRUD, 읽음/별표 처리, 휴지통 관리, 첨부파일 다운로드 등
 */
const express = require("express");
const router = express.Router();
const { Op } = require("sequelize");
const sequelize = require("../config/database");
const SentLog = require("../models/SentLog");
const SystemConfig = require("../models/SystemConfig");
const User = require("../models/User");
const { getObjectStream } = require("../services/s3Service");
const { sendEmail } = require("../services/emailService");
const sseService = require("../services/sseService");
const { authenticateToken } = require("../middleware/auth");
const jwt = require("jsonwebtoken");

// 공통 헬퍼 함수 import
const {
  getModel,
  normalizeEmail,
  calculateStorageSize,
  findEmail,
  safeRollback,
  MAILBOX_MODELS,
} = require("../utils/helpers");
const { calculateEmailSize } = require("../utils/emailUtils");

// 자주 사용하는 모델 destructuring
const {
  INBOX: Inbox,
  SENT: Sent,
  TRASH: Trash,
  SPAM: Spam,
  DRAFTS: Draft,
  IMPORTANT: Important,
} = MAILBOX_MODELS;

/**
 * SSE - 실시간 메일 알림 (인증 미들웨어 전에 배치)
 */
router.get("/events", (req, res) => {
  // 쿼리 파라미터에서 토큰 확인
  const token = req.query.token;

  if (!token) {
    return res.status(401).json({ error: "토큰이 필요합니다" });
  }

  try {
    // 토큰 검증
    jwt.verify(token, process.env.JWT_SECRET || "your-secret-key");

    // SSE 헤더 설정
    res.setHeader("Content-Type", "text/event-stream");
    res.setHeader("Cache-Control", "no-cache");
    res.setHeader("Connection", "keep-alive");
    res.setHeader("Access-Control-Allow-Origin", "*");

    // 연결 유지 메시지
    res.write('data: {"type":"connected"}\n\n');

    // 클라이언트 추가
    sseService.addClient(res);

    // 연결 종료 시 클라이언트 제거
    req.on("close", () => {
      sseService.removeClient(res);
    });
  } catch (error) {
    return res.status(401).json({ error: "유효하지 않은 토큰입니다" });
  }
});

// 모든 라우트에 인증 미들웨어 적용
router.use(authenticateToken);

// ============================================================================
// Gemini 번역 API (로그인 사용자 모두 사용 가능)
// ============================================================================

const geminiService = require("../services/geminiService");
const EmailTranslation = require("../models/EmailTranslation");

/**
 * Gemini 현재 모델명 조회 (일반 사용자용)
 * GET /api/emails/gemini-model
 */
router.get("/emails/gemini-model", async (req, res) => {
  try {
    const config = await geminiService.getGeminiConfig();
    const modelInfo = config.models?.find((m) => m.id === config.gemini_model);
    res.json({
      modelId: config.gemini_model,
      modelName: modelInfo?.name || config.gemini_model || "Gemini AI",
    });
  } catch (error) {
    res.json({ modelId: "", modelName: "Gemini AI" });
  }
});

/**
 * Gemini 번역 (캐시 지원)
 * POST /api/emails/translate
 * Body: { emailId, mailbox, text, targetLang }
 */
router.post("/emails/translate", async (req, res) => {
  try {
    const { emailId, mailbox, text, targetLang } = req.body;
    const lang = targetLang || "ko";

    if (!text) {
      return res.status(400).json({ error: "번역할 텍스트가 필요합니다" });
    }

    // emailId와 mailbox가 있으면 캐시 확인
    if (emailId && mailbox) {
      const cached = await EmailTranslation.findOne({
        where: { emailId, mailbox, targetLang: lang },
      });

      if (cached) {
        return res.json({
          translatedText: cached.translatedContent,
          cached: true,
          modelName: cached.modelUsed || "Gemini AI",
        });
      }
    }

    // 캐시가 없으면 번역 실행
    const config = await geminiService.getGeminiConfig();
    if (!config.gemini_api_key) {
      return res.status(400).json({
        error: "Gemini API 키가 설정되지 않았습니다. 관리자에게 문의하세요.",
      });
    }

    const translatedText = await geminiService.translateText(
      text,
      lang,
      config.gemini_api_key,
      config.gemini_model
    );

    // 번역 결과 캐시 저장 (emailId, mailbox가 있을 때만)
    if (emailId && mailbox) {
      await EmailTranslation.upsert({
        emailId,
        mailbox,
        targetLang: lang,
        translatedContent: translatedText,
        modelUsed: config.gemini_model,
      });
    }

    // 모델명 조회
    const modelInfo = config.models?.find((m) => m.id === config.gemini_model);
    const modelName = modelInfo?.name || config.gemini_model;

    res.json({ translatedText, cached: false, modelName });
  } catch (error) {
    console.error("번역 오류:", error);
    res.status(500).json({ error: error.message || "번역 실패" });
  }
});

// ============================================================================
// API 라우트
// ============================================================================

/**
 * 메일함별 개수 및 스토리지 사용량 조회
 * GET /api/emails/counts
 */
router.get("/emails/counts", async (req, res) => {
  try {
    const userEmail = req.user.email;

    // 각 메일함 개수 병렬 조회
    const [inboxC, sentC, trashC, spamC, draftsC, importantC] =
      await Promise.all([
        Inbox.count({
          where: { to: { [Op.like]: `%${userEmail}%` }, isDeleted: false },
        }),
        Sent.count({ where: { from: userEmail, isDeleted: false } }),
        Trash.count({
          where: {
            [Op.or]: [
              { from: userEmail },
              { to: { [Op.like]: `%${userEmail}%` } },
            ],
          },
        }),
        Spam.count({
          where: { to: { [Op.like]: `%${userEmail}%` }, isDeleted: false },
        }),
        Draft.count({ where: { from: userEmail, isDeleted: false } }),
        Important.count({
          where: {
            [Op.or]: [
              { from: userEmail },
              { to: { [Op.like]: `%${userEmail}%` } },
            ],
          },
        }),
      ]);

    // 스토리지 사용량 계산 (전체 시스템)
    const [inboxItems, sentItems] = await Promise.all([
      Inbox.findAll({ attributes: ["attachments", "subject", "text", "html"] }),
      Sent.findAll({ attributes: ["attachments", "subject", "text", "html"] }),
    ]);

    const totalSize =
      calculateStorageSize(inboxItems) + calculateStorageSize(sentItems);
    const storageUsedMB = (totalSize / (1024 * 1024)).toFixed(2);

    // 쿼터 설정 가져오기 (기본값 50GB)
    const quotaConfig = await SystemConfig.findOne({
      where: { key: "user_storage_quota" },
    });
    const storageLimit = quotaConfig ? parseInt(quotaConfig.value) : 51200;

    res.json({
      INBOX: inboxC,
      SENT: sentC,
      TRASH: trashC,
      SPAM: spamC,
      DRAFTS: draftsC,
      IMPORTANT: importantC,
      storageUsed: storageUsedMB,
      storageLimit: storageLimit,
    });
  } catch (error) {
    console.error("메일함 개수 조회 오류:", error);
    res.status(500).json({ error: "개수 조회 실패" });
  }
});

/**
 * 메일 검색 (상세 필터 지원)
 * GET /api/emails/search
 * 쿼리 파라미터:
 *   - q: 기본 검색어
 *   - scope: 검색 범위 (ALL|INBOX|SENT|...)
 *   - from: 발신자 필터
 *   - to: 수신자 필터
 *   - subject: 제목 필터
 *   - includes: 포함 키워드
 *   - excludes: 제외 키워드
 *   - minSize: 최소 크기 (bytes)
 *   - maxSize: 최대 크기 (bytes)
 *   - dateAfter: 이후 날짜 (YYYY-MM-DD)
 *   - dateBefore: 이전 날짜 (YYYY-MM-DD)
 *   - hasAttachment: 첨부파일 유무 (true/false)
 */
router.get("/emails/search", async (req, res) => {
  try {
    const {
      q,
      scope = "ALL",
      from: fromFilter,
      to: toFilter,
      subject: subjectFilter,
      includes,
      excludes,
      minSize,
      maxSize,
      dateAfter,
      dateBefore,
      hasAttachment,
      page = 1,
      limit = 50,
    } = req.query;
    const userEmail = req.user.email;

    // 최소한 하나의 검색 조건이 필요
    const hasAnyFilter =
      q ||
      fromFilter ||
      toFilter ||
      subjectFilter ||
      includes ||
      minSize ||
      maxSize ||
      dateAfter ||
      dateBefore ||
      hasAttachment;
    if (!hasAnyFilter) {
      return res.json({ emails: [], total: 0, page: 1, totalPages: 0 });
    }

    const searchQuery = q ? q.trim() : "";
    const pageNum = parseInt(page) || 1;
    const limitNum = parseInt(limit) || 50;
    const offset = (pageNum - 1) * limitNum;

    // 검색할 메일함 결정
    const mailboxesToSearch =
      scope === "ALL"
        ? ["INBOX", "SENT", "DRAFTS", "SPAM", "TRASH", "IMPORTANT"]
        : [scope.toUpperCase()];

    let allResults = [];

    // 각 메일함에서 검색
    for (const box of mailboxesToSearch) {
      const Model = getModel(box);
      if (!Model) continue;

      // 사용자별 기본 필터
      let userFilter = {};
      if (box === "INBOX" || box === "SPAM") {
        userFilter.to = { [Op.like]: `%${userEmail}%` };
      } else if (box === "SENT" || box === "DRAFTS") {
        userFilter.from = userEmail;
      } else {
        userFilter[Op.or] = [
          { from: userEmail },
          { to: { [Op.like]: `%${userEmail}%` } },
        ];
      }

      // 검색 조건 배열
      const andConditions = [];

      // 기본 검색어 (제목, 발신자, 수신자, 본문 검색)
      if (searchQuery) {
        andConditions.push({
          [Op.or]: [
            { subject: { [Op.like]: `%${searchQuery}%` } },
            { from: { [Op.like]: `%${searchQuery}%` } },
            { fromName: { [Op.like]: `%${searchQuery}%` } },
            { to: { [Op.like]: `%${searchQuery}%` } },
            { text: { [Op.like]: `%${searchQuery}%` } },
            { html: { [Op.like]: `%${searchQuery}%` } },
          ],
        });
      }

      // 발신자 필터
      if (fromFilter) {
        andConditions.push({
          [Op.or]: [
            { from: { [Op.like]: `%${fromFilter}%` } },
            { fromName: { [Op.like]: `%${fromFilter}%` } },
          ],
        });
      }

      // 수신자 필터
      if (toFilter) {
        andConditions.push({ to: { [Op.like]: `%${toFilter}%` } });
      }

      // 제목 필터
      if (subjectFilter) {
        andConditions.push({ subject: { [Op.like]: `%${subjectFilter}%` } });
      }

      // 포함 키워드
      if (includes) {
        andConditions.push({
          [Op.or]: [
            { text: { [Op.like]: `%${includes}%` } },
            { html: { [Op.like]: `%${includes}%` } },
            { subject: { [Op.like]: `%${includes}%` } },
          ],
        });
      }

      // 날짜 필터
      if (dateAfter) {
        andConditions.push({ date: { [Op.gte]: new Date(dateAfter) } });
      }
      if (dateBefore) {
        andConditions.push({
          date: { [Op.lte]: new Date(dateBefore + "T23:59:59") },
        });
      }

      const where = {
        ...userFilter,
        isDeleted: false,
      };

      if (andConditions.length > 0) {
        where[Op.and] = andConditions;
      }

      let results = await Model.findAll({
        where,
        order: [["date", "DESC"]],
      });

      // 제외 키워드 (메모리에서 필터링)
      if (excludes) {
        const excludeTerms = excludes.toLowerCase();
        results = results.filter((email) => {
          const content = `${email.subject || ""} ${email.text || ""} ${
            email.html || ""
          }`.toLowerCase();
          return !content.includes(excludeTerms);
        });
      }

      // 크기 필터 (DB size 컬럼 우선 사용, 없는 메일은 메모리에서 계산)
      if (minSize || maxSize) {
        const minBytes = minSize ? parseInt(minSize) : 0;
        const maxBytes = maxSize ? parseInt(maxSize) : Infinity;

        results = results.filter((email) => {
          // size 컬럼이 있으면 사용
          if (
            email.size !== null &&
            email.size !== undefined &&
            email.size > 0
          ) {
            return email.size >= minBytes && email.size <= maxBytes;
          }

          // size 컬럼이 없는 기존 메일은 메모리에서 계산 (fallback)
          let size = 0;
          if (email.subject) size += Buffer.byteLength(email.subject, "utf8");
          if (email.text) size += Buffer.byteLength(email.text, "utf8");
          if (email.html) size += Buffer.byteLength(email.html, "utf8");

          try {
            const atts =
              typeof email.attachments === "string"
                ? JSON.parse(email.attachments)
                : email.attachments || [];
            atts.forEach((att) => {
              size += att.size || 0;
            });
          } catch {}

          return size >= minBytes && size <= maxBytes;
        });
      }

      // 첨부파일 필터 (메모리에서 필터링)
      if (hasAttachment === "true") {
        results = results.filter((email) => {
          try {
            const atts =
              typeof email.attachments === "string"
                ? JSON.parse(email.attachments)
                : email.attachments || [];
            return Array.isArray(atts) && atts.length > 0;
          } catch {
            return false;
          }
        });
      }

      // 메일함 정보 추가
      results.forEach((email) => {
        const normalized = normalizeEmail(email, box);
        normalized.mailbox = box;
        allResults.push(normalized);
      });
    }

    // 날짜순 정렬
    allResults.sort((a, b) => new Date(b.date) - new Date(a.date));

    // 페이징
    const total = allResults.length;
    const paged = allResults.slice(offset, offset + limitNum);

    res.json({
      emails: paged,
      total,
      page: pageNum,
      totalPages: Math.ceil(total / limitNum),
      query: searchQuery,
      scope,
    });
  } catch (error) {
    console.error("메일 검색 오류:", error);
    res.status(500).json({ error: "검색 실패" });
  }
});

/**
 * 메일 목록 조회 (페이징)
 * GET /api/emails?mailbox=INBOX&page=1&limit=20
 */
router.get("/emails", async (req, res) => {
  try {
    const { mailbox = "INBOX", page = 1, limit = 20 } = req.query;
    const Model = getModel(mailbox);
    const userEmail = req.user.email;

    const pageNum = parseInt(page) || 1;
    const limitNum = parseInt(limit) || 20;
    const offset = (pageNum - 1) * limitNum;

    // 사용자별 필터링 조건
    let where = { isDeleted: false };
    if (mailbox === "INBOX" || mailbox === "SPAM") {
      where.to = { [Op.like]: `%${userEmail}%` };
    } else if (mailbox === "SENT" || mailbox === "DRAFTS") {
      where.from = userEmail;
    } else {
      where[Op.or] = [
        { from: userEmail },
        { to: { [Op.like]: `%${userEmail}%` } },
      ];
    }

    const { count, rows } = await Model.findAndCountAll({
      where,
      order: [["date", "DESC"]],
      limit: limitNum,
      offset: offset,
    });

    res.json({
      emails: rows.map((e) => normalizeEmail(e, mailbox)),
      total: count,
      page: pageNum,
      totalPages: Math.ceil(count / limitNum),
    });
  } catch (error) {
    console.error("메일 목록 조회 오류:", error);
    res.status(500).json({ error: "메일 조회 실패" });
  }
});

/**
 * 메일 상세 조회
 * GET /api/emails/:id?mailbox=INBOX
 */
router.get("/emails/:id", async (req, res) => {
  try {
    const { mailbox } = req.query;
    const result = await findEmail(req.params.id, req.user.email, mailbox);
    if (!result) return res.status(404).json({ error: "메일 찾기 실패" });

    res.json(normalizeEmail(result.email, result.box));
  } catch (error) {
    console.error("메일 상세 조회 오류:", error);
    res.status(500).json({ error: "오류" });
  }
});

/**
 * 읽음 처리
 * PATCH /api/emails/:id/read?mailbox=INBOX
 */
router.patch("/emails/:id/read", async (req, res) => {
  try {
    const { mailbox } = req.query;
    const result = await findEmail(req.params.id, req.user.email, mailbox);
    if (!result) return res.status(404).json({ error: "메일 찾기 실패" });

    result.email.isRead = true;

    // \\Seen 플래그 추가
    let flags = result.email.flags || [];
    if (typeof flags === "string") {
      try {
        flags = JSON.parse(flags);
      } catch {
        flags = [];
      }
    }
    if (!Array.isArray(flags)) flags = [];
    if (!flags.includes("\\Seen")) {
      flags.push("\\Seen");
    }
    result.email.flags = JSON.stringify(flags);

    await result.email.save();
    res.json({ success: true });
  } catch (error) {
    console.error("읽음 처리 오류:", error);
    res.status(500).json({ error: "오류" });
  }
});

/**
 * 안읽음 처리
 * PATCH /api/emails/:id/unread?mailbox=INBOX
 */
router.patch("/emails/:id/unread", async (req, res) => {
  try {
    const { mailbox } = req.query;
    const result = await findEmail(req.params.id, req.user.email, mailbox);
    if (!result) return res.status(404).json({ error: "메일 찾기 실패" });

    result.email.isRead = false;

    // \Seen 플래그 제거
    let flags = result.email.flags || [];
    if (typeof flags === "string") {
      try {
        flags = JSON.parse(flags);
      } catch {
        flags = [];
      }
    }
    if (!Array.isArray(flags)) flags = [];
    result.email.flags = JSON.stringify(flags.filter((f) => f !== "\\Seen"));

    await result.email.save();
    res.json({ success: true });
  } catch (error) {
    console.error("안읽음 처리 오류:", error);
    res.status(500).json({ error: "오류" });
  }
});

/**
 * 별표(중요) 토글 - 이동 방식
 * PATCH /api/emails/:id/star?mailbox=INBOX
 * - 별표 추가: 원본 메일함 → Important로 이동
 * - 별표 해제: Important → 원래 메일함으로 이동
 */
router.patch("/emails/:id/star", async (req, res) => {
  const t = await sequelize.transaction();
  try {
    const { mailbox } = req.query;
    const result = await findEmail(req.params.id, req.user.email, mailbox);
    if (!result) {
      await safeRollback(t);
      return res.status(404).json({ error: "메일 찾기 실패" });
    }

    const { email, box } = result;

    // flags 파싱
    let flags = email.flags || [];
    if (typeof flags === "string") {
      try {
        flags = JSON.parse(flags);
      } catch {
        flags = [];
      }
    }
    if (!Array.isArray(flags)) flags = [];

    const isFlagged = flags.includes("\\Flagged");

    if (box === "IMPORTANT") {
      // 중요편지함에서 별표 해제 → 원래 메일함으로 복원
      flags = flags.filter((f) => f !== "\\Flagged");

      const originalBox = email.originalMailbox || "INBOX";
      const TargetModel = getModel(originalBox);

      // 원래 메일함으로 복사
      const emailData = email.toJSON();
      delete emailData.id;
      delete emailData.originalMailbox;
      emailData.flags = flags;
      const newEmail = await TargetModel.create(emailData, { transaction: t });

      // Important에서 삭제
      await email.destroy({ transaction: t });

      await t.commit();
      res.json({
        success: true,
        starred: false,
        movedTo: originalBox.toLowerCase(),
        newEmailId: newEmail.id,
      });
    } else {
      // 다른 메일함에서 별표 추가 → Important로 이동
      flags.push("\\Flagged");

      // Important로 복사
      const emailData = email.toJSON();
      delete emailData.id;
      emailData.originalMailbox = box;
      emailData.flags = flags;
      const newEmail = await Important.create(emailData, { transaction: t });

      // 원본 삭제
      await email.destroy({ transaction: t });

      await t.commit();
      res.json({
        success: true,
        starred: true,
        movedTo: "important",
        newEmailId: newEmail.id,
      });
    }
  } catch (error) {
    await safeRollback(t);
    console.error("별표 처리 오류:", error);
    res.status(500).json({ error: "오류" });
  }
});

/**
 * 휴지통으로 이동 (트랜잭션 사용)
 * PATCH /api/emails/:id/trash?mailbox=INBOX
 */
router.patch("/emails/:id/trash", async (req, res) => {
  const t = await sequelize.transaction();
  try {
    const { mailbox } = req.query;
    const result = await findEmail(req.params.id, req.user.email, mailbox);
    if (!result) {
      await safeRollback(t);
      return res.status(404).json({ error: "메일 찾기 실패" });
    }

    const { email, box } = result;
    if (box === "TRASH") {
      await safeRollback(t);
      return res.json({ success: true });
    }

    // 휴지통으로 복사
    const emailData = email.toJSON();
    delete emailData.id;
    emailData.originalMailbox = box;
    if (emailData.isRead === undefined) emailData.isRead = true;

    const trashEmail = await Trash.create(emailData, { transaction: t });
    await email.destroy({ transaction: t });

    await t.commit();
    res.json({ success: true, trashId: trashEmail.id });
  } catch (error) {
    await safeRollback(t);
    console.error("휴지통 이동 오류:", error);
    res.status(500).json({ error: "휴지통 이동 실패" });
  }
});

/**
 * 휴지통에서 복구 (트랜잭션 사용)
 * PATCH /api/emails/:id/restore?mailbox=TRASH
 */
router.patch("/emails/:id/restore", async (req, res) => {
  const t = await sequelize.transaction();
  try {
    const { mailbox } = req.query;
    const result = await findEmail(
      req.params.id,
      req.user.email,
      mailbox || "TRASH"
    );

    if (!result || result.box !== "TRASH") {
      await safeRollback(t);
      return res.status(404).json({ error: "휴지통에서 찾을 수 없음" });
    }

    const { email } = result;
    const targetBox = email.originalMailbox || "INBOX";
    const TargetModel = getModel(targetBox);

    const emailData = email.toJSON();
    delete emailData.id;
    delete emailData.originalMailbox;
    if (emailData.isRead === undefined) emailData.isRead = true;

    await TargetModel.create(emailData, { transaction: t });
    await email.destroy({ transaction: t });

    await t.commit();
    res.json({ success: true });
  } catch (error) {
    await safeRollback(t);
    console.error("복구 오류:", error);
    res.status(500).json({ error: "복구 실패" });
  }
});

/**
 * 스팸함으로 이동 (트랜잭션 사용) + rspamd 학습
 * PATCH /api/emails/:id/spam?mailbox=INBOX
 */
router.patch("/emails/:id/spam", async (req, res) => {
  const t = await sequelize.transaction();
  try {
    const { mailbox } = req.query;
    const result = await findEmail(req.params.id, req.user.email, mailbox);
    if (!result) {
      await safeRollback(t);
      return res.status(404).json({ error: "메일 찾기 실패" });
    }

    const { email, box } = result;
    if (box === "SPAM") {
      await safeRollback(t);
      return res.json({ success: true });
    }

    // rspamd 스팸 학습 (원본 이메일이 있는 경우)
    try {
      const rspamd = require("../services/rspamdService");
      const rawEmail = email.rawEmail || rspamd.buildRawEmail(email.toJSON());
      await rspamd.learnSpam(rawEmail);
      console.log(`[rspamd] 스팸 학습 완료: ${email.subject}`);
    } catch (rspamdError) {
      console.warn("[rspamd] 스팸 학습 실패 (무시):", rspamdError.message);
    }

    // 스팸함으로 복사
    const emailData = email.toJSON();
    delete emailData.id;
    emailData.originalMailbox = box;
    if (emailData.isRead === undefined) emailData.isRead = true;

    const spamEmail = await Spam.create(emailData, { transaction: t });
    await email.destroy({ transaction: t });

    await t.commit();
    res.json({ success: true, spamId: spamEmail.id, learned: true });
  } catch (error) {
    await safeRollback(t);
    console.error("스팸함 이동 오류:", error);
    res.status(500).json({ error: "스팸함 이동 실패" });
  }
});

/**
 * 메일 이동 (범용) + rspamd 학습
 * PATCH /api/emails/:id/move?mailbox=INBOX&target=SPAM
 */
router.patch("/emails/:id/move", async (req, res) => {
  const t = await sequelize.transaction();
  try {
    const { mailbox, target } = req.query;
    const result = await findEmail(req.params.id, req.user.email, mailbox);
    if (!result) {
      await safeRollback(t);
      return res.status(404).json({ error: "메일 찾기 실패" });
    }

    const { email, box } = result;
    if (box === target) {
      await safeRollback(t);
      return res.json({ success: true });
    }

    // rspamd 학습 (스팸함 관련 이동 시)
    let learned = false;
    try {
      const rspamd = require("../services/rspamdService");
      const rawEmail = email.rawEmail || rspamd.buildRawEmail(email.toJSON());

      if (target === "SPAM" && box !== "SPAM") {
        // 스팸함으로 이동 → 스팸으로 학습
        await rspamd.learnSpam(rawEmail);
        console.log(`[rspamd] 스팸 학습 완료: ${email.subject}`);
        learned = true;
      } else if (box === "SPAM" && target !== "SPAM") {
        // 스팸함에서 나감 → 정상 메일(ham)로 학습
        await rspamd.learnHam(rawEmail);
        console.log(`[rspamd] 햄 학습 완료: ${email.subject}`);
        learned = true;
      }
    } catch (rspamdError) {
      console.warn("[rspamd] 학습 실패 (무시):", rspamdError.message);
    }

    const TargetModel = getModel(target);

    // 대상 메일함으로 복사
    const emailData = email.toJSON();
    delete emailData.id;
    emailData.originalMailbox = box;
    if (emailData.isRead === undefined) emailData.isRead = true;

    const newEmail = await TargetModel.create(emailData, { transaction: t });
    await email.destroy({ transaction: t });

    await t.commit();
    res.json({ success: true, newId: newEmail.id, target, learned });
  } catch (error) {
    await safeRollback(t);
    console.error("메일 이동 오류:", error);
    res.status(500).json({ error: "메일 이동 실패" });
  }
});

/**
 * 영구 삭제
 * DELETE /api/emails/:id?mailbox=TRASH
 */
router.delete("/emails/:id", async (req, res) => {
  try {
    const { mailbox } = req.query;
    const result = await findEmail(req.params.id, req.user.email, mailbox);
    if (!result) return res.status(404).json({ error: "메일 찾기 실패" });

    await result.email.destroy();
    res.json({ success: true });
  } catch (error) {
    console.error("삭제 오류:", error);
    res.status(500).json({ error: "삭제 실패" });
  }
});

/**
 * 첨부파일 다운로드 (스트리밍)
 * GET /api/emails/:id/attachments/:filename?mailbox=INBOX
 */
router.get("/emails/:id/attachments/:filename", async (req, res) => {
  try {
    const { mailbox } = req.query;
    const result = await findEmail(req.params.id, req.user.email, mailbox);
    if (!result) return res.status(404).json({ error: "메일 찾기 실패" });

    // 첨부파일 목록 파싱
    let attachments = result.email.attachments || [];
    if (typeof attachments === "string") {
      try {
        attachments = JSON.parse(attachments);
      } catch {
        attachments = [];
      }
    }

    // 요청된 파일명으로 검색
    const att = attachments.find((a) => a.filename === req.params.filename);
    if (!att) return res.status(404).json({ error: "파일을 찾을 수 없음" });

    // S3에서 스트리밍 다운로드
    const { stream, contentType, contentLength } = await getObjectStream(
      att.key
    );
    res.setHeader("Content-Type", contentType || "application/octet-stream");
    if (contentLength) res.setHeader("Content-Length", contentLength);

    const encoded = encodeURIComponent(att.filename);
    res.setHeader(
      "Content-Disposition",
      `attachment; filename="${encoded}"; filename*=UTF-8''${encoded}`
    );
    stream.pipe(res);
  } catch (error) {
    console.error("첨부파일 다운로드 오류:", error);
    res.status(500).json({ error: "다운로드 오류" });
  }
});

/**
 * 메일 발송 (SES + 보낸편지함 저장)
 * POST /api/send
 */
router.post("/send", async (req, res) => {
  try {
    const { to, subject, html, text, attachments = [] } = req.body;
    const userEmail = req.user.email;

    // 사용자 이름 조회하여 From 헤더 구성
    const currentUser = await User.findOne({ where: { email: userEmail } });
    const fromHeader = currentUser?.name
      ? `"${currentUser.name}" <${userEmail}>`
      : userEmail;

    // 첨부파일을 Garage에 업로드
    const { uploadAttachment } = require("../services/s3Service");
    const attachmentsData = [];

    for (const att of attachments) {
      const buffer = Buffer.from(att.content, "base64");
      const key = await uploadAttachment(buffer, att.filename, att.contentType);
      attachmentsData.push({
        filename: att.filename,
        contentType: att.contentType,
        size: buffer.length,
        key: key,
      });
    }

    // SES를 통한 발송 (From 헤더에 이름 포함)
    await sendEmail({ from: fromHeader, to, subject, html, text, attachments });

    // 보낸편지함에 저장 (첨부파일 정보 포함)
    const sentEmailData = {
      from: userEmail,
      fromName: currentUser?.name || null,
      to: Array.isArray(to) ? to.join(",") : to,
      subject,
      html: html,
      text: text || (html ? html.replace(/<[^>]*>/g, "") : ""),
      attachments: attachmentsData,
      date: new Date(),
      isRead: true,
    };
    sentEmailData.size = calculateEmailSize(sentEmailData);
    await Sent.create(sentEmailData);

    // 발송 로그 테이블에도 기록 (통계용 - 보낸편지함 삭제와 무관하게 유지)
    await SentLog.create({
      from: userEmail,
      to: Array.isArray(to) ? to.join(",") : to,
      subject: subject || "(제목 없음)",
      success: true,
      sentAt: new Date(),
    });

    res.json({ success: true });
  } catch (error) {
    console.error("메일 발송 오류:", error);
    res.status(500).json({ error: "발송 실패" });
  }
});

/**
 * 임시저장 생성
 * POST /api/drafts
 */
router.post("/drafts", async (req, res) => {
  try {
    const { to, subject, html, text } = req.body;
    const userEmail = req.user.email;

    const draft = await Draft.create({
      from: userEmail,
      to: Array.isArray(to) ? to.join(",") : to || "",
      subject: subject || "(제목 없음)",
      html: html || "",
      text: text || (html ? html.replace(/<[^>]*>/g, "") : ""),
      date: new Date(),
      isRead: true,
      isDeleted: false,
    });

    res.json({ success: true, id: draft.id });
  } catch (error) {
    console.error("임시저장 오류:", error);
    res.status(500).json({ error: "임시저장 실패" });
  }
});

/**
 * 임시저장 삭제
 * DELETE /api/drafts/:id
 */
router.delete("/drafts/:id", async (req, res) => {
  try {
    const draft = await Draft.findOne({
      where: { id: req.params.id, from: req.user.email },
    });

    if (!draft) {
      return res.status(404).json({ error: "임시저장 찾기 실패" });
    }

    await draft.destroy();
    res.json({ success: true });
  } catch (error) {
    console.error("임시저장 삭제 오류:", error);
    res.status(500).json({ error: "삭제 실패" });
  }
});

/**
 * 사용자 이메일-이름 매핑 조회
 * GET /api/user-names
 * 로컬 가입 사용자의 이메일과 이름 매핑 반환
 */
router.get("/user-names", authenticateToken, async (req, res) => {
  try {
    const users = await User.findAll({
      attributes: ["email", "name"],
      where: { name: { [Op.ne]: null } },
    });

    // 이메일 -> 이름 매핑 객체로 변환
    const userMap = {};
    users.forEach((user) => {
      if (user.name) {
        userMap[user.email] = user.name;
      }
    });

    res.json(userMap);
  } catch (error) {
    console.error("사용자 이름 조회 오류:", error);
    res.status(500).json({ error: "조회 실패" });
  }
});

module.exports = router;