const visitRequestModel = require('../models/visitRequestModel');
const logger = require('../utils/logger');

// ==================== 출입 신청 관리 ====================

exports.createVisitRequest = async (req, res) => {
  try {
    const requester_id = req.user.user_id;
    const requestData = { requester_id, ...req.body };

    const requiredFields = ['visitor_company', 'category_id', 'workplace_id', 'visit_date', 'visit_time', 'purpose_id'];
    for (const field of requiredFields) {
      if (!requestData[field]) {
        return res.status(400).json({ success: false, message: `${field}는 필수 입력 항목입니다.` });
      }
    }

    const requestId = await visitRequestModel.createVisitRequest(requestData);
    res.status(201).json({
      success: true,
      message: '출입 신청이 성공적으로 생성되었습니다.',
      data: { request_id: requestId }
    });
  } catch (err) {
    logger.error('출입 신청 생성 오류:', err);
    res.status(500).json({ success: false, message: '출입 신청 생성 중 오류가 발생했습니다.' });
  }
};

exports.getAllVisitRequests = async (req, res) => {
  try {
    const filters = {
      status: req.query.status,
      visit_date: req.query.visit_date,
      start_date: req.query.start_date,
      end_date: req.query.end_date,
      requester_id: req.query.requester_id,
      category_id: req.query.category_id
    };

    const requests = await visitRequestModel.getAllVisitRequests(filters);
    res.json({ success: true, data: requests });
  } catch (err) {
    logger.error('출입 신청 목록 조회 오류:', err);
    res.status(500).json({ success: false, message: '출입 신청 목록 조회 중 오류가 발생했습니다.' });
  }
};

exports.getVisitRequestById = async (req, res) => {
  try {
    const request = await visitRequestModel.getVisitRequestById(req.params.id);
    if (!request) {
      return res.status(404).json({ success: false, message: '출입 신청을 찾을 수 없습니다.' });
    }
    res.json({ success: true, data: request });
  } catch (err) {
    logger.error('출입 신청 조회 오류:', err);
    res.status(500).json({ success: false, message: '출입 신청 조회 중 오류가 발생했습니다.' });
  }
};

exports.updateVisitRequest = async (req, res) => {
  try {
    const result = await visitRequestModel.updateVisitRequest(req.params.id, req.body);
    if (result.affectedRows === 0) {
      return res.status(404).json({ success: false, message: '출입 신청을 찾을 수 없습니다.' });
    }
    res.json({ success: true, message: '출입 신청이 수정되었습니다.' });
  } catch (err) {
    logger.error('출입 신청 수정 오류:', err);
    res.status(500).json({ success: false, message: '출입 신청 수정 중 오류가 발생했습니다.' });
  }
};

exports.deleteVisitRequest = async (req, res) => {
  try {
    const result = await visitRequestModel.deleteVisitRequest(req.params.id);
    if (result.affectedRows === 0) {
      return res.status(404).json({ success: false, message: '출입 신청을 찾을 수 없습니다.' });
    }
    res.json({ success: true, message: '출입 신청이 삭제되었습니다.' });
  } catch (err) {
    logger.error('출입 신청 삭제 오류:', err);
    res.status(500).json({ success: false, message: '출입 신청 삭제 중 오류가 발생했습니다.' });
  }
};

exports.approveVisitRequest = async (req, res) => {
  try {
    const result = await visitRequestModel.approveVisitRequest(req.params.id, req.user.user_id);
    if (result.affectedRows === 0) {
      return res.status(404).json({ success: false, message: '출입 신청을 찾을 수 없습니다.' });
    }
    res.json({ success: true, message: '출입 신청이 승인되었습니다.' });
  } catch (err) {
    logger.error('출입 신청 승인 오류:', err);
    res.status(500).json({ success: false, message: '출입 신청 승인 중 오류가 발생했습니다.' });
  }
};

exports.rejectVisitRequest = async (req, res) => {
  try {
    const rejectionData = {
      approved_by: req.user.user_id,
      rejection_reason: req.body.rejection_reason || '사유 없음'
    };
    const result = await visitRequestModel.rejectVisitRequest(req.params.id, rejectionData);
    if (result.affectedRows === 0) {
      return res.status(404).json({ success: false, message: '출입 신청을 찾을 수 없습니다.' });
    }
    res.json({ success: true, message: '출입 신청이 반려되었습니다.' });
  } catch (err) {
    logger.error('출입 신청 반려 오류:', err);
    res.status(500).json({ success: false, message: '출입 신청 반려 중 오류가 발생했습니다.' });
  }
};

// ==================== 방문 목적 관리 ====================

exports.getAllVisitPurposes = async (req, res) => {
  try {
    const purposes = await visitRequestModel.getAllVisitPurposes();
    res.json({ success: true, data: purposes });
  } catch (err) {
    logger.error('방문 목적 조회 오류:', err);
    res.status(500).json({ success: false, message: '방문 목적 조회 중 오류가 발생했습니다.' });
  }
};

exports.getActiveVisitPurposes = async (req, res) => {
  try {
    const purposes = await visitRequestModel.getActiveVisitPurposes();
    res.json({ success: true, data: purposes });
  } catch (err) {
    logger.error('활성 방문 목적 조회 오류:', err);
    res.status(500).json({ success: false, message: '활성 방문 목적 조회 중 오류가 발생했습니다.' });
  }
};

exports.createVisitPurpose = async (req, res) => {
  try {
    if (!req.body.purpose_name) {
      return res.status(400).json({ success: false, message: 'purpose_name은 필수 입력 항목입니다.' });
    }
    const purposeId = await visitRequestModel.createVisitPurpose(req.body);
    res.status(201).json({
      success: true,
      message: '방문 목적이 추가되었습니다.',
      data: { purpose_id: purposeId }
    });
  } catch (err) {
    logger.error('방문 목적 추가 오류:', err);
    res.status(500).json({ success: false, message: '방문 목적 추가 중 오류가 발생했습니다.' });
  }
};

exports.updateVisitPurpose = async (req, res) => {
  try {
    const result = await visitRequestModel.updateVisitPurpose(req.params.id, req.body);
    if (result.affectedRows === 0) {
      return res.status(404).json({ success: false, message: '방문 목적을 찾을 수 없습니다.' });
    }
    res.json({ success: true, message: '방문 목적이 수정되었습니다.' });
  } catch (err) {
    logger.error('방문 목적 수정 오류:', err);
    res.status(500).json({ success: false, message: '방문 목적 수정 중 오류가 발생했습니다.' });
  }
};

exports.deleteVisitPurpose = async (req, res) => {
  try {
    const result = await visitRequestModel.deleteVisitPurpose(req.params.id);
    if (result.affectedRows === 0) {
      return res.status(404).json({ success: false, message: '방문 목적을 찾을 수 없습니다.' });
    }
    res.json({ success: true, message: '방문 목적이 삭제되었습니다.' });
  } catch (err) {
    logger.error('방문 목적 삭제 오류:', err);
    res.status(500).json({ success: false, message: '방문 목적 삭제 중 오류가 발생했습니다.' });
  }
};

// ==================== 안전교육 기록 관리 ====================

exports.createTrainingRecord = async (req, res) => {
  try {
    const trainingData = { trainer_id: req.user.user_id, ...req.body };

    const requiredFields = ['request_id', 'training_date', 'training_start_time'];
    for (const field of requiredFields) {
      if (!trainingData[field]) {
        return res.status(400).json({ success: false, message: `${field}는 필수 입력 항목입니다.` });
      }
    }

    const trainingId = await visitRequestModel.createTrainingRecord(trainingData);

    // 안전교육 기록 생성 후 출입 신청 상태를 training_completed로 변경
    try {
      await visitRequestModel.updateVisitRequestStatus(trainingData.request_id, 'training_completed');
    } catch (statusErr) {
      logger.error('출입 신청 상태 업데이트 오류:', statusErr);
    }

    res.status(201).json({
      success: true,
      message: '안전교육 기록이 생성되었습니다.',
      data: { training_id: trainingId }
    });
  } catch (err) {
    logger.error('안전교육 기록 생성 오류:', err);
    res.status(500).json({ success: false, message: '안전교육 기록 생성 중 오류가 발생했습니다.' });
  }
};

exports.getTrainingRecordByRequestId = async (req, res) => {
  try {
    const record = await visitRequestModel.getTrainingRecordByRequestId(req.params.requestId);
    res.json({ success: true, data: record || null });
  } catch (err) {
    logger.error('안전교육 기록 조회 오류:', err);
    res.status(500).json({ success: false, message: '안전교육 기록 조회 중 오류가 발생했습니다.' });
  }
};

exports.updateTrainingRecord = async (req, res) => {
  try {
    const result = await visitRequestModel.updateTrainingRecord(req.params.id, req.body);
    if (result.affectedRows === 0) {
      return res.status(404).json({ success: false, message: '안전교육 기록을 찾을 수 없습니다.' });
    }
    res.json({ success: true, message: '안전교육 기록이 수정되었습니다.' });
  } catch (err) {
    logger.error('안전교육 기록 수정 오류:', err);
    res.status(500).json({ success: false, message: '안전교육 기록 수정 중 오류가 발생했습니다.' });
  }
};

exports.completeTraining = async (req, res) => {
  try {
    const trainingId = req.params.id;
    const signatureData = req.body.signature_data;

    if (!signatureData) {
      return res.status(400).json({ success: false, message: '서명 데이터가 필요합니다.' });
    }

    const result = await visitRequestModel.completeTraining(trainingId, signatureData);
    if (result.affectedRows === 0) {
      return res.status(404).json({ success: false, message: '안전교육 기록을 찾을 수 없습니다.' });
    }

    // 교육 완료 후 출입 신청 상태 변경
    try {
      const record = await visitRequestModel.getTrainingRecordByRequestId(trainingId);
      if (record) {
        await visitRequestModel.updateVisitRequestStatus(record.request_id, 'training_completed');
      }
    } catch (statusErr) {
      logger.error('출입 신청 상태 업데이트 오류:', statusErr);
    }

    res.json({ success: true, message: '안전교육이 완료되었습니다.' });
  } catch (err) {
    logger.error('안전교육 완료 처리 오류:', err);
    res.status(500).json({ success: false, message: '안전교육 완료 처리 중 오류가 발생했습니다.' });
  }
};

exports.getTrainingRecords = async (req, res) => {
  try {
    const filters = {
      training_date: req.query.training_date,
      start_date: req.query.start_date,
      end_date: req.query.end_date,
      trainer_id: req.query.trainer_id
    };
    const records = await visitRequestModel.getTrainingRecords(filters);
    res.json({ success: true, data: records });
  } catch (err) {
    logger.error('안전교육 기록 목록 조회 오류:', err);
    res.status(500).json({ success: false, message: '안전교육 기록 목록 조회 중 오류가 발생했습니다.' });
  }
};