/**
 * 리플레이 Deck.gl 레이어 관리 훅
 * 참조: mda-react-front/src/tracking/components/ReplayV2.tsx
 *
 * 구조:
 * 1. queryCompleted → 정적 항적 레이어 생성
 * 2. animationStore.currentTime 변경 → requestAnimatedRender()
 * 3. animationStore.getCurrentVesselPositions() → 현재 위치 계산
 * 4. deck.gl 레이어 생성 → 전역 레지스트리 등록 → shipBatchRenderer.immediateRender()
 *
 * 필터링:
 * - filterModules.custom: 선박 아이콘 표시
 * - filterModules.path: 항적 라인 표시
 * - filterModules.label: 선명 라벨 표시
 * - shipKindCodeFilter: 선종 필터
 * - vesselStates: 선박 상태 (NORMAL/SELECTED/DELETED)
 */
import { useEffect, useRef, useCallback } from 'react';
import { ScatterplotLayer } from '@deck.gl/layers';
import useMergedTrackStore from '../stores/mergedTrackStore';
import useAnimationStore from '../stores/animationStore';
import useReplayStore from '../stores/replayStore';
import usePlaybackTrailStore from '../stores/playbackTrailStore';
import useShipStore from '../../stores/shipStore';
import { VesselState, FilterModuleType } from '../types/replay.types';
import { createStaticTrackLayers, createVirtualShipLayers } from '../../map/layers/trackLayer';
import { registerReplayLayers, unregisterReplayLayers } from '../utils/replayLayerRegistry';
import { shipBatchRenderer } from '../../map/ShipBatchRenderer';
import { hideLiveShips, showLiveShips } from '../../utils/liveControl';

/**
 * 선박 상태에 따라 표시 여부 결정
 * @param {string} vesselId - 선박 ID
 * @param {Object} filterModule - 필터 모듈 설정 (showNormal, showSelected, showDeleted)
 * @param {Map} vesselStates - 선박 상태 맵
 * @param {Set} deletedVesselIds - 삭제된 선박 Set (레거시)
 * @param {Set} selectedVesselIds - 선택된 선박 Set (레거시)
 * @returns {boolean} 표시 여부
 */
function shouldShowVessel(vesselId, filterModule, vesselStates, deletedVesselIds, selectedVesselIds) {
  // 선박 상태 확인
  let state = VesselState.NORMAL;
  if (vesselStates.has(vesselId)) {
    state = vesselStates.get(vesselId);
  } else if (deletedVesselIds.has(vesselId)) {
    state = VesselState.DELETED;
  } else if (selectedVesselIds.has(vesselId)) {
    state = VesselState.SELECTED;
  }

  // 상태에 따라 필터 적용
  switch (state) {
    case VesselState.NORMAL:
      return filterModule.showNormal;
    case VesselState.SELECTED:
      return filterModule.showSelected;
    case VesselState.DELETED:
      return filterModule.showDeleted;
    default:
      return filterModule.showNormal;
  }
}

/**
 * 리플레이 레이어 훅
 */
export default function useReplayLayer() {
  const staticLayersRef = useRef([]);
  const tracksRef = useRef([]);

  const queryCompleted = useReplayStore((s) => s.queryCompleted);

  // animationStore에서 currentTime, playbackSpeed 구독 (ReplayV2.tsx와 동일)
  const currentTime = useAnimationStore((s) => s.currentTime);
  const playbackSpeed = useAnimationStore((s) => s.playbackSpeed);

  // 필터 상태 구독
  const filterModules = useReplayStore((s) => s.filterModules);
  const shipKindCodeFilter = useReplayStore((s) => s.shipKindCodeFilter);
  const vesselStates = useReplayStore((s) => s.vesselStates);
  const deletedVesselIds = useReplayStore((s) => s.deletedVesselIds);
  const selectedVesselIds = useReplayStore((s) => s.selectedVesselIds);

  // 하이라이트 상태 구독
  const highlightedVesselId = useReplayStore((s) => s.highlightedVesselId);
  const setHighlightedVesselId = useReplayStore((s) => s.setHighlightedVesselId);

  /**
   * 항적/아이콘 호버 시 하이라이트 설정
   */
  const handlePathHover = useCallback((vesselId) => {
    setHighlightedVesselId(vesselId);
  }, [setHighlightedVesselId]);

  /**
   * 가상 선박 아이콘 호버 시 툴팁 표시
   */
  const handleIconHover = useCallback((shipData, x, y) => {
    if (shipData) {
      // ShipTooltip 형식에 맞게 변환하여 shipStore에 저장
      useShipStore.getState().setHoverInfo({
        ship: {
          shipName: shipData.shipName,
          targetId: shipData.vesselId?.split('_').pop() || shipData.vesselId,
          signalKindCode: shipData.shipKindCode,
          sog: shipData.speed || 0,
          cog: shipData.heading || 0,
        },
        x,
        y,
      });
      // 하이라이트도 설정
      setHighlightedVesselId(shipData.vesselId);
    } else {
      useShipStore.getState().setHoverInfo(null);
      setHighlightedVesselId(null);
    }
  }, [setHighlightedVesselId]);

  /**
   * 트랙 필터링
   * @param {Array} tracks - 전체 트랙 배열
   * @returns {Array} 필터링된 트랙 배열
   */
  const filterTracks = useCallback((tracks) => {
    const replayState = useReplayStore.getState();
    const { filterModules, shipKindCodeFilter, vesselStates, deletedVesselIds, selectedVesselIds } = replayState;
    const pathFilter = filterModules[FilterModuleType.PATH];

    return tracks.filter((track) => {
      // 1. 선종 필터
      if (!shipKindCodeFilter.has(track.shipKindCode)) {
        return false;
      }

      // 2. 상태 필터 (항적)
      return shouldShowVessel(
        track.vesselId,
        pathFilter,
        vesselStates,
        deletedVesselIds,
        selectedVesselIds
      );
    });
  }, []);

  /**
   * 현재 위치 필터링
   * @param {Array} positions - 전체 위치 배열
   * @returns {Object} { iconPositions, labelPositions }
   */
  const filterPositions = useCallback((positions) => {
    const replayState = useReplayStore.getState();
    const { filterModules, shipKindCodeFilter, vesselStates, deletedVesselIds, selectedVesselIds } = replayState;
    const customFilter = filterModules[FilterModuleType.CUSTOM];
    const labelFilter = filterModules[FilterModuleType.LABEL];

    const iconPositions = [];
    const labelPositions = [];

    positions.forEach((pos) => {
      // 1. 선종 필터
      if (!shipKindCodeFilter.has(pos.shipKindCode)) {
        return;
      }

      // 2. 아이콘 필터 (CUSTOM)
      if (shouldShowVessel(
        pos.vesselId,
        customFilter,
        vesselStates,
        deletedVesselIds,
        selectedVesselIds
      )) {
        iconPositions.push(pos);
      }

      // 3. 라벨 필터 (LABEL)
      if (shouldShowVessel(
        pos.vesselId,
        labelFilter,
        vesselStates,
        deletedVesselIds,
        selectedVesselIds
      )) {
        labelPositions.push(pos);
      }
    });

    return { iconPositions, labelPositions };
  }, []);

  /**
   * 애니메이션 렌더링 요청
   * animationStore.getCurrentVesselPositions() 사용 (메인 프로젝트 동일)
   */
  const requestAnimatedRender = useCallback(() => {
    // getCurrentVesselPositions로 현재 시간의 선박 위치 계산
    const currentPositions = useAnimationStore.getState().getCurrentVesselPositions();

    if (currentPositions.length === 0 && tracksRef.current.length === 0) {
      return;
    }

    // position → lon/lat 변환 (createVirtualShipLayers 형식에 맞춤)
    const formattedPositions = currentPositions.map((pos) => ({
      vesselId: pos.vesselId,
      lon: pos.position[0],
      lat: pos.position[1],
      heading: pos.heading,
      speed: pos.speed,
      shipKindCode: pos.shipKindCode,
      shipName: pos.shipName,
    }));

    // 위치 필터링
    const { iconPositions, labelPositions } = filterPositions(formattedPositions);

    // 트랙 필터링
    const filteredTracks = filterTracks(tracksRef.current);

    // ===== 항적표시 기능 (playbackTrailStore) =====
    const trailStore = usePlaybackTrailStore.getState();
    const layers = [];

    // 항적표시가 활성화되어 있으면 프레임 기록
    if (trailStore.isEnabled && iconPositions.length > 0) {
      trailStore.recordFrame(
        iconPositions.map((pos) => ({
          vesselId: pos.vesselId,
          lon: pos.lon,
          lat: pos.lat,
        }))
      );
    }

    // 항적표시 레이어 생성 (가장 먼저 추가 - 맨 아래 레이어)
    if (trailStore.isEnabled) {
      const trailPoints = trailStore.getVisiblePoints();
      if (trailPoints.length > 0) {
        const trailLayer = new ScatterplotLayer({
          id: 'replay-playback-trail',
          data: trailPoints,
          pickable: false,
          stroked: false,
          filled: true,
          radiusUnits: 'pixels',
          getPosition: (d) => [d.lon, d.lat],
          getRadius: (d) => trailStore.getPointSize(d.frameIndex),
          getFillColor: (d) => {
            const opacity = trailStore.getOpacity(d.frameIndex);
            return [60, 60, 60, Math.floor(opacity * 180)]; // 회색 점, 투명도 0-180
          },
          updateTriggers: {
            getRadius: [trailStore.frameIndex],
            getFillColor: [trailStore.frameIndex],
          },
        });
        layers.push(trailLayer);
      }
    }

    // 현재 하이라이트 상태 가져오기
    const currentHighlightedVesselId = useReplayStore.getState().highlightedVesselId;

    // 정적 레이어 재생성 (필터 적용 + 하이라이트)
    const staticLayers = createStaticTrackLayers({
      tracks: filteredTracks,
      showPoints: false,
      highlightedVesselId: currentHighlightedVesselId,
      onPathHover: handlePathHover,
    });

    // 동적 레이어 생성 (아이콘/라벨 분리 + 호버 콜백)
    const dynamicLayers = createVirtualShipLayers({
      currentPositions: iconPositions,
      showVirtualShip: iconPositions.length > 0,
      showLabels: false,
      onIconHover: handleIconHover,
      onPathHover: handlePathHover,
    });

    // 라벨 레이어 별도 생성 (라벨 필터 적용)
    const labelLayers = createVirtualShipLayers({
      currentPositions: labelPositions,
      showVirtualShip: false,
      showLabels: labelPositions.length > 0,
    });

    registerReplayLayers([...layers, ...staticLayers, ...dynamicLayers, ...labelLayers]);
    shipBatchRenderer.immediateRender();
  }, [filterTracks, filterPositions, handlePathHover, handleIconHover]);

  /**
   * 쿼리 완료 시 라이브 선박 숨기기 + 정적 레이어 생성 + 초기 위치 렌더
   */
  useEffect(() => {
    if (!queryCompleted) {
      // queryCompleted가 false로 바뀌면 리플레이 종료 → 클린업
      unregisterReplayLayers();
      staticLayersRef.current = [];
      tracksRef.current = [];
      showLiveShips();
      shipBatchRenderer.immediateRender();
      return;
    }

    // 리플레이 모드 시작 → 라이브 선박 숨기기
    hideLiveShips();

    const vesselChunks = useMergedTrackStore.getState().vesselChunks;
    if (vesselChunks.size === 0) return;

    // vesselChunks → tracks 배열 변환
    const tracks = [];
    vesselChunks.forEach((vc, vesselId) => {
      const path = useMergedTrackStore.getState().getMergedPath(vesselId);
      if (!path || path.geometry.length < 2) return;

      tracks.push({
        vesselId,
        geometry: path.geometry,
        timestamps: path.timestamps,
        timestampsMs: path.timestampsMs,
        speeds: path.speeds,
        shipKindCode: vc.shipKindCode || '000027',
        shipName: vc.shipName || '',
        sigSrcCd: vc.sigSrcCd,
      });
    });

    tracksRef.current = tracks;

    // 시간 범위 업데이트 (animationStore)
    useAnimationStore.getState().updateTimeRange();

    // 초기 렌더링
    requestAnimatedRender();
  }, [queryCompleted, requestAnimatedRender]);

  /**
   * currentTime 변경 시 애니메이션 렌더링 (ReplayV2.tsx와 동일한 패턴)
   */
  useEffect(() => {
    if (!queryCompleted) return;
    requestAnimatedRender();
  }, [currentTime, queryCompleted, requestAnimatedRender]);

  /**
   * 필터 변경 시 재렌더링
   */
  useEffect(() => {
    if (!queryCompleted) return;
    requestAnimatedRender();
  }, [filterModules, shipKindCodeFilter, vesselStates, deletedVesselIds, selectedVesselIds, queryCompleted, requestAnimatedRender]);

  /**
   * 배속 변경 시 항적 maxFrames 업데이트
   */
  useEffect(() => {
    usePlaybackTrailStore.getState().updatePlaybackSpeed(playbackSpeed);
  }, [playbackSpeed]);

  /**
   * 하이라이트 변경 시 레이어 재렌더링
   */
  useEffect(() => {
    if (!queryCompleted) return;
    requestAnimatedRender();
  }, [highlightedVesselId, queryCompleted, requestAnimatedRender]);

  /**
   * 키보드 이벤트 리스너 (Delete/Insert 키로 선박 상태 변경)
   */
  useEffect(() => {
    if (!queryCompleted) return;

    const handleKeyDown = (event) => {
      const currentHighlightedId = useReplayStore.getState().highlightedVesselId;
      if (!currentHighlightedId) return;

      const { vesselStates, deletedVesselIds, selectedVesselIds, setVesselState } = useReplayStore.getState();

      // 현재 상태 확인
      let currentState = VesselState.NORMAL;
      if (vesselStates.has(currentHighlightedId)) {
        currentState = vesselStates.get(currentHighlightedId);
      } else if (deletedVesselIds.has(currentHighlightedId)) {
        currentState = VesselState.DELETED;
      } else if (selectedVesselIds.has(currentHighlightedId)) {
        currentState = VesselState.SELECTED;
      }

      let targetState = null;

      if (event.key === 'Delete') {
        // Delete 키: NORMAL/SELECTED → DELETED, DELETED → NORMAL
        if (currentState === VesselState.DELETED) {
          targetState = VesselState.NORMAL;
        } else {
          targetState = VesselState.DELETED;
        }
      } else if (event.key === 'Insert') {
        // Insert 키: NORMAL → SELECTED, SELECTED → NORMAL, DELETED → SELECTED
        if (currentState === VesselState.DELETED) {
          targetState = VesselState.SELECTED;
        } else if (currentState === VesselState.SELECTED) {
          targetState = VesselState.NORMAL;
        } else {
          targetState = VesselState.SELECTED;
        }
      }

      if (targetState !== null) {
        setVesselState(currentHighlightedId, targetState);
        // 하이라이트 해제
        useReplayStore.getState().setHighlightedVesselId(null);
        // 레이어 재렌더링
        requestAnimatedRender();
      }
    };

    window.addEventListener('keydown', handleKeyDown);
    return () => {
      window.removeEventListener('keydown', handleKeyDown);
    };
  }, [queryCompleted, requestAnimatedRender]);

  /**
   * 컴포넌트 언마운트 시 클린업
   */
  useEffect(() => {
    return () => {
      unregisterReplayLayers();
      staticLayersRef.current = [];
      tracksRef.current = [];
      showLiveShips();
      shipBatchRenderer.immediateRender();
    };
  }, []);
}
