const AttendanceModel = require('../models/attendanceModel');

class AttendanceController {
  // 일일 근태 현황 조회 (대시보드용)
  static async getDailyAttendanceStatus(req, res) {
    try {
      const { date } = req.query;
      
      if (!date) {
        return res.status(400).json({
          success: false,
          message: '날짜가 필요합니다.'
        });
      }

      const attendanceStatus = await AttendanceModel.getWorkerAttendanceStatus(date);
      
      res.json({
        success: true,
        data: attendanceStatus,
        message: '근태 현황을 성공적으로 조회했습니다.'
      });
    } catch (error) {
      console.error('근태 현황 조회 오류:', error);
      res.status(500).json({
        success: false,
        message: '근태 현황 조회 중 오류가 발생했습니다.',
        error: error.message
      });
    }
  }

  // 일일 근태 기록 조회
  static async getDailyAttendanceRecords(req, res) {
    try {
      const { date, worker_id } = req.query;
      
      if (!date) {
        return res.status(400).json({
          success: false,
          message: '날짜가 필요합니다.'
        });
      }

      const records = await AttendanceModel.getDailyAttendanceRecords(date, worker_id);
      
      res.json({
        success: true,
        data: records,
        message: '근태 기록을 성공적으로 조회했습니다.'
      });
    } catch (error) {
      console.error('근태 기록 조회 오류:', error);
      res.status(500).json({
        success: false,
        message: '근태 기록 조회 중 오류가 발생했습니다.',
        error: error.message
      });
    }
  }

  // 근태 기록 생성/업데이트
  static async upsertAttendanceRecord(req, res) {
    try {
      const {
        record_date,
        worker_id,
        total_work_hours,
        attendance_type_id,
        vacation_type_id,
        is_vacation_processed,
        overtime_approved,
        status,
        notes
      } = req.body;

      // 필수 필드 검증
      if (!record_date || !worker_id) {
        return res.status(400).json({
          success: false,
          message: '날짜와 작업자 ID가 필요합니다.'
        });
      }

      const recordData = {
        record_date,
        worker_id,
        total_work_hours: total_work_hours || 0,
        attendance_type_id,
        vacation_type_id,
        is_vacation_processed: is_vacation_processed || false,
        overtime_approved: overtime_approved || false,
        status: status || 'incomplete',
        notes,
        created_by: req.user.user_id
      };

      const result = await AttendanceModel.upsertAttendanceRecord(recordData);
      
      res.json({
        success: true,
        data: result,
        message: '근태 기록이 성공적으로 저장되었습니다.'
      });
    } catch (error) {
      console.error('근태 기록 저장 오류:', error);
      res.status(500).json({
        success: false,
        message: '근태 기록 저장 중 오류가 발생했습니다.',
        error: error.message
      });
    }
  }

  // 휴가 처리
  static async processVacation(req, res) {
    try {
      const { worker_id, date, vacation_type } = req.body;

      // 필수 필드 검증
      if (!worker_id || !date || !vacation_type) {
        return res.status(400).json({
          success: false,
          message: '작업자 ID, 날짜, 휴가 유형이 필요합니다.'
        });
      }

      // 휴가 유형 검증
      const validVacationTypes = ['ANNUAL_FULL', 'ANNUAL_HALF', 'ANNUAL_QUARTER'];
      if (!validVacationTypes.includes(vacation_type)) {
        return res.status(400).json({
          success: false,
          message: '유효하지 않은 휴가 유형입니다.'
        });
      }

      const result = await AttendanceModel.processVacation(
        worker_id,
        date,
        vacation_type,
        req.user.user_id
      );
      
      res.json({
        success: true,
        data: result,
        message: '휴가 처리가 성공적으로 완료되었습니다.'
      });
    } catch (error) {
      console.error('휴가 처리 오류:', error);
      res.status(500).json({
        success: false,
        message: '휴가 처리 중 오류가 발생했습니다.',
        error: error.message
      });
    }
  }

  // 초과근무 승인
  static async approveOvertime(req, res) {
    try {
      const { worker_id, date } = req.body;

      // 필수 필드 검증
      if (!worker_id || !date) {
        return res.status(400).json({
          success: false,
          message: '작업자 ID와 날짜가 필요합니다.'
        });
      }

      const result = await AttendanceModel.approveOvertime(
        worker_id,
        date,
        req.user.user_id
      );
      
      if (result) {
        res.json({
          success: true,
          message: '초과근무가 성공적으로 승인되었습니다.'
        });
      } else {
        res.status(404).json({
          success: false,
          message: '해당 날짜의 근태 기록을 찾을 수 없습니다.'
        });
      }
    } catch (error) {
      console.error('초과근무 승인 오류:', error);
      res.status(500).json({
        success: false,
        message: '초과근무 승인 중 오류가 발생했습니다.',
        error: error.message
      });
    }
  }

  // 근로 유형 목록 조회
  static async getAttendanceTypes(req, res) {
    try {
      const attendanceTypes = await AttendanceModel.getAttendanceTypes();
      
      res.json({
        success: true,
        data: attendanceTypes,
        message: '근로 유형 목록을 성공적으로 조회했습니다.'
      });
    } catch (error) {
      console.error('근로 유형 조회 오류:', error);
      res.status(500).json({
        success: false,
        message: '근로 유형 조회 중 오류가 발생했습니다.',
        error: error.message
      });
    }
  }

  // 휴가 유형 목록 조회
  static async getVacationTypes(req, res) {
    try {
      const vacationTypes = await AttendanceModel.getVacationTypes();
      
      res.json({
        success: true,
        data: vacationTypes,
        message: '휴가 유형 목록을 성공적으로 조회했습니다.'
      });
    } catch (error) {
      console.error('휴가 유형 조회 오류:', error);
      res.status(500).json({
        success: false,
        message: '휴가 유형 조회 중 오류가 발생했습니다.',
        error: error.message
      });
    }
  }

  // 작업자 휴가 잔여 조회
  static async getWorkerVacationBalance(req, res) {
    try {
      const { worker_id } = req.params;
      const { year } = req.query;

      if (!worker_id) {
        return res.status(400).json({
          success: false,
          message: '작업자 ID가 필요합니다.'
        });
      }

      const balance = await AttendanceModel.getWorkerVacationBalance(
        parseInt(worker_id),
        year ? parseInt(year) : null
      );
      
      res.json({
        success: true,
        data: balance,
        message: '휴가 잔여 정보를 성공적으로 조회했습니다.'
      });
    } catch (error) {
      console.error('휴가 잔여 조회 오류:', error);
      res.status(500).json({
        success: false,
        message: '휴가 잔여 조회 중 오류가 발생했습니다.',
        error: error.message
      });
    }
  }

  // 월별 근태 통계
  static async getMonthlyAttendanceStats(req, res) {
    try {
      const { year, month, worker_id } = req.query;

      if (!year || !month) {
        return res.status(400).json({
          success: false,
          message: '연도와 월이 필요합니다.'
        });
      }

      const stats = await AttendanceModel.getMonthlyAttendanceStats(
        parseInt(year),
        parseInt(month),
        worker_id ? parseInt(worker_id) : null
      );
      
      res.json({
        success: true,
        data: stats,
        message: '월별 근태 통계를 성공적으로 조회했습니다.'
      });
    } catch (error) {
      console.error('월별 근태 통계 조회 오류:', error);
      res.status(500).json({
        success: false,
        message: '월별 근태 통계 조회 중 오류가 발생했습니다.',
        error: error.message
      });
    }
  }
}

module.exports = AttendanceController;