/**
 * GIS 모니터링 API 모듈
 */

const API_BASE = '/api/v1';

/**
 * Haegu (해구) 관련 API
 */
export const HaeguAPI = {
    /**
     * Haegu 경계 데이터 조회
     */
    async getBoundaries() {
        const response = await fetch(`${API_BASE}/haegu/boundaries`);
        if (!response.ok) throw new Error('Failed to load haegu boundaries');
        return response.json();
    },

    /**
     * Haegu 선박 통계 조회
     * @param {number} minutes - 조회 시간 범위 (분)
     */
    async getVesselStats(minutes) {
        const response = await fetch(`${API_BASE}/haegu/vessel-stats?minutes=${minutes}`);
        if (!response.ok) throw new Error('Failed to load haegu vessel stats');
        return response.json();
    },

    /**
     * 특정 Haegu의 트랙 조회
     * @param {string} haeguNo - Haegu 번호
     * @param {number} minutes - 조회 시간 범위 (분)
     */
    async getTracks(haeguNo, minutes) {
        const response = await fetch(`${API_BASE}/tracks/haegu/${haeguNo}?minutes=${minutes}`);
        if (!response.ok) throw new Error('Failed to load haegu tracks');
        return response.json();
    }
};

/**
 * Area (사용자 정의 구역) 관련 API
 */
export const AreaAPI = {
    /**
     * Area 경계 데이터 조회
     */
    async getBoundaries() {
        const response = await fetch(`${API_BASE}/areas/boundaries`);
        if (!response.ok) throw new Error('Failed to load area boundaries');
        return response.json();
    },

    /**
     * Area 선박 통계 조회
     * @param {number} minutes - 조회 시간 범위 (분)
     */
    async getVesselStats(minutes) {
        const response = await fetch(`${API_BASE}/areas/vessel-stats?minutes=${minutes}`);
        if (!response.ok) throw new Error('Failed to load area vessel stats');
        return response.json();
    },

    /**
     * 특정 Area의 트랙 조회
     * @param {string} areaId - Area ID
     * @param {number} minutes - 조회 시간 범위 (분)
     */
    async getTracks(areaId, minutes) {
        const response = await fetch(`${API_BASE}/tracks/area/${areaId}?minutes=${minutes}`);
        if (!response.ok) throw new Error('Failed to load area tracks');
        return response.json();
    }
};

/**
 * 트랙 관련 API
 */
export const TrackAPI = {
    /**
     * 구역별 트랙 조회 (통합)
     * @param {string} type - 'haegu' 또는 'area'
     * @param {string} id - 구역 ID
     * @param {number} minutes - 조회 시간 범위 (분)
     */
    async getByArea(type, id, minutes) {
        const response = await fetch(`${API_BASE}/tracks/${type}/${id}?minutes=${minutes}`);
        if (!response.ok) throw new Error(`Failed to load ${type} tracks`);
        return response.json();
    },

    /**
     * 특정 선박들의 트랙 조회
     * @param {Object} params - 조회 파라미터
     */
    async getVesselTracks(params) {
        const response = await fetch(`${API_BASE}/tracks/vessels`, {
            method: 'POST',
            headers: { 'Content-Type': 'application/json' },
            body: JSON.stringify(params)
        });
        if (!response.ok) throw new Error('Failed to load vessel tracks');
        return response.json();
    }
};

/**
 * Sequential Passage 관련 API
 */
export const PassageAPI = {
    /**
     * 순차 통과 선박 검색
     * @param {Object} params - 검색 파라미터
     */
    async searchSequential(params) {
        const response = await fetch(`${API_BASE}/passages/sequential`, {
            method: 'POST',
            headers: { 'Content-Type': 'application/json' },
            body: JSON.stringify(params)
        });
        if (!response.ok) throw new Error('Failed to search sequential passages');
        return response.json();
    },

    /**
     * 전체 구역 통과 선박 검색
     * @param {Object} params - 검색 파라미터
     */
    async searchAllZones(params) {
        const response = await fetch(`${API_BASE}/passages/all-zones`, {
            method: 'POST',
            headers: { 'Content-Type': 'application/json' },
            body: JSON.stringify(params)
        });
        if (!response.ok) throw new Error('Failed to search all zones passages');
        return response.json();
    }
};

/**
 * API 호출 헬퍼 함수
 */
export class APIHelper {
    /**
     * 병렬 API 호출
     * @param {Array<Promise>} promises - API 호출 프로미스 배열
     * @returns {Promise<Array>} 결과 배열
     */
    static async parallel(promises) {
        try {
            return await Promise.all(promises);
        } catch (error) {
            console.error('Parallel API call failed:', error);
            throw error;
        }
    }

    /**
     * 재시도 로직이 포함된 API 호출
     * @param {Function} apiCall - API 호출 함수
     * @param {number} maxRetries - 최대 재시도 횟수
     * @param {number} delay - 재시도 간격 (ms)
     */
    static async withRetry(apiCall, maxRetries = 3, delay = 1000) {
        let lastError;
        
        for (let i = 0; i < maxRetries; i++) {
            try {
                return await apiCall();
            } catch (error) {
                lastError = error;
                if (i < maxRetries - 1) {
                    await new Promise(resolve => setTimeout(resolve, delay));
                }
            }
        }
        
        throw lastError;
    }

    /**
     * 타임스탬프 포맷팅
     * @param {string} timestamp - 타임스탬프
     * @returns {string} 포맷된 타임스탬프
     */
    static formatTimestamp(timestamp) {
        if (!timestamp) return '';
        
        // T 형식이 포함된 경우 초 추가
        if (timestamp.includes('T') && !timestamp.includes(':00', timestamp.lastIndexOf(':'))) {
            return timestamp + ':00';
        }
        
        return timestamp;
    }
}