veza/apps/web/src/features/tracks/pages/track-detail-page/useTrackDetailPage.ts

import { useState, useEffect, useCallback } from 'react';
import { useParams } from 'react-router-dom';
import { getTrack } from '../../services/trackService';
import { TrackServiceError as TrackUploadError } from '../../errors/trackErrors';
import { usePlayerStore } from '@/features/player/store/playerStore';
import type { Track as PlayerTrack } from '@/features/player/types';
import toast from '@/utils/toast';
import { useTranslation } from '@/hooks/useTranslation';
import type { Track } from '../../types/track';

export function useTrackDetailPage(trackIdOverride?: string) {
  const { t } = useTranslation();
  const { id: paramId } = useParams<{ id: string }>();
  const id = trackIdOverride ?? paramId ?? '';

  const [track, setTrack] = useState<Track | null>(null);
  const [isLoading, setIsLoading] = useState(true);
  const [error, setError] = useState<Error | null>(null);
  const [isShareDialogOpen, setIsShareDialogOpen] = useState(false);

  const { play, pause, currentTrack, isPlaying, addToQueue } = usePlayerStore();

  const loadTrack = useCallback(async () => {
    if (!id) {
      setError(new Error('Track ID is required'));
      setIsLoading(false);
      return;
    }
    try {
      setIsLoading(true);
      setError(null);
      const loadedTrack = await getTrack(id);
      setTrack(loadedTrack);
    } catch (err) {
      const errorMessage =
        err instanceof TrackUploadError
          ? err.message
          : err instanceof Error
            ? err.message
            : 'Failed to load track';
      setError(new Error(errorMessage));
    } finally {
      setIsLoading(false);
    }
  }, [id]);

  useEffect(() => {
    loadTrack();
  }, [loadTrack]);

  const mapToPlayerTrack = (t: Track): PlayerTrack => ({
    id: t.id,
    title: t.title,
    artist: t.artist,
    album: t.album,
    duration: t.duration,
    url: (t as { stream_manifest_url?: string }).stream_manifest_url || `/api/v1/tracks/${t.id}/stream`,
    cover: (t as { cover_art_path?: string }).cover_art_path,
    genre: t.genre,
  });

  const handlePlay = () => {
    if (track) play(mapToPlayerTrack(track));
  };
  const handlePause = () => pause();
  const handleAddToQueue = () => {
    if (track) {
      addToQueue([mapToPlayerTrack(track)]);
      toast.success(t('tracks.detail.addedToQueue'));
    }
  };
  const handleShare = () => setIsShareDialogOpen(true);

  const isCurrentTrack = currentTrack?.id === track?.id;
  const isCurrentlyPlaying = isCurrentTrack && isPlaying;

  return {
    id,
    track,
    isLoading,
    error,
    loadTrack,
    isShareDialogOpen,
    setIsShareDialogOpen,
    handlePlay,
    handlePause,
    handleAddToQueue,
    handleShare,
    isCurrentTrack,
    isCurrentlyPlaying,
  };
}