/**
 * 통계 패널 컴포넌트
 */

import { getTypeLabel, getColorByType, formatDistance, getPeriodLabel } from '../utils/helpers.js';

export class StatisticsPanel {
    constructor() {
        this.totalCountEl = null;
        this.vesselCountEl = null;
        this.avgDistanceEl = null;
        this.legendContentEl = null;
        this.legendTitleEl = null;
    }

    /**
     * 초기화
     */
    init() {
        this.totalCountEl = document.getElementById('totalCount');
        this.vesselCountEl = document.getElementById('vesselCount');
        this.avgDistanceEl = document.getElementById('avgDistance');
        this.legendContentEl = document.getElementById('legendContent');
        this.legendTitleEl = document.getElementById('legendTitle');
    }

    /**
     * 통계 업데이트
     * @param {Array} tracks - 궤적 데이터
     */
    updateStatistics(tracks) {
        const uniqueVessels = new Set();
        let totalDistance = 0;
        
        tracks.forEach(track => {
            uniqueVessels.add(track.vesselId);
            totalDistance += parseFloat(track.distanceNm) || 0;
        });
        
        // 카운트 업데이트
        if (this.totalCountEl) {
            this.totalCountEl.textContent = tracks.length;
        }
        
        if (this.vesselCountEl) {
            this.vesselCountEl.textContent = uniqueVessels.size;
        }
        
        // 평균 거리 계산
        if (this.avgDistanceEl) {
            if (tracks.length > 0) {
                const avgDist = (totalDistance / tracks.length).toFixed(1);
                this.avgDistanceEl.textContent = `${avgDist} nm`;
            } else {
                this.avgDistanceEl.textContent = '0 nm';
            }
        }
    }

    /**
     * 범례 업데이트
     * @param {Array} tracks - 궤적 데이터
     * @param {Map} vesselGroups - 선박별 그룹 데이터
     * @param {string} startDate - 시작 날짜
     * @param {string} endDate - 종료 날짜
     */
    updateLegend(tracks, vesselGroups, startDate, endDate) {
        // 범례 제목 업데이트
        if (this.legendTitleEl) {
            const periodLabel = getPeriodLabel(startDate, endDate);
            this.legendTitleEl.innerHTML = `비정상 유형별 현황 <span style="font-size: 0.8em; color: #6c757d; font-weight: normal;">(${periodLabel})</span>`;
        }
        
        if (!this.legendContentEl) return;
        
        const typeStats = this.calculateTypeStatistics(tracks, vesselGroups);
        
        if (typeStats.size === 0) {
            this.legendContentEl.innerHTML = '<div style="color: #6c757d; font-size: 0.85em;">데이터 없음</div>';
            return;
        }
        
        // 트랙 수 기준으로 정렬
        const sortedTypes = Array.from(typeStats.entries())
            .sort((a, b) => b[1].tracks - a[1].tracks);
        
        this.legendContentEl.innerHTML = sortedTypes.map(([type, stats]) => {
            const color = getColorByType(type).slice(0, 3);
            const description = this.getTypeDescription(type);
            
            return `
                <div class="legend-item" title="${description}">
                    <div style="display: flex; align-items: center; flex: 1;">
                        <div class="legend-color" style="background-color: rgb(${color.join(',')})"></div>
                        <div class="legend-label">${getTypeLabel(type)}</div>
                    </div>
                    <div class="legend-count">${stats.vessels}척 / ${stats.tracks}건</div>
                </div>
            `;
        }).join('');
    }

    /**
     * 유형별 통계 계산
     * @param {Array} tracks - 궤적 데이터
     * @param {Map} vesselGroups - 선박별 그룹 데이터
     * @returns {Map} 유형별 통계
     */
    calculateTypeStatistics(tracks, vesselGroups) {
        const typeStats = new Map();
        const vesselsByType = new Map();
        
        // 각 선박의 가장 최근 비정상 유형 결정
        vesselGroups.forEach((tracks, vesselId) => {
            if (tracks.length > 0) {
                const latestType = tracks[0].abnormalType;
                vesselsByType.set(vesselId, latestType);
            }
        });
        
        // 모든 유형에 대해 통계 집계
        const allTypes = ['extreme_speed', 'extreme_distance', 'extreme_transition', 
                         'extreme_avg_speed_5min', 'impossible_transition', 'user_detected'];
        
        allTypes.forEach(type => {
            const trackCount = tracks.filter(t => t.abnormalType === type).length;
            const vesselCount = Array.from(vesselsByType.values()).filter(t => t === type).length;
            
            if (trackCount > 0 || vesselCount > 0) {
                typeStats.set(type, { 
                    tracks: trackCount, 
                    vessels: vesselCount 
                });
            }
        });
        
        return typeStats;
    }

    /**
     * 유형별 설명 가져오기
     * @param {string} type - 비정상 유형
     * @returns {string} 설명
     */
    getTypeDescription(type) {
        const descriptions = {
            'extreme_speed': '평균속도가 선박 500knots, 항공기 800knots 초과',
            'extreme_distance': '5분간 이동거리가 100nm 초과',
            'extreme_transition': '버킷 전환 시 암시된 속도가 비정상적으로 높음',
            'extreme_avg_speed_5min': '5분 평균속도가 1000knots 초과 (네트워크 오류)',
            'impossible_transition': '시간대별 집계 시 물리적으로 불가능한 전환 (500knots 초과)',
            'user_detected': '사용자가 수동으로 검출한 비정상 궤적'
        };
        return descriptions[type] || '비정상 궤적';
    }

    /**
     * 통계 카드에 애니메이션 효과 추가
     */
    animateStatCards() {
        const statCards = document.querySelectorAll('.stat-card');
        statCards.forEach(card => {
            card.classList.add('updating');
            setTimeout(() => {
                card.classList.remove('updating');
            }, 500);
        });
    }
}