/**
 * GIS 유틸리티 함수
 */

/**
 * LineStringM WKT 파싱
 * @param {string} wkt - WKT 문자열
 * @returns {Array} 좌표 배열 [[lon, lat], ...]
 */
export function parseLineStringM(wkt) {
    if (!wkt) return [];
    
    const matches = wkt.match(/LINESTRING M\s*\((.*)\)/);
    if (!matches) return [];
    
    try {
        const coords = matches[1].split(',').map(coord => {
            const parts = coord.trim().split(/\s+/);
            const lon = parseFloat(parts[0]);
            const lat = parseFloat(parts[1]);
            
            if (isNaN(lon) || isNaN(lat)) return null;
            
            return [lon, lat];
        }).filter(coord => coord !== null);
        
        return coords;
    } catch (error) {
        console.error('Error parsing LineStringM:', error);
        return [];
    }
}

/**
 * 선박 수에 따른 색상 계산
 * @param {number} count - 선박 수
 * @returns {Array} RGBA 색상 배열
 */
export function getVesselCountColor(count) {
    if (count >= 200) return [255, 69, 0, 150];    // 빨강
    if (count >= 100) return [255, 165, 0, 150];   // 주황
    if (count >= 50) return [255, 215, 0, 150];    // 금색
    if (count >= 10) return [144, 238, 144, 150];  // 연두
    if (count > 0) return [224, 224, 224, 150];    // 연회색
    return [224, 224, 224, 50];                    // 투명 회색
}

/**
 * 속도에 따른 트랙 색상 계산
 * @param {number} speed - 속도 (knots)
 * @param {boolean} selected - 선택 여부
 * @returns {Array} RGBA 색상 배열
 */
export function getTrackColor(speed, selected = false) {
    if (selected) return [0, 128, 255, 255];       // 파랑 (선택됨)
    if (speed > 20) return [255, 0, 0, 200];       // 빨강 (고속)
    if (speed > 10) return [255, 165, 0, 200];     // 주황 (중속)
    return [0, 255, 0, 200];                        // 초록 (저속)
}

/**
 * 좌표 배열로부터 경계 계산
 * @param {Array} coordinates - 좌표 배열
 * @returns {Object} 경계 객체 {minLng, minLat, maxLng, maxLat}
 */
export function calculateBounds(coordinates) {
    if (!coordinates || coordinates.length === 0) {
        return null;
    }
    
    let minLng = Infinity, minLat = Infinity;
    let maxLng = -Infinity, maxLat = -Infinity;
    
    coordinates.forEach(coord => {
        if (Array.isArray(coord) && coord.length >= 2) {
            minLng = Math.min(minLng, coord[0]);
            maxLng = Math.max(maxLng, coord[0]);
            minLat = Math.min(minLat, coord[1]);
            maxLat = Math.max(maxLat, coord[1]);
        }
    });
    
    return {
        minLng,
        minLat,
        maxLng,
        maxLat
    };
}

/**
 * 트랙 데이터 처리 및 병합
 * @param {Array} tracks - 원시 트랙 데이터
 * @returns {Object} 선박별로 병합된 트랙 데이터
 */
export function processVesselTracks(tracks) {
    const vesselTracks = {};
    
    tracks.forEach(track => {
        const vesselId = `${track.sig_src_cd}_${track.target_id}`;
        
        if (!vesselTracks[vesselId]) {
            vesselTracks[vesselId] = {
                vessel_id: vesselId,
                sig_src_cd: track.sig_src_cd,
                target_id: track.target_id,
                tracks: [],
                total_distance: 0,
                speeds: [],
                times: []
            };
        }
        
        vesselTracks[vesselId].tracks.push(track);
        vesselTracks[vesselId].total_distance += parseFloat(track.distance_nm) || 0;
        vesselTracks[vesselId].speeds.push(parseFloat(track.avg_speed) || 0);
        vesselTracks[vesselId].times.push(new Date(track.time_bucket));
    });
    
    // 시간순 정렬 및 통계 계산
    Object.values(vesselTracks).forEach(vessel => {
        vessel.tracks.sort((a, b) => new Date(a.time_bucket) - new Date(b.time_bucket));
        vessel.avg_speed = vessel.speeds.reduce((a, b) => a + b, 0) / vessel.speeds.length;
        vessel.max_speed = Math.max(...vessel.speeds);
        vessel.min_speed = Math.min(...vessel.speeds);
        vessel.start_time = vessel.times[0];
        vessel.end_time = vessel.times[vessel.times.length - 1];
    });
    
    return vesselTracks;
}

/**
 * 트랙 포인트 병합
 * @param {Array} tracks - 트랙 배열
 * @returns {Array} 병합된 포인트 배열
 */
export function mergeTrackPoints(tracks) {
    const allPoints = [];
    
    tracks.forEach(track => {
        const points = parseLineStringM(track.track_geom);
        allPoints.push(...points);
    });
    
    return allPoints;
}

/**
 * 거리 포맷팅
 * @param {number} distance - 거리 (nm)
 * @param {number} decimals - 소수점 자리수
 * @returns {string} 포맷된 거리
 */
export function formatDistance(distance, decimals = 2) {
    if (distance === null || distance === undefined) return '-';
    return `${distance.toFixed(decimals)} nm`;
}

/**
 * 속도 포맷팅
 * @param {number} speed - 속도 (knots)
 * @param {number} decimals - 소수점 자리수
 * @returns {string} 포맷된 속도
 */
export function formatSpeed(speed, decimals = 1) {
    if (speed === null || speed === undefined) return '-';
    return `${speed.toFixed(decimals)} kts`;
}

/**
 * 시간 포맷팅
 * @param {string|Date} time - 시간
 * @returns {string} 포맷된 시간
 */
export function formatTime(time) {
    if (!time) return '-';
    const date = new Date(time);
    return date.toLocaleString('ko-KR', {
        year: 'numeric',
        month: '2-digit',
        day: '2-digit',
        hour: '2-digit',
        minute: '2-digit'
    });
}

/**
 * 최근 위치 추출
 * @param {Array} tracks - 트랙 배열
 * @returns {Array} 최신 위치 배열
 */
export function extractLatestPositions(tracks) {
    const latestPositions = {};
    
    tracks.forEach(track => {
        const vesselId = `${track.sig_src_cd}_${track.target_id}`;
        const path = parseLineStringM(track.track_geom);
        
        if (path.length > 0) {
            const trackTime = new Date(track.time_bucket);
            
            if (!latestPositions[vesselId] || 
                trackTime > new Date(latestPositions[vesselId].time)) {
                latestPositions[vesselId] = {
                    position: path[path.length - 1],
                    vessel_id: vesselId,
                    sig_src_cd: track.sig_src_cd,
                    target_id: track.target_id,
                    time: track.time_bucket,
                    speed: parseFloat(track.avg_speed) || 0,
                    distance: parseFloat(track.distance_nm) || 0
                };
            }
        }
    });
    
    return Object.values(latestPositions);
}

/**
 * 구역 ID 정규화
 * @param {string} zoneId - 구역 ID
 * @returns {string} 정규화된 ID
 */
export function normalizeZoneId(zoneId) {
    if (!zoneId) return '';
    return String(zoneId).trim();
}

/**
 * 선박 ID 파싱
 * @param {string} vesselId - 선박 ID (형식: sigSrcCd_targetId)
 * @returns {Object} {sigSrcCd, targetId}
 */
export function parseVesselId(vesselId) {
    if (!vesselId) return { sigSrcCd: '', targetId: '' };
    
    const [sigSrcCd, ...targetIdParts] = vesselId.split('_');
    const targetId = targetIdParts.join('_'); // targetId에 언더스코어가 포함된 경우 처리
    
    return { sigSrcCd, targetId };
}

/**
 * 필터 조건 검증
 * @param {Object} track - 트랙 데이터
 * @param {Object} filters - 필터 조건
 * @returns {boolean} 필터 통과 여부
 */
export function passesFilters(track, filters) {
    const { minSpeed = 0, maxSpeed = Infinity, minDist = 0, maxDist = Infinity } = filters;
    
    const speed = track.avg_speed || 0;
    const distance = track.distance || 0;
    
    return speed >= minSpeed && 
           speed <= maxSpeed && 
           distance >= minDist && 
           distance <= maxDist;
}