import { useState, useRef, useEffect } from "react";
import { useLocation } from "wouter";
import { type Video } from "@shared/schema";
import VideoCard from "./video-card";
import BunnyVideoModal from "./bunny-video-modal";
import { Button } from "@/components/ui/button";
import { ChevronLeft, ChevronRight } from "lucide-react";

interface VideoCategory {
  title: string;
  videos: Video[];
}

interface NetflixGridProps {
  videos: Video[];
  isLoading: boolean;
}

export default function NetflixGrid({ videos, isLoading }: NetflixGridProps) {
  const [selectedVideo, setSelectedVideo] = useState<Video | null>(null);
  const [isModalOpen, setIsModalOpen] = useState(false);
  const [, setLocation] = useLocation();

  const handleVideoClick = (video: Video) => {
    // Navigate to individual video page instead of modal
    setLocation(`/video/${video.id}`);
  };

  const handleCloseModal = () => {
    setIsModalOpen(false);
    setSelectedVideo(null);
  };

  const handleVideoChange = (video: Video) => {
    setSelectedVideo(video);
  };

  // Organize videos into categories
  const getCategories = (): VideoCategory[] => {
    if (!videos.length) return [];

    // Sort by views for top content
    const sortedByViews = [...videos].sort((a, b) => (b.views || 0) - (a.views || 0));
    
    // Sort by date for recently added
    const sortedByDate = [...videos].sort((a, b) => 
      new Date(b.createdAt).getTime() - new Date(a.createdAt).getTime()
    );

    // FOLX STADL videos
    const folxStadlVideos = videos.filter(video => 
      video.title.includes("FOLX STADL") || video.title.includes("FOLXSTADL")
    );

    return [
      {
        title: "Meistgesehen",
        videos: sortedByViews.slice(0, 10)
      },
      ...(folxStadlVideos.length > 0 ? [{
        title: "FOLX STADL",
        videos: folxStadlVideos.slice(0, 12)
      }] : []),
      {
        title: "GDL VIDEO",
        videos: (() => {
          // Filter videos that are only Geschichte des Liedes (exclude FOLX STADL and Gipfelstammtisch)
          const artistVideos = videos.filter(video => 
            !video.title.includes("FOLX STADL") && 
            !video.title.includes("FOLXSTADL") &&
            !video.title.includes("Gipfelstammtisch")
          );
          
          // Group by performer/artist (extract performer name before " - ")
          const performerGroups: { [key: string]: typeof videos } = {};
          artistVideos.forEach(video => {
            const performer = video.title.split(" - ")[0] || "Unknown";
            if (!performerGroups[performer]) {
              performerGroups[performer] = [];
            }
            performerGroups[performer].push(video);
          });
          
          // Sort each group by upload date (newest first)
          Object.keys(performerGroups).forEach(performer => {
            performerGroups[performer].sort((a, b) => 
              new Date(b.createdAt).getTime() - new Date(a.createdAt).getTime()
            );
          });
          
          // Distribute videos: first one from each performer, then continue
          const result = [];
          const performers = Object.keys(performerGroups);
          let maxRounds = Math.max(...performers.map(p => performerGroups[p].length));
          
          for (let round = 0; round < maxRounds && result.length < 15; round++) {
            for (let performer of performers) {
              if (performerGroups[performer][round] && result.length < 15) {
                result.push(performerGroups[performer][round]);
              }
            }
          }
          
          return result;
        })()
      },
      {
        title: "Beliebt jetzt",
        videos: videos.slice(0, 12)
      }
    ];
  };

  if (isLoading && videos.length === 0) {
    return (
      <div className="space-y-8">
        {Array.from({ length: 3 }).map((_, categoryIndex) => (
          <div key={categoryIndex} className="space-y-4">
            <div className="h-6 bg-bunny-gray rounded w-48 animate-pulse"></div>
            <div className="flex space-x-4 overflow-hidden">
              {Array.from({ length: 6 }).map((_, index) => (
                <div key={index} className="flex-shrink-0 w-56 md:w-80 animate-pulse">
                  <div className="bg-bunny-gray aspect-[9/16] md:aspect-[16/9] rounded-xl mb-3"></div>
                  <div className="space-y-2">
                    <div className="h-4 bg-bunny-gray rounded w-3/4"></div>
                    <div className="h-3 bg-bunny-gray rounded w-1/2"></div>
                  </div>
                </div>
              ))}
            </div>
          </div>
        ))}
      </div>
    );
  }

  if (videos.length === 0) {
    return (
      <div className="text-center py-12">
        <div className="text-bunny-muted text-lg mb-4">
          No videos found
        </div>
        <p className="text-sm text-bunny-muted">
          Try adjusting your search or filter criteria
        </p>
      </div>
    );
  }

  const categories = getCategories();

  return (
    <>
      <div>
        {categories.map((category, categoryIndex) => (
          <div key={categoryIndex} className={`${categoryIndex === 0 ? 'mt-8 mb-12' : 'mb-12'}`}>
            <CategoryRow
              category={category}
              onVideoClick={handleVideoClick}
              hideScrollButtons={false}
            />
          </div>
        ))}
      </div>

      <BunnyVideoModal
        video={selectedVideo}
        isOpen={isModalOpen}
        onClose={handleCloseModal}
        videos={videos}
        onVideoChange={handleVideoChange}
      />
    </>
  );
}

interface CategoryRowProps {
  category: VideoCategory;
  onVideoClick: (video: Video) => void;
  hideScrollButtons?: boolean;
}

function CategoryRow({ category, onVideoClick, hideScrollButtons = false }: CategoryRowProps) {
  const scrollRef = useRef<HTMLDivElement>(null);
  const [isScrolling, setIsScrolling] = useState(false);
  const scrollIntervalRef = useRef<NodeJS.Timeout>();
  const [clickedVideoId, setClickedVideoId] = useState<string | null>(null);

  const scroll = (direction: 'left' | 'right') => {
    if (scrollRef.current) {
      // Scroll exactly 4 cards (220px + 16px gap = 236px per card)
      const cardWidth = 220 + 16; // card width + gap
      const scrollAmount = cardWidth * 4; // 4 cards at once
      
      const currentScroll = scrollRef.current.scrollLeft;
      const targetScroll = direction === 'left' 
        ? currentScroll - scrollAmount 
        : currentScroll + scrollAmount;
        
      scrollRef.current.scrollTo({
        left: targetScroll,
        behavior: 'smooth'
      });
    }
  };

  const startAutoScroll = (direction: 'left' | 'right') => {
    // Stop any existing scrolling first
    if (scrollIntervalRef.current) {
      clearInterval(scrollIntervalRef.current);
    }
    
    setIsScrolling(true);
    scrollIntervalRef.current = setInterval(() => {
      if (scrollRef.current) {
        const scrollStep = direction === 'left' ? -3 : 3;
        scrollRef.current.scrollLeft += scrollStep;
      }
    }, 16); // 60fps smooth scrolling
  };

  const stopAutoScroll = () => {
    setIsScrolling(false);
    if (scrollIntervalRef.current) {
      clearInterval(scrollIntervalRef.current);
    }
  };

  useEffect(() => {
    return () => {
      if (scrollIntervalRef.current) {
        clearInterval(scrollIntervalRef.current);
      }
    };
  }, []);

  return (
    <div 
      className="relative group mb-6"
    >
      <h2 className="text-xl font-semibold text-white mb-4 px-4">
        {category.title}
      </h2>
      <div className="relative">

        {/* Scrollable video row - true edge to edge */}
        <div
          ref={scrollRef}
          className="flex gap-4 overflow-x-auto pl-4 pr-4"
          style={{ 
            maxWidth: '1200px', 
            margin: '0 auto', 
            scrollbarWidth: 'none', 
            msOverflowStyle: 'none'
          }}
        >
          {category.videos.map((video, index) => (
            <div 
              key={video.id} 
              className="flex-shrink-0 w-[280px]"
            >
              <VideoCard
                video={video}
                onClick={(video) => {
                  setClickedVideoId(video.id);
                  onVideoClick(video);
                }}
                className="w-full rounded-lg overflow-hidden"
              />
            </div>
          ))}
        </div>
      </div>
    </div>
  );
}