TK-FB-Project/api.hyungi.net/index.js

require('dotenv').config();
const express = require('express');
const cors = require('cors');
const path = require('path');
const helmet = require('helmet');
const rateLimit = require('express-rate-limit');

// 새로운 유틸리티들 import
const { errorMiddleware } = require('./utils/errorHandler');
const { responseMiddleware } = require('./utils/responseFormatter');

// Swagger 설정
const swaggerUi = require('swagger-ui-express');
const swaggerSpec = require('./config/swagger');

// 성능 최적화 모듈
const compression = require('compression');
const cache = require('./utils/cache');

const app = express();

// 헬스체크와 개발용 엔드포인트는 CORS 이후에 등록

// ✅ 보안 헤더 설정 (Helmet)
app.use(helmet({
  contentSecurityPolicy: {
    directives: {
      defaultSrc: ["'self'"],
      styleSrc: ["'self'", "'unsafe-inline'", "https://fonts.googleapis.com"],
      scriptSrc: ["'self'", "'unsafe-inline'", "'unsafe-eval'"],
      imgSrc: ["'self'", "data:", "https:", "blob:"],
      fontSrc: ["'self'", "https://fonts.gstatic.com"],
      connectSrc: ["'self'", "https://api.technicalkorea.com"],
    },
  },
  hsts: {
    maxAge: 31536000,
    includeSubDomains: true,
    preload: true
  }
}));

// ✅ 성능 최적화 미들웨어
app.use(compression({
  filter: (req, res) => {
    if (req.headers['x-no-compression']) {
      return false;
    }
    return compression.filter(req, res);
  },
  level: 6, // 압축 레벨 (1-9, 6이 기본값)
  threshold: 1024 // 1KB 이상만 압축
}));

// ✅ 요청 바디 용량 제한 확장
app.use(express.urlencoded({ extended: true, limit: '50mb' }));
app.use(express.json({ limit: '50mb' }));

// ✅ 응답 포맷터 미들웨어 적용
app.use(responseMiddleware);

//개발용 CORS 설정 (수정됨)
app.use(cors({
  origin: function (origin, callback) {
    // 개발 환경에서는 모든 origin 허용
    console.log('🌐 CORS Origin 요청:', origin);
    
    const allowedOrigins = [
      'http://localhost:20000',   // 웹 UI
      'http://localhost:3005',    // API 서버  
      'http://localhost:3000',    // 개발 포트
      'http://127.0.0.1:20000',   // 로컬호스트 대체
    ];
    
    // origin이 없는 경우 (직접 접근) 허용
    if (!origin) {
      console.log('✅ Origin 없음 - 허용');
      return callback(null, true);
    }
    
    // 허용된 origin인지 확인
    if (allowedOrigins.includes(origin)) {
      console.log('✅ 허용된 Origin:', origin);
      return callback(null, true);
    }
    
    // 개발 환경에서는 모든 localhost 허용
    if (origin.includes('localhost') || origin.includes('127.0.0.1')) {
      console.log('✅ 로컬호스트 허용:', origin);
      return callback(null, true);
    }
    
    console.log('❌ 차단된 Origin:', origin);
    callback(null, false);
  },
  credentials: true,
  methods: ['GET', 'POST', 'PUT', 'DELETE', 'OPTIONS'],
  allowedHeaders: ['Content-Type', 'Authorization', 'X-Requested-With']
}));

// ✅ Health check (CORS 이후에 등록)
app.get('/api/health', (req, res) => {
  console.log('🟢 Health check 호출됨!');
  res.status(200).json({ 
    status: 'healthy',
    service: 'Hyungi API',
    timestamp: new Date().toISOString()
  });
});

// ✅ 개발용 Ping 엔드포인트
app.get('/api/ping', (req, res) => {
  console.log('🏓 Ping 요청 받음!');
  res.status(200).json({ 
    message: 'pong',
    timestamp: new Date().toISOString()
  });
});

// ✅ 개발용 DB 설정 엔드포인트 (임시 비활성화)
// app.post('/api/setup-attendance-db', async (req, res) => {
//   // DB 설정 로직 임시 비활성화
// });

// ✅ 서버 상태 엔드포인트
app.get('/api/status', (req, res) => {
  console.log('📊 Status 요청 받음!');
  res.health('running', {
    service: 'Hyungi API',
    version: '2.1.0',
    environment: process.env.NODE_ENV || 'development'
  });
});

// ✅ CORS 설정: 허용 origin 명시 (수정된 버전)
//app.use(cors({
//  origin: function (origin, callback) {
//    const allowedOrigins = process.env.ALLOWED_ORIGINS 
//      ? process.env.ALLOWED_ORIGINS.split(',')
//      : [
//          'http://localhost:3000',
//          'http://localhost:3005',
//          'http://web-ui',
//          'http://web-ui:80',
//          'http://web-ui:3001',         // 실제 내부 포트
//          'http://172.18.0.1',
//          'http://172.18.0.1:3001',
//          'http://172.18.0.2',          // web-ui 컨테이너 IP
//          'http://172.18.0.2:3001',     // web-ui 컨테이너 IP:포트
//          'http://192.168.0.3',         // 나스 외부 IP (포트 없음)
//          'http://192.168.0.3:80',      // 나스 외부 접근
//          'http://192.168.0.3:3001',    // 나스 외부 접근 (실제 포트)
//          'http://192.168.0.3:5000',    // 시놀로지 기본 포트
//          'http://192.168.0.3:5001',    // 시놀로지 HTTPS 포트
//          // 추가: 더 유연한 허용
//          'http://192.168.0.3:3000',    // 다른 포트들도 허용
//          'http://192.168.0.3:8080',
//          'http://192.168.0.3:8000'
//        ];
//    
//    // 개발 환경에서는 모든 로컬 IP 허용
//    if (process.env.NODE_ENV === 'development' || !origin) {
//      return callback(null, true);
//    }
//    
//    // 192.168.x.x 대역 자동 허용 (시놀로지 환경)
//    if (origin && origin.match(/^http:\/\/192\.168\.\d+\.\d+(:\d+)?$/)) {
//      console.log('✅ 로컬 네트워크 IP 자동 허용:', origin);
//      return callback(null, true);
//    }
//    
//    if (allowedOrigins.includes(origin)) {
//      callback(null, true);
//    } else {
//      console.error('❌ CORS 차단됨:', origin);
//      console.log('허용된 Origins:', allowedOrigins);
//      callback(new Error('CORS 차단됨: ' + origin));
//    }
//  },
//  credentials: true
// }));

// ✅ 신뢰할 수 있는 프록시 설정 (IP 주소 정확히 가져오기)
app.set('trust proxy', 1);

// ✅ API 속도 제한 설정 - 내부 시스템이므로 비활성화
// Rate Limiting 제거 (내부 시스템, 제한된 사용자)
const apiLimiter = (req, res, next) => next(); // 통과
const loginLimiter = (req, res, next) => next(); // 통과

// ✅ 라우터 등록
const authRoutes = require('./routes/authRoutes');
const projectRoutes = require('./routes/projectRoutes');
const workerRoutes = require('./routes/workerRoutes');
const workReportRoutes = require('./routes/workReportRoutes');
const toolsRoute = require('./routes/toolsRoute');
const uploadRoutes = require('./routes/uploadRoutes');
const uploadBgRoutes = require('./routes/uploadBgRoutes');
const dailyIssueReportRoutes = require('./routes/dailyIssueReportRoutes');
const issueTypeRoutes = require('./routes/issueTypeRoutes');
const healthRoutes = require('./routes/healthRoutes');
const dailyWorkReportRoutes = require('./routes/dailyWorkReportRoutes');
const workAnalysisRoutes = require('./routes/workAnalysisRoutes');
const analysisRoutes = require('./routes/analysisRoutes');
const systemRoutes = require('./routes/systemRoutes'); // 새로운 분석 라우트
const performanceRoutes = require('./routes/performanceRoutes'); // 성능 모니터링 라우트

// 🔒 인증 미들웨어 가져오기
const { verifyToken } = require('./middlewares/authMiddleware');

// ahn.hyungi.net 배포용
app.use(express.static(path.join(__dirname, 'public')));

// ✅ 업로드된 파일 정적 라우팅 추가 (웹에서 이미지 접근 가능하게)
app.use('/uploads', express.static(path.join(__dirname, 'uploads')));

// 🔒 활동 로깅 미들웨어
const activityLogger = (req, res, next) => {
  const start = Date.now();
  
  res.on('finish', () => {
    const duration = Date.now() - start;
    const logData = {
      timestamp: new Date().toISOString(),
      method: req.method,
      url: req.originalUrl,
      status: res.statusCode,
      duration: duration + 'ms',
      ip: req.ip,
      user: req.user?.username || 'anonymous'
    };
    
    // 성공/실패에 따른 로그 레벨 분기
    if (res.statusCode >= 400) {
      console.error('[API Error]', logData);
    } else if (res.statusCode >= 300) {
      console.warn('[API Redirect]', logData);
    } else {
      console.log('[API Access]', logData);
    }
  });
  
  next();
};

// ===== 📋 미들웨어 적용 순서 수정 (🔥 핵심 수정 부분) =====

// 모든 API 요청에 활동 로거 적용
app.use('/api/*', activityLogger);

// 🔓 인증이 필요 없는 경로들을 먼저 등록 (순서 중요!)

// Health check는 이미 맨 위에서 등록됨

// 🔓 로그인 관련 경로들 (인증 없이 접근 가능)
// 로그인 엔드포인트에 특별한 속도 제한 적용
app.post('/api/auth/login', loginLimiter, (req, res, next) => {
  console.log('🔓 로그인 요청 받음:', req.body.username);
  authRoutes.handle(req, res, next);
});

// 기타 공개 인증 엔드포인트들
app.use('/api/auth/refresh-token', loginLimiter);
app.use('/api/auth/check-password-strength', loginLimiter);

// 나머지 인증 라우트
app.use('/api/auth', authRoutes);

// 🔧 DB 설정 라우트 (개발용 - 인증 없이 접근 가능)
app.use('/api/setup', require('./routes/setupRoutes'));

// 🔒 일반 API 속도 제한 적용
app.use('/api/', apiLimiter);

// 🔒 인증이 필요한 모든 API에 대해 토큰 검증 (수정된 버전)
app.use('/api/*', (req, res, next) => {
  console.log(`🔍 API 요청: ${req.method} ${req.originalUrl}`);
  
  // 🔓 인증이 필요 없는 경로들은 통과 (정확한 매칭)
  const publicPaths = [
    '/api/auth/login',
    '/api/auth/refresh-token',
    '/api/auth/check-password-strength',
    '/api/health',
    '/api/ping',      // 개발용 핑
    '/api/status',    // 서버 상태
    '/api/setup/setup-attendance-db',
  '/api/setup/setup-monthly-status',  // DB 설정 (개발용)
  '/api/setup/add-overtime-warning',  // 12시간 초과 상태 추가 (개발용)
  '/api/setup/migrate-existing-data', // 기존 데이터 마이그레이션 (개발용)
  '/api/setup/check-data-status',     // DB 상태 확인 (개발용)
  '/api/monthly-status/calendar',     // 월별 집계 테스트용
  '/api/monthly-status/daily-details' // 일별 상세 테스트용
  ];
  
  // 정확한 경로 매칭 확인
  const isPublicPath = publicPaths.some(path => {
    // 정확한 경로 또는 쿼리 파라미터가 있는 경우
    const isMatch = req.originalUrl === path || 
                   req.originalUrl.startsWith(path + '?') ||
                   req.originalUrl.startsWith(path + '/');
    if (isMatch) {
      console.log(`🔓 Public path 허용: ${req.originalUrl}`);
    }
    return isMatch;
  });
  
  if (isPublicPath) {
    return next();
  }
  
  // 나머지는 모두 인증 필요
  console.log(`🔒 인증 필요한 경로: ${req.originalUrl}`);
  verifyToken(req, res, next);
});

// ===== 📊 모든 라우트 등록 (인증된 사용자만) =====

// 📝 일반 기능들
app.use('/api/issue-reports', dailyIssueReportRoutes);
app.use('/api/issue-types', issueTypeRoutes);

// 👥 기본 데이터들 (모든 인증된 사용자)
app.use('/api/workers', workerRoutes);
app.use('/api/daily-work-reports', dailyWorkReportRoutes);
app.use('/api/work-analysis', workAnalysisRoutes);
app.use('/api/analysis', analysisRoutes); // 새로운 분석 라우트 등록
app.use('/api/daily-work-reports-analysis', require('./routes/workReportAnalysisRoutes')); // 데일리 워크 레포트 분석 라우트
app.use('/api/attendance', require('./routes/attendanceRoutes')); // 근태 관리 라우트
app.use('/api/monthly-status', require('./routes/monthlyStatusRoutes')); // 월별 상태 집계 라우트

// 📊 리포트 및 분석
app.use('/api/workreports', workReportRoutes);

// 🔧 시스템 관리 (시스템 권한만)
app.use('/api/system', systemRoutes);
app.use('/api/uploads', uploadRoutes);

// 📊 성능 모니터링 (관리자 권한)
app.use('/api/performance', performanceRoutes);

// ⚙️ 시스템 데이터들 (모든 인증된 사용자)
app.use('/api/projects', projectRoutes);
app.use('/api/tools', toolsRoute);

// 👤 사용자 관리 API (관리자 전용)
app.get('/api/users', async (req, res) => {
  try {
    // 관리자 권한 확인
    if (!req.user || !['admin', 'system'].includes(req.user.access_level)) {
      return res.status(403).json({
        success: false,
        error: '관리자 권한이 필요합니다.'
      });
    }

    const { getDb } = require('./dbPool');
    const db = await getDb();
    const [users] = await db.execute(`
      SELECT user_id, username, name, role, access_level, is_active, created_at, worker_id
      FROM users 
      WHERE is_active = 1
      ORDER BY user_id
    `);
    
    res.json({
      success: true,
      message: '사용자 목록 조회 성공',
      data: users
    });
  } catch (error) {
    console.error('사용자 목록 조회 오류:', error);
    res.status(500).json({
      success: false,
      error: '사용자 목록을 불러올 수 없습니다.'
    });
  }
});

// 👤 사용자 정보 수정 API (관리자 전용)
app.put('/api/users/:id', async (req, res) => {
  try {
    // 관리자 권한 확인
    if (!req.user || !['admin', 'system'].includes(req.user.access_level)) {
      return res.status(403).json({
        success: false,
        error: '관리자 권한이 필요합니다.'
      });
    }

    const userId = req.params.id;
    const { username, name, role, access_level, is_active } = req.body;

    // undefined 값을 null로 변환
    const safeUsername = username !== undefined ? username : null;
    const safeName = name !== undefined ? name : null;
    const safeRole = role !== undefined ? role : null;
    const safeAccessLevel = access_level !== undefined ? access_level : null;
    const safeIsActive = is_active !== undefined ? is_active : null;

    const { getDb } = require('./dbPool');
    const db = await getDb();
    
    const [result] = await db.execute(`
      UPDATE users 
      SET username = ?, name = ?, role = ?, access_level = ?, is_active = ?, updated_at = NOW()
      WHERE user_id = ?
    `, [safeUsername, safeName, safeRole, safeAccessLevel, safeIsActive, userId]);
    
    if (result.affectedRows === 0) {
      return res.status(404).json({
        success: false,
        error: '사용자를 찾을 수 없습니다.'
      });
    }

    res.json({
      success: true,
      message: '사용자 정보가 성공적으로 수정되었습니다.'
    });
  } catch (error) {
    console.error('사용자 정보 수정 오류:', error);
    res.status(500).json({
      success: false,
      error: '사용자 정보 수정에 실패했습니다.'
    });
  }
});

// 👤 사용자 삭제 API (관리자 전용)
app.delete('/api/users/:id', async (req, res) => {
  try {
    // 관리자 권한 확인
    if (!req.user || !['admin', 'system'].includes(req.user.access_level)) {
      return res.status(403).json({
        success: false,
        error: '관리자 권한이 필요합니다.'
      });
    }

    const userId = req.params.id;

    // 자기 자신은 삭제할 수 없도록 방지
    if (parseInt(userId) === req.user.user_id) {
      return res.status(400).json({
        success: false,
        error: '자기 자신은 삭제할 수 없습니다.'
      });
    }

    const { getDb } = require('./dbPool');
    const db = await getDb();
    
    // 사용자 존재 여부 확인
    const [existingUser] = await db.execute(`
      SELECT user_id, username FROM users WHERE user_id = ?
    `, [userId]);
    
    if (existingUser.length === 0) {
      return res.status(404).json({
        success: false,
        error: '사용자를 찾을 수 없습니다.'
      });
    }

    // 사용자 삭제 (실제로는 비활성화)
    const [result] = await db.execute(`
      UPDATE users 
      SET is_active = 0, updated_at = NOW()
      WHERE user_id = ?
    `, [userId]);

    res.json({
      success: true,
      message: `사용자 '${existingUser[0].username}'가 성공적으로 비활성화되었습니다.`
    });
  } catch (error) {
    console.error('사용자 삭제 오류:', error);
    res.status(500).json({
      success: false,
      error: '사용자 삭제에 실패했습니다.'
    });
  }
});

// 👤 사용자 생성 API (관리자 전용)
app.post('/api/users', async (req, res) => {
  try {
    // 관리자 권한 확인
    if (!req.user || !['admin', 'system'].includes(req.user.access_level)) {
      return res.status(403).json({
        success: false,
        error: '관리자 권한이 필요합니다.'
      });
    }

    const { username, name, role, access_level, password } = req.body;

    // 필수 필드 검증
    if (!username || !name || !password) {
      return res.status(400).json({
        success: false,
        error: '사용자명, 이름, 비밀번호는 필수 입력 항목입니다.'
      });
    }

    const { getDb } = require('./dbPool');
    const db = await getDb();
    
    // 중복 사용자명 확인
    const [existingUser] = await db.execute(`
      SELECT user_id FROM users WHERE username = ?
    `, [username]);
    
    if (existingUser.length > 0) {
      return res.status(400).json({
        success: false,
        error: '이미 존재하는 사용자명입니다.'
      });
    }

    // 비밀번호 해시화
    const bcrypt = require('bcryptjs');
    const hashedPassword = await bcrypt.hash(password, 10);

    // undefined 값을 null로 변환 및 role에 따른 access_level 자동 설정
    const safeRole = role !== undefined ? role : null;
    
    // role에 따라 access_level 자동 설정
    let safeAccessLevel;
    if (access_level !== undefined) {
      safeAccessLevel = access_level;
    } else if (safeRole === 'admin') {
      safeAccessLevel = 'admin';
    } else if (safeRole === 'leader' || safeRole === 'group_leader') {
      safeAccessLevel = 'group_leader';
    } else {
      safeAccessLevel = 'worker';
    }

    // 사용자 생성
    const [result] = await db.execute(`
      INSERT INTO users (username, name, password, role, access_level, is_active, created_at, updated_at)
      VALUES (?, ?, ?, ?, ?, 1, NOW(), NOW())
    `, [username, name, hashedPassword, safeRole, safeAccessLevel]);

    res.status(201).json({
      success: true,
      message: `사용자 '${username}'가 성공적으로 생성되었습니다.`,
      data: {
        user_id: result.insertId,
        username: username,
        name: name,
        role: safeRole,
        access_level: safeAccessLevel,
        is_active: true
      }
    });
  } catch (error) {
    console.error('사용자 생성 오류:', error);
    res.status(500).json({
      success: false,
      error: '사용자 생성에 실패했습니다.'
    });
  }
});

// 👤 사용자 상태 변경 API (관리자 전용)
app.put('/api/users/:id/status', async (req, res) => {
  try {
    // 관리자 권한 확인
    if (!req.user || !['admin', 'system'].includes(req.user.access_level)) {
      return res.status(403).json({
        success: false,
        error: '관리자 권한이 필요합니다.'
      });
    }

    const userId = req.params.id;
    const { is_active } = req.body;

    // 자기 자신의 상태는 변경할 수 없도록 방지
    if (parseInt(userId) === req.user.user_id) {
      return res.status(400).json({
        success: false,
        error: '자기 자신의 상태는 변경할 수 없습니다.'
      });
    }

    const { getDb } = require('./dbPool');
    const db = await getDb();
    
    // 사용자 존재 여부 확인
    const [existingUser] = await db.execute(`
      SELECT user_id, username, is_active FROM users WHERE user_id = ?
    `, [userId]);
    
    if (existingUser.length === 0) {
      return res.status(404).json({
        success: false,
        error: '사용자를 찾을 수 없습니다.'
      });
    }

    // 상태 변경
    const newStatus = is_active !== undefined ? is_active : !existingUser[0].is_active;
    const [result] = await db.execute(`
      UPDATE users 
      SET is_active = ?, updated_at = NOW()
      WHERE user_id = ?
    `, [newStatus, userId]);

    const statusText = newStatus ? '활성화' : '비활성화';
    
    res.json({
      success: true,
      message: `사용자 '${existingUser[0].username}'가 성공적으로 ${statusText}되었습니다.`,
      data: {
        user_id: parseInt(userId),
        username: existingUser[0].username,
        is_active: newStatus
      }
    });
  } catch (error) {
    console.error('사용자 상태 변경 오류:', error);
    res.status(500).json({
      success: false,
      error: '사용자 상태 변경에 실패했습니다.'
    });
  }
});

// 📤 파일 업로드
app.use('/api', uploadBgRoutes);

// ===== 📚 Swagger API 문서 =====
app.use('/api-docs', swaggerUi.serve, swaggerUi.setup(swaggerSpec, {
  explorer: true,
  customCss: '.swagger-ui .topbar { display: none }',
  customSiteTitle: 'TK Work Management API',
  swaggerOptions: {
    persistAuthorization: true,
    displayRequestDuration: true,
    docExpansion: 'none',
    filter: true,
    showExtensions: true,
    showCommonExtensions: true
  }
}));

// Swagger JSON 스펙 제공
app.get('/api-docs.json', (req, res) => {
  res.setHeader('Content-Type', 'application/json');
  res.send(swaggerSpec);
});

// ===== 🚨 에러 핸들러 (모든 라우트 뒤에 위치) =====
app.use(errorMiddleware);

// ===== 🔍 API 정보 엔드포인트 =====
app.get('/api', (req, res) => {
  res.json({
    name: 'Technical Korea Work Management API',
    version: '2.1.0',
    description: '보안이 강화된 생산관리 시스템 API',
    timestamp: new Date().toISOString(),
    security: {
      authentication: 'JWT Bearer Token',
      rateLimit: {
        general: '100 requests per 15 minutes',
        login: '5 attempts per 15 minutes'
      },
      cors: 'Configured for specific origins',
      headers: 'Security headers enabled (Helmet)'
    },
    user: {
      username: req.user?.username || 'anonymous',
      access_level: req.user?.access_level || 'none',
      worker_id: req.user?.worker_id || null
    },
    endpoints: {
      auth: {
        login: 'POST /api/auth/login',
        logout: 'POST /api/auth/logout',
        refreshToken: 'POST /api/auth/refresh-token',
        changePassword: 'POST /api/auth/change-password',
        adminChangePassword: 'POST /api/auth/admin/change-password',
        checkPasswordStrength: 'POST /api/auth/check-password-strength',
        me: 'GET /api/auth/me',
        users: 'GET /api/auth/users',
        register: 'POST /api/auth/register',
        updateUser: 'PUT /api/auth/users/:id',
        deleteUser: 'DELETE /api/auth/users/:id',
        loginHistory: 'GET /api/auth/login-history'
      },
      dailyWorkReports: {
        workTypes: 'GET /api/daily-work-reports/work-types',
        workStatusTypes: 'GET /api/daily-work-reports/work-status-types', 
        errorTypes: 'GET /api/daily-work-reports/error-types',
        create: 'POST /api/daily-work-reports',
        search: 'GET /api/daily-work-reports/search',
        summary: 'GET /api/daily-work-reports/summary',
        byDate: 'GET /api/daily-work-reports/date/:date',
        update: 'PUT /api/daily-work-reports/:id',
        delete: 'DELETE /api/daily-work-reports/:id'
      },
      workAnalysis: {
       stats: 'GET /api/work-analysis/stats?start=YYYY-MM-DD&end=YYYY-MM-DD',
       dailyTrend: 'GET /api/work-analysis/daily-trend?start=YYYY-MM-DD&end=YYYY-MM-DD',
       workerStats: 'GET /api/work-analysis/worker-stats?start=YYYY-MM-DD&end=YYYY-MM-DD',
       projectStats: 'GET /api/work-analysis/project-stats?start=YYYY-MM-DD&end=YYYY-MM-DD',
       workTypeStats: 'GET /api/work-analysis/work-type-stats?start=YYYY-MM-DD&end=YYYY-MM-DD',
       recentWork: 'GET /api/work-analysis/recent-work?start=YYYY-MM-DD&end=YYYY-MM-DD&limit=10',
       weekdayPattern: 'GET /api/work-analysis/weekday-pattern?start=YYYY-MM-DD&end=YYYY-MM-DD',
       errorAnalysis: 'GET /api/work-analysis/error-analysis?start=YYYY-MM-DD&end=YYYY-MM-DD',
       monthlyComparison: 'GET /api/work-analysis/monthly-comparison?year=YYYY',
       workerSpecialization: 'GET /api/work-analysis/worker-specialization?start=YYYY-MM-DD&end=YYYY-MM-DD',
       dashboard: 'GET /api/work-analysis/dashboard?start=YYYY-MM-DD&end=YYYY-MM-DD',
       health: 'GET /api/work-analysis/health'
      },
      workers: 'GET/POST/PUT/DELETE /api/workers',
      projects: 'GET/POST/PUT/DELETE /api/projects',
      issues: 'GET/POST/PUT/DELETE /api/issue-reports',
      reports: 'GET /api/workreports',
      uploads: 'POST /api/uploads'
    },
    note: '모든 API는 로그인 후 접근 가능합니다. 자세한 API 문서는 관리자에게 문의하세요.'
  });
});

// ===== 🏠 메인 페이지 라우트 =====
app.get('/', (req, res) => {
  res.sendFile(path.join(__dirname, 'public', 'index.html'));
});

// ✅ 서버 실행
const PORT = process.env.PORT || 3005;
const server = app.listen(PORT, () => {
  console.log(`
🚀 Technical Korea Work Management System v2.1.0
📍 서버가 포트 ${PORT}에서 실행 중입니다.
🌐 접속 URL: http://localhost:${PORT}
📊 API 문서: http://localhost:${PORT}/api

🔒 보안 기능:
   ✅ JWT 토큰 인증
   ✅ 로그인 실패 제한 (5회)
   ✅ API 속도 제한
   ✅ 보안 헤더 (Helmet)
   ✅ CORS 설정 (192.168.0.3:3001 허용)
   ✅ 활동 로깅

📋 새로운 기능:
   🔐 비밀번호 변경 (본인/관리자)
   🔄 토큰 갱신 (Refresh Token)
   📊 로그인 이력 조회
   💪 비밀번호 강도 체크
  `);
}).on('error', (err) => {
  console.error('❌ 서버 실행 중 오류 발생:', err);
  if (err.code === 'EADDRINUSE') {
    console.error(`포트 ${PORT}이(가) 이미 사용 중입니다.`);
  }
});

// ===== 🚨 에러 핸들링 =====

// 404 핸들러
app.use((req, res) => {
  console.log(`[404] ${req.method} ${req.originalUrl} - IP: ${req.ip}`);
  
  if (req.originalUrl.startsWith('/api/')) {
    res.status(404).json({ 
      error: 'API 엔드포인트를 찾을 수 없습니다.',
      path: req.originalUrl,
      available: '/api',
      timestamp: new Date().toISOString()
    });
  } else {
    res.status(404).json({ 
      error: '요청하신 페이지를 찾을 수 없습니다.',
      timestamp: new Date().toISOString()
    });
  }
});

// 전역 에러 핸들러  
app.use((err, req, res, next) => {
  const errorId = Date.now().toString(36);
  
  console.error(`[ERROR ${errorId}] ${new Date().toISOString()}:`, {
    message: err.message,
    stack: process.env.NODE_ENV === 'development' ? err.stack : undefined,
    url: req.originalUrl,
    method: req.method,
    ip: req.ip,
    user: req.user?.username || 'anonymous'
  });

  // CORS 에러
//  if (err.message && err.message.includes('CORS 차단됨')) {
//    return res.status(403).json({ 
//      error: 'CORS 정책에 의해 차단되었습니다.',
//      message: 'API 접근이 허용되지 않은 도메인입니다.',
//      errorId
//    });
//  }

  // JWT 에러
  if (err.name === 'JsonWebTokenError') {
    return res.status(401).json({ 
      error: '유효하지 않은 토큰입니다.',
      errorId
    });
  }

  if (err.name === 'TokenExpiredError') {
    return res.status(401).json({ 
      error: '토큰이 만료되었습니다. 다시 로그인해주세요.',
      errorId
    });
  }

  // 요청 크기 초과
  if (err.type === 'entity.too.large') {
    return res.status(413).json({ 
      error: '요청 크기가 너무 큽니다. 50MB 이하로 줄여주세요.',
      errorId
    });
  }

  // 일반 서버 에러
  res.status(err.status || 500).json({ 
    error: '서버 오류가 발생했습니다.',
    message: process.env.NODE_ENV === 'development' ? err.message : '관리자에게 문의하세요.',
    errorId,
    timestamp: new Date().toISOString()
  });
});

// ===== 🔄 Graceful Shutdown =====
const gracefulShutdown = () => {
  console.log('\n🛑 서버 종료 신호를 받았습니다...');
  
  server.close(() => {
    console.log('✅ HTTP 서버가 정상적으로 종료되었습니다.');
    
    // DB 연결 종료 등 추가 정리 작업
    // 예: db.end(), redis.quit() 등
    
    process.exit(0);
  });
  
  // 30초 후 강제 종료
  setTimeout(() => {
    console.error('❌ 정상 종료 실패, 강제 종료합니다.');
    process.exit(1);
  }, 30000);
};

process.on('SIGTERM', gracefulShutdown);
process.on('SIGINT', gracefulShutdown);

// 처리되지 않은 Promise 거부
process.on('unhandledRejection', (reason, promise) => {
  console.error('처리되지 않은 Promise 거부:', reason);
  // 개발 환경에서는 크래시, 프로덕션에서는 로그만
  if (process.env.NODE_ENV === 'development') {
    process.exit(1);
  }
});

// 처리되지 않은 예외
process.on('uncaughtException', (error) => {
  console.error('처리되지 않은 예외:', error);
  gracefulShutdown();
});

// ✅ 캐시 시스템 초기화
(async () => {
  try {
    await cache.initRedis();
    console.log('🚀 캐시 시스템 초기화 완료');
  } catch (error) {
    console.warn('캐시 시스템 초기화 실패:', error.message);
  }
})();

module.exports = app;