'use client';

import { useEffect, useMemo, useState } from 'react';

import { Globe2, Maximize2, X } from 'lucide-react';
import { Direction, Range, getTrackBackground } from 'react-range';
import { useMediaQuery } from 'react-responsive';

import CreationCard from '@/components/creations/CreationCard';
import { Button } from '@/components/ui/button';
import { Text } from '@/components/ui/typography';
import { cn } from '@/lib/utils';

import type { CreationListItem } from '@/types/Creation';

import ImageMarkerMap, { type ImageMarkerItem } from './ImageMarkerMap';

export type TimeMachineItem = CreationListItem & { category: string; lat: number; lng: number };

export interface TimeMachineData {
  items: TimeMachineItem[];
  minYear: number;
  maxYear: number;
}

// Widest bar of the year column, in px: just enough to show where the creations are.
const BAR_WIDTH = 20;

const INK = '#151720';
const MUTED_BAR = 'rgba(21, 23, 32, 0.16)';

// Roughly the Carpathian Basin the map opens on; creations outside it are counted apart.
const HOME_BOUNDS = { south: 44, north: 49.8, west: 15.5, east: 27.5 };

const formatNumber = (value: number) => value.toLocaleString('hu-HU');
const yearOf = (item: TimeMachineItem) => item.labelYear as number;
const decadeOf = (year: number) => Math.floor(year / 10) * 10;
const isAbroad = ({ lat, lng }: TimeMachineItem) =>
  lat < HOME_BOUNDS.south ||
  lat > HOME_BOUNDS.north ||
  lng < HOME_BOUNDS.west ||
  lng > HOME_BOUNDS.east;

// The Hungarian suffix follows the spoken tens: "hetvenes", "nyolcvanas", "kétezres".
const DECADE_SUFFIX = ['es', 'es', 'as', 'as', 'es', 'es', 'as', 'es', 'as', 'es'];
const decadeLabel = (decade: number) =>
  `${decade}-${decade % 100 === 0 ? 'es' : DECADE_SUFFIX[(decade % 100) / 10]} évek`;

function rangeLabelOf(from: number, to: number, maxYear: number) {
  if (from === to) return String(from);
  const wholeDecade = from % 10 === 0 && (to === from + 9 || (to === maxYear && to < from + 9));
  return wholeDecade ? decadeLabel(from) : `${from}–${to}`;
}

function boundsOf(items: TimeMachineItem[]): google.maps.LatLngBoundsLiteral | null {
  if (items.length === 0) return null;
  const lats = items.map((item) => item.lat);
  const lngs = items.map((item) => item.lng);
  return {
    south: Math.min(...lats),
    north: Math.max(...lats),
    west: Math.min(...lngs),
    east: Math.max(...lngs),
  };
}

/** The Időgép: creations with a known place, on a map for a chosen span of years. */
export default function TimeMachineMap({ data }: { data: TimeMachineData }) {
  const [full, setFull] = useState(false);
  // Full screen: the page under it holds still, and Esc closes it.
  useEffect(() => {
    if (!full) return;
    const overflow = document.body.style.overflow;
    document.body.style.overflow = 'hidden';
    const close = (event: KeyboardEvent) => {
      if (event.key === 'Escape') setFull(false);
    };
    window.addEventListener('keydown', close);
    return () => {
      document.body.style.overflow = overflow;
      window.removeEventListener('keydown', close);
    };
  }, [full]);

  const { items, minYear, maxYear } = data;
  // From tablets up the year column stands beside the map; on phones it lies under it.
  const vertical = useMediaQuery({ minWidth: 768 });

  const decades = useMemo(() => {
    const list: number[] = [];
    for (let decade = decadeOf(minYear); decade <= maxYear; decade += 10) list.push(decade);
    return list;
  }, [minYear, maxYear]);

  const yearCounts = useMemo(() => {
    const counts = new Map<number, number>();
    for (const item of items) counts.set(yearOf(item), (counts.get(yearOf(item)) ?? 0) + 1);
    return counts;
  }, [items]);
  const maxYearCount = Math.max(1, ...yearCounts.values());
  const span = maxYear - minYear + 1;

  const initialFrom = useMemo(
    () => (items.length > 0 ? decadeOf(yearOf(items[Math.floor(items.length / 2)])) : decades[0]),
    [items, decades]
  );

  const [from, setFrom] = useState(Math.max(minYear, initialFrom));
  const [to, setTo] = useState(Math.min(maxYear, initialFrom + 9));
  const [hoveredYear, setHoveredYear] = useState<number | null>(null);
  const [fitTo, setFitTo] = useState<google.maps.LatLngBoundsLiteral | null>(null);
  // A marker selection belongs to the range it was made in.
  const [selection, setSelection] = useState<{ keys: string[]; signature: string } | null>(null);

  const visibleItems = useMemo(
    () => items.filter((item) => yearOf(item) >= from && yearOf(item) <= to),
    [items, from, to]
  );
  const abroadItems = useMemo(() => visibleItems.filter(isAbroad), [visibleItems]);

  const markerItems = useMemo<ImageMarkerItem[]>(
    () =>
      visibleItems.map((item) => ({
        key: item.alkotasAzonosito,
        lat: item.lat,
        lng: item.lng,
        year: yearOf(item),
        imageId: item.fokep?.id as number,
      })),
    [visibleItems]
  );
  const placeCount = useMemo(
    () => new Set(visibleItems.map((item) => `${item.lat}|${item.lng}`)).size,
    [visibleItems]
  );

  const signature = `${from}|${to}`;
  const selectedKeys = useMemo(
    () => new Set(selection?.signature === signature ? selection.keys : []),
    [selection, signature]
  );
  const selectedItems = useMemo(
    () => visibleItems.filter((item) => selectedKeys.has(item.alkotasAzonosito)).reverse(),
    [visibleItems, selectedKeys]
  );

  const selectMarkers = (keys: string[]) => setSelection({ keys, signature });

  const chooseRange = (start: number, end: number) => {
    setFrom(Math.max(minYear, start));
    setTo(Math.min(maxYear, end));
  };

  // Clicking a bar moves the selection, keeping its width, so that it starts at that year.
  const jumpTo = (year: number) => {
    const width = to - from;
    const start = Math.min(year, maxYear - width);
    chooseRange(start, start + width);
  };

  const yearFromPointer = (event: React.MouseEvent<SVGSVGElement>) => {
    const box = event.currentTarget.getBoundingClientRect();
    const ratio = vertical
      ? (event.clientY - box.top) / box.height
      : (event.clientX - box.left) / box.width;
    return Math.min(maxYear, Math.max(minYear, minYear + Math.floor(ratio * span)));
  };

  if (items.length === 0) {
    return (
      <Text tone="muted">
        Nincs megjeleníthető, évszámmal, helyszínnel és képpel ellátott alkotás.
      </Text>
    );
  }

  const rangeLabel = rangeLabelOf(from, to, maxYear);
  const mapHeight = vertical
    ? full
      ? 'h-[calc(100dvh-6rem)] min-h-[320px]'
      : 'h-[74vh] min-h-[480px]'
    : full
      ? 'h-[calc(100dvh-14rem)] min-h-[280px]'
      : 'h-[60vh] min-h-[360px]';

  return (
    <div
      className={cn(
        full && 'fixed inset-0 z-[70] flex flex-col overflow-y-auto bg-surface-paper p-3 sm:p-6'
      )}
      role={full ? 'dialog' : undefined}
      aria-modal={full || undefined}
      aria-label={full ? 'Időgép, teljes képernyő' : undefined}
    >
      <div className="border border-mma-blue/10 bg-white">
        <div className={cn('flex', vertical ? mapHeight : 'flex-col')}>
          <div className={cn('relative min-w-0 bg-[#e8edf2]', vertical ? 'flex-1' : mapHeight)}>
            <ImageMarkerMap
              items={markerItems}
              selectedKeys={selectedKeys}
              onSelect={selectMarkers}
              gestureHandling="cooperative"
              representative="earliest"
              fitBounds={fitTo}
            />
            <div className="pointer-events-none absolute left-3 top-3 bg-white/90 px-4 py-3 shadow-sm">
              <div className="font-slab text-2xl font-bold leading-none text-[#151720] sm:text-3xl">
                {rangeLabel}
              </div>
              <Text variant="meta" tone="muted" className="mt-2">
                {formatNumber(visibleItems.length)} alkotás · {formatNumber(placeCount)} helyszín
              </Text>
              <Text variant="caption" tone="muted" className="mt-1 hidden sm:block">
                Kattintson egy képre, és megnyithatja az alkotást.
              </Text>
              {fitTo ? (
                <Button
                  size="xs"
                  variant="quiet"
                  className="pointer-events-auto mt-2 bg-white"
                  onClick={() => setFitTo(null)}
                >
                  Vissza a Kárpát-medencére
                </Button>
              ) : abroadItems.length > 0 ? (
                <Button
                  size="xs"
                  variant="quiet"
                  className="pointer-events-auto mt-2 bg-white"
                  onClick={() => setFitTo(boundsOf(visibleItems))}
                >
                  <Globe2 />+{formatNumber(abroadItems.length)} a Kárpát-medencén kívül
                </Button>
              ) : null}
            </div>
            <Button
              size="icon"
              variant="quiet"
              onClick={() => setFull((value) => !value)}
              aria-label={full ? 'Vissza az oldalra' : 'Teljes képernyő'}
              title={full ? 'Vissza az oldalra' : 'Teljes képernyő'}
              className="absolute right-3 top-3 bg-white shadow-sm"
            >
              {full ? <X /> : <Maximize2 />}
            </Button>
            {selectedItems.length > 0 ? (
              <div
                className="absolute inset-x-3 bottom-3 bg-white p-3 shadow-lg sm:right-auto sm:max-w-[calc(100%-1.5rem)]"
                role="region"
                aria-label="Kiválasztott alkotások"
              >
                <div className="flex items-center justify-between gap-3">
                  <Text variant="meta" tone="muted">
                    {selectedItems.length > 1
                      ? `${formatNumber(selectedItems.length)} alkotás ezen a helyen`
                      : (selectedItems[0].telepules ?? 'Alkotás')}
                  </Text>
                  <Button
                    size="xs"
                    variant="ghost"
                    onClick={() => setSelection(null)}
                    aria-label="Bezárás"
                  >
                    <X />
                  </Button>
                </div>
                <div className="mt-2 flex gap-2 overflow-x-auto">
                  {selectedItems.map((item) => (
                    <div key={item.alkotasAzonosito} className="w-40 shrink-0 sm:w-44">
                      <CreationCard data={item} vertical />
                    </div>
                  ))}
                </div>
              </div>
            ) : null}
          </div>

          <div
            className={cn(
              'border-mma-blue/10',
              vertical ? 'flex w-24 shrink-0 flex-col border-l' : 'border-t pb-3'
            )}
          >
            <Text
              variant="meta"
              tone="muted"
              className={cn(
                'tabular-nums',
                vertical ? 'h-9 px-2 pt-3 text-center' : 'h-8 px-4 pt-3'
              )}
            >
              {hoveredYear !== null
                ? `${hoveredYear} · ${formatNumber(yearCounts.get(hoveredYear) ?? 0)}${vertical ? '' : ' alkotás'}`
                : vertical
                  ? 'Évek'
                  : 'Alkotások évenként'}
            </Text>
            <div
              className={cn(
                'relative',
                vertical ? 'mx-2 mb-4 mt-2 flex-1' : 'mx-4 mt-2 h-[4.5rem]'
              )}
            >
              <svg
                viewBox={vertical ? `0 0 ${BAR_WIDTH} ${span}` : `0 0 ${span} ${BAR_WIDTH}`}
                preserveAspectRatio="none"
                className={cn(
                  'absolute block cursor-pointer',
                  vertical ? 'inset-y-0 left-0 h-full w-5' : 'inset-x-0 top-0 h-5 w-full'
                )}
                role="img"
                aria-label={`Alkotások száma évenként, ${minYear}–${maxYear}`}
                onPointerMove={(event) => setHoveredYear(yearFromPointer(event))}
                onPointerLeave={() => setHoveredYear(null)}
                onClick={(event) => jumpTo(yearFromPointer(event))}
              >
                {Array.from({ length: span }, (_, index) => {
                  const year = minYear + index;
                  const count = yearCounts.get(year) ?? 0;
                  if (count === 0) return null;
                  const length = Math.max(1.5, (count / maxYearCount) * BAR_WIDTH);
                  const fill =
                    (year >= from && year <= to) || year === hoveredYear ? INK : MUTED_BAR;
                  return (
                    <rect
                      key={year}
                      fill={fill}
                      {...(vertical
                        ? { x: BAR_WIDTH - length, y: index + 0.15, width: length, height: 0.7 }
                        : { x: index + 0.15, y: BAR_WIDTH - length, width: 0.7, height: length })}
                    />
                  );
                })}
              </svg>

              <div className={cn('absolute', vertical ? 'inset-y-0 left-7' : 'inset-x-0 top-7')}>
                <Range
                  // A new direction needs fresh thumb measurements.
                  key={vertical ? 'vertical' : 'horizontal'}
                  direction={vertical ? Direction.Down : Direction.Right}
                  values={[from, to]}
                  min={minYear}
                  max={maxYear}
                  step={1}
                  onChange={([start, end]) => chooseRange(start, end)}
                  renderTrack={({ props, children }) => (
                    <div
                      {...props}
                      className={vertical ? 'h-full w-1.5' : 'h-1.5 w-full'}
                      style={{
                        ...props.style,
                        background: getTrackBackground({
                          values: [from, to],
                          colors: [MUTED_BAR, INK, MUTED_BAR],
                          min: minYear,
                          max: maxYear,
                          direction: vertical ? Direction.Down : Direction.Right,
                        }),
                      }}
                    >
                      {children}
                    </div>
                  )}
                  renderThumb={({ props, index }) => {
                    const { key, ...rest } = props;
                    return (
                      <div
                        key={key}
                        {...rest}
                        aria-label={index === 0 ? 'Kezdő év' : 'Záró év'}
                        className="h-5 w-5 rounded-full border-2 border-white bg-mma-yellow shadow focus:outline-none focus-visible:ring-2 focus-visible:ring-mma-blue"
                      />
                    );
                  }}
                />
              </div>

              <div
                className={cn(
                  'absolute',
                  vertical ? 'inset-y-0 left-11 right-0' : 'inset-x-0 top-11 h-6'
                )}
                role="group"
                aria-label="Ugrás egy évtizedre"
              >
                {decades.map((decade) => {
                  const active =
                    from === Math.max(minYear, decade) && to === Math.min(maxYear, decade + 9);
                  return (
                    <Button
                      key={decade}
                      size="xs"
                      variant={active ? 'default' : 'quiet'}
                      onClick={() => chooseRange(decade, decade + 9)}
                      aria-label={decadeLabel(decade)}
                      aria-pressed={active}
                      title={decadeLabel(decade)}
                      className={cn(
                        'absolute h-6 px-1.5 text-xs tabular-nums',
                        !active && 'bg-white',
                        vertical ? 'left-0 -translate-y-1/2' : 'top-0 -translate-x-1/2'
                      )}
                      style={{
                        [vertical ? 'top' : 'left']:
                          `${((Math.min(decade + 5, (decade + maxYear + 1) / 2) - minYear) / span) * 100}%`,
                      }}
                    >
                      {`'${String(decade % 100).padStart(2, '0')}`}
                    </Button>
                  );
                })}
              </div>
            </div>
          </div>
        </div>
      </div>
    </div>
  );
}
