import apiClient from './api';
import dayjs from 'dayjs';

/**
 * 이벤트 서비스 - 이벤트 관련 API 호출을 처리하는 서비스
 */
export default {
  /**
   * 모든 이벤트 목록 가져오기
   * @param {number} clubId - 클럽 ID
   * @returns {Promise<Array>} 이벤트 목록
   */
  async getEvents(clubId) {
    if (!clubId) {
      throw new Error('클럽 ID가 필요합니다.');
    }

    try {
      const response = await apiClient.post('/api/club/events', { clubId });
      return response.data;
    } catch (error) {
      // 원래 오류 객체 그대로 전달하여 HTTP 상태 코드 확인 가능하게 함
      if (error.response) {
        console.error('이벤트 목록 오류:', {
          status: error.response.status,
          data: error.response.data
        });
        throw error;
      }
      throw error;
    }
  },

  /**
   * 특정 이벤트 상세 정보 가져오기
   * @param {number} id - 이벤트 ID
   * @returns {Promise<Object>} 이벤트 상세 정보
   */
  async getEventById(id) {
    if (!id) {
      throw new Error('이벤트 ID가 필요합니다.');
    }

    try {
      const response = await apiClient.get(`/api/club/events/${id}`);
      return response.data;
    } catch (error) {
      if (error.response && error.response.data && error.response.data.message) {
        throw new Error(error.response.data.message);
      }
      throw error;
    }
  },

  /**
   * 새 이벤트 추가
   * @param {Object} event - 이벤트 객체
   * @returns {Promise<Object>} 생성된 이벤트 객체
   */
  async createEvent(event) {
    if (!event) {
      throw new Error('이벤트 객체가 필요합니다.');
    }

    try {
      const formattedEvent = {
        ...event,
        startDate: dayjs(event.startDate).format('YYYY-MM-DDTHH:mm:ssZ'),
        endDate: event.endDate ? dayjs(event.endDate).format('YYYY-MM-DDTHH:mm:ssZ') : null
      };
      
      const response = await apiClient.post('/api/club/events/create', formattedEvent);
      return response.data;
    } catch (error) {
      if (error.response && error.response.data && error.response.data.message) {
        throw new Error(error.response.data.message);
      }
      throw error;
    }
  },

  /**
   * 기존 이벤트 수정
   * @param {Object} event - 수정할 이벤트 객체
   * @returns {Promise<Object>} 수정된 이벤트 객체
   */
  async updateEvent(event) {
    if (!event) {
      throw new Error('이벤트 객체가 필요합니다.');
    }

    try {
      const formattedEvent = {
        ...event,
        startDate: dayjs(event.startDate).format('YYYY-MM-DDTHH:mm:ssZ'),
        endDate: event.endDate ? dayjs(event.endDate).format('YYYY-MM-DDTHH:mm:ssZ') : null
      };
      
      const response = await apiClient.put(`/api/club/events/${event.id}`, formattedEvent);
      return response.data;
    } catch (error) {
      if (error.response && error.response.data && error.response.data.message) {
        throw new Error(error.response.data.message);
      }
      throw error;
    }
  },

  /**
   * 이벤트 삭제
   * @param {number} clubId - 클럽 ID
   * @param {number} id - 삭제할 이벤트 ID
   * @returns {Promise<void>}
   */
  async deleteEvent(clubId, id) {
    if (!clubId || !id) {
      throw new Error('클럽 ID와 이벤트 ID가 필요합니다.');
    }

    try {
      await apiClient.delete(`/api/club/events/${id}`, {
        data: { clubId }
      });
    } catch (error) {
      if (error.response && error.response.data && error.response.data.message) {
        throw new Error(error.response.data.message);
      }
      throw error;
    }
  },

  /**
   * 이벤트 참가자 목록 조회
   * @param {number} eventId - 이벤트 ID
   * @returns {Promise<Array>} 참가자 목록
   */
  async getEventParticipants(eventId) {
    if (!eventId) {
      throw new Error('이벤트 ID가 필요합니다.');
    }

    try {
      const response = await apiClient.post(`/api/club/events/${eventId}/participants/list`, {
        eventId,
        clubId: localStorage.getItem('clubId')
      });
      return response.data.participants;
    } catch (error) {
      if (error.response && error.response.data && error.response.data.message) {
        throw new Error(error.response.data.message);
      }
      throw error;
    }
  },

  /**
   * 이벤트 참가자 추가
   * @param {number} eventId - 이벤트 ID
   * @param {Object} participant - 참가자 정보
   * @returns {Promise<Object>} 추가된 참가자 정보
   */
  async addEventParticipant(eventId, participant) {
    if (!eventId || !participant) {
      throw new Error('이벤트 ID와 참가자 정보가 필요합니다.');
    }

    try {
      const response = await apiClient.post(`/api/club/events/${eventId}/participants`, participant);
      return response.data;
    } catch (error) {
      if (error.response && error.response.data && error.response.data.message) {
        throw new Error(error.response.data.message);
      }
      throw error;
    }
  },

  /**
   * 참가자 정보 수정
   * @param {number} eventId - 이벤트 ID
   * @param {Object} participant - 수정할 참가자 정보
   * @returns {Promise<Object>} 수정된 참가자 정보
   */
  async updateEventParticipant(eventId, participant) {
    if (!eventId || !participant) {
      throw new Error('이벤트 ID와 참가자 정보가 필요합니다.');
    }

    try {
      const response = await apiClient.put(`/api/club/events/${eventId}/participants`, participant);
      return response.data;
    } catch (error) {
      if (error.response && error.response.data && error.response.data.message) {
        throw new Error(error.response.data.message);
      }
      throw error;
    }
  },

  /**
   * 참가자 제거
   * @param {number} eventId - 이벤트 ID
   * @param {Object} participant - 제거할 참가자 정보
   * @returns {Promise<void>}
   */
  async removeEventParticipant(eventId, participant) {
    if (!eventId || !participant) {
      throw new Error('이벤트 ID와 참가자 정보가 필요합니다.');
    }

    try {
      await apiClient.delete(`/api/club/events/${eventId}/participants`, {
        data: participant
      });
    } catch (error) {
      if (error.response && error.response.data && error.response.data.message) {
        throw new Error(error.response.data.message);
      }
      throw error;
    }
  },

  /**
   * 참가자 상태 수정
   * @param {number} eventId - 이벤트 ID
   * @param {number} userId - 사용자 ID
   * @param {string} status - 변경할 상태
   * @returns {Promise<Object>} 수정된 참가자 정보
   */
  async updateParticipantStatus(eventId, userId, status) {
    if (!eventId || !userId || !status) {
      throw new Error('이벤트 ID, 사용자 ID, 상태가 필요합니다.');
    }

    try {
      const response = await apiClient.put(`/api/club/events/${eventId}/participants/${userId}/status`, { status });
      return response.data;
    } catch (error) {
      if (error.response && error.response.data && error.response.data.message) {
        throw new Error(error.response.data.message);
      }
      throw error;
    }
  },

  /**
   * 점수 조회
   * @param {number} eventId - 이벤트 ID
   * @returns {Promise<Array>} 점수 목록
   */
  async getEventScores(eventId) {
    if (!eventId) {
      throw new Error('이벤트 ID가 필요합니다.');
    }

    try {
      const response = await apiClient.get(`/api/club/events/${eventId}/scores`);
      return response.data;
    } catch (error) {
      throw new Error(error.response?.data?.message || '점수 조회 중 오류가 발생했습니다.');
    }
  },

  /**
   * 점수 등록
   * @param {number} eventId - 이벤트 ID
   * @param {Object} scoreData - 점수 정보
   * @returns {Promise<Object>} 등록된 점수 정보
   */
  async addScore(eventId, scoreData) {
    if (!eventId || !scoreData) {
      throw new Error('이벤트 ID와 점수 정보가 필요합니다.');
    }

    try {
      const response = await apiClient.post(`/api/club/events/${eventId}/scores`, {
        participantId: scoreData.participantId,
        teamNumber: scoreData.teamNumber,
        gameNumber: scoreData.gameNumber,
        score: scoreData.score,
        handicap: scoreData.handicap
      });
      return response.data;
    } catch (error) {
      throw new Error(error.response?.data?.message || '점수 등록 중 오류가 발생했습니다.');
    }
  },

  /**
   * 점수 수정
   * @param {number} eventId - 이벤트 ID
   * @param {number} scoreId - 점수 ID
   * @param {Object} scoreData - 수정할 점수 정보
   * @returns {Promise<Object>} 수정된 점수 정보
   */
  async updateScore(eventId, scoreId, scoreData) {
    if (!eventId || !scoreId || !scoreData) {
      throw new Error('이벤트 ID, 점수 ID, 점수 정보가 필요합니다.');
    }

    if (scoreData.gameNumber === undefined || scoreData.gameNumber === null ||
        scoreData.score === undefined || scoreData.score === null) {
      throw new Error('게임 번호와 점수는 필수입니다.');
    }

    try {
      // URL 파라미터 문자열로 변환
      const url = `/api/club/events/${String(eventId)}/scores/${String(scoreId)}`;
      
      const payload = {
        gameNumber: Number(scoreData.gameNumber),
        score: scoreData.score !== null ? Number(scoreData.score) : undefined,
        handicap: scoreData.handicap !== null ? Number(scoreData.handicap) : 0
      };

      console.log('Updating score:', {
        url,
        eventId,
        scoreId,
        payload
      });

      const response = await apiClient.put(url, payload);
      return response.data;
    } catch (error) {
      console.error('Score update error:', {
        error: error.response?.data,
        status: error.response?.status,
        statusText: error.response?.statusText
      });
      throw new Error(error.response?.data?.message || '점수 수정 중 오류가 발생했습니다.');
    }
  },

  /**
   * 점수 삭제
   * @param {number} eventId - 이벤트 ID
   * @param {number} scoreId - 점수 ID
   * @returns {Promise<void>}
   */
  async deleteScore(eventId, scoreId) {
    if (!eventId || !scoreId) {
      throw new Error('이벤트 ID와 점수 ID가 필요합니다.');
    }

    try {
      const response = await apiClient.delete(`/api/club/events/${eventId}/scores/${scoreId}`);
      return response.data;
    } catch (error) {
      throw new Error(error.response?.data?.message || '점수 삭제 중 오류가 발생했습니다.');
    }
  },

  /**
   * 참가자의 모든 점수 삭제
   * @param {number} eventId - 이벤트 ID
   * @param {number} participantId - 참가자 ID
   * @returns {Promise<Object>} 삭제 결과
   */
  async deleteParticipantScores(eventId, participantId) {
    if (!eventId || !participantId) {
      throw new Error('이벤트 ID와 참가자 ID가 필요합니다.');
    }

    try {
      const response = await apiClient.delete(`/api/club/events/${eventId}/participants/${participantId}/scores`);
      return response.data;
    } catch (error) {
      if (error.response && error.response.data && error.response.data.message) {
        throw new Error(error.response.data.message);
      }
      throw error;
    }
  },

  /**
   * 파일 업로드 후 파싱 요청
   * @param {Object} data - 파일명과 클럽ID 정보
   * @returns {Promise<Object>} 파싱된 데이터
   */
  async parseEventFile(data) {
    if (!data.filename || !data.clubId) {
      throw new Error('파일명과 클럽 ID가 필요합니다.');
    }

    try {
      const response = await apiClient.post('/api/club/events/parse-preview', data);
      return response.data;
    } catch (error) {
      if (error.response && error.response.data && error.response.data.message) {
        throw new Error(error.response.data.message);
      }
      throw error;
    }
  },

  /**
   * 파일 업로드 URL 가져오기
   * @param {number} clubId - 클럽 ID
   * @returns {string} 파일 업로드 URL
   */
  getFileUploadUrl(clubId) {
    if (!clubId) {
      throw new Error('클럽 ID가 필요합니다.');
    }
    return `/api/club/events/upload?clubId=${clubId}`;
  },
  
  /**
   * 파일 업로드 함수
   * @param {File} file - 업로드할 파일
   * @param {number} clubId - 클럽 ID
   * @returns {Promise<Object>} 업로드 결과
   */
  async uploadFile(file, clubId) {
    if (!file || !clubId) {
      throw new Error('파일과 클럽 ID가 필요합니다.');
    }

    const formData = new FormData();
    formData.append('file', file);
    formData.append('clubId', clubId);

    try {
      const response = await apiClient.post('/api/club/events/upload', formData, {
        headers: {
          'Content-Type': 'multipart/form-data'
        }
      });
      return response.data;
    } catch (error) {
      console.error('파일 업로드 오류:', error);
      if (error.response && error.response.data && error.response.data.message) {
        throw new Error(error.response.data.message);
      }
      throw error;
    }
  },
  
  /**
   * 이벤트 파일 데이터 저장
   * @param {Object} data - 이벤트 데이터, 참가자 데이터, 클럽 ID
   * @returns {Promise<Object>} 저장된 이벤트 정보
   */
  async saveEventFileData(data) {
    if (!data.eventData || !data.participants || !data.clubId) {
      throw new Error('이벤트 정보, 참가자 정보, 클럽 ID가 필요합니다.');
    }

    try {
      const response = await apiClient.post('/api/club/events/save-file-data', data);
      return response.data;
    } catch (error) {
      if (error.response && error.response.data && error.response.data.message) {
        throw new Error(error.response.data.message);
      }
      throw error;
    }
  },

  /**
   * 업로드된 임시 파일 삭제
   * @param {Object} data - 파일명 정보
   * @returns {Promise<Object>} 삭제 결과
   */
  async deleteUploadedFile(data) {
    if (!data.filename) {
      throw new Error('파일명이 필요합니다.');
    }

    try {
      const response = await apiClient.post('/api/club/events/delete-file', data);
      return response.data;
    } catch (error) {
      if (error.response && error.response.data && error.response.data.message) {
        throw new Error(error.response.data.message);
      }
      throw error;
    }
  },

  /**
   * 이벤트 파일 업로드 URL 생성
   * @param {number} clubId - 클럽 ID
   * @returns {string} 파일 업로드 URL
   */
  getFileUploadUrl(clubId) {
    if (!clubId) {
      throw new Error('클럽 ID가 필요합니다.');
    }
    return `/api/club/events/upload`;
  }
};
