'use client';

import * as React from 'react';
import { Play, Pause, Square, SkipBack, Volume2, VolumeX, Circle, AlignVerticalJustifyStart, AlignVerticalJustifyEnd, Layers } from 'lucide-react';
import { Button } from '@/components/ui/Button';
import { Slider } from '@/components/ui/Slider';
import { MasterMeter } from '@/components/controls/MasterMeter';
import { cn } from '@/lib/utils/cn';

export interface PlaybackControlsProps {
  isPlaying: boolean;
  isPaused: boolean;
  currentTime: number;
  duration: number;
  volume: number;
  onPlay: () => void;
  onPause: () => void;
  onStop: () => void;
  onSeek: (time: number, autoPlay?: boolean) => void;
  onVolumeChange: (volume: number) => void;
  disabled?: boolean;
  className?: string;
  currentTimeFormatted?: string;
  durationFormatted?: string;
  isRecording?: boolean;
  onStartRecording?: () => void;
  onStopRecording?: () => void;
  punchInEnabled?: boolean;
  punchInTime?: number;
  punchOutTime?: number;
  onPunchInEnabledChange?: (enabled: boolean) => void;
  onPunchInTimeChange?: (time: number) => void;
  onPunchOutTimeChange?: (time: number) => void;
  overdubEnabled?: boolean;
  onOverdubEnabledChange?: (enabled: boolean) => void;
  masterPeakLevel?: number;
  masterRmsLevel?: number;
  masterIsClipping?: boolean;
  onResetClip?: () => void;
}

export function PlaybackControls({
  isPlaying,
  isPaused,
  currentTime,
  duration,
  volume,
  onPlay,
  onPause,
  onStop,
  onSeek,
  onVolumeChange,
  disabled = false,
  className,
  currentTimeFormatted,
  durationFormatted,
  isRecording = false,
  onStartRecording,
  onStopRecording,
  punchInEnabled = false,
  punchInTime = 0,
  punchOutTime = 0,
  onPunchInEnabledChange,
  onPunchInTimeChange,
  onPunchOutTimeChange,
  overdubEnabled = false,
  onOverdubEnabledChange,
  masterPeakLevel = 0,
  masterRmsLevel = 0,
  masterIsClipping = false,
  onResetClip,
}: PlaybackControlsProps) {
  const [isMuted, setIsMuted] = React.useState(false);
  const [previousVolume, setPreviousVolume] = React.useState(volume);

  const handlePlayPause = () => {
    if (isPlaying) {
      onPause();
    } else {
      onPlay();
    }
  };

  const handleMuteToggle = () => {
    if (isMuted) {
      onVolumeChange(previousVolume);
      setIsMuted(false);
    } else {
      setPreviousVolume(volume);
      onVolumeChange(0);
      setIsMuted(true);
    }
  };

  const handleVolumeChange = (newVolume: number) => {
    onVolumeChange(newVolume);
    if (newVolume === 0) {
      setIsMuted(true);
    } else {
      setIsMuted(false);
    }
  };

  const progress = duration > 0 ? (currentTime / duration) * 100 : 0;

  return (
    <div className={cn('space-y-4', className)}>
      {/* Timeline Slider */}
      <div className="space-y-2">
        <input
          type="range"
          min={0}
          max={duration || 100}
          step={0.01}
          value={currentTime}
          onChange={(e) => onSeek(parseFloat(e.target.value), false)}
          onMouseUp={(e) => onSeek(parseFloat((e.target as HTMLInputElement).value), true)}
          onTouchEnd={(e) => onSeek(parseFloat((e.target as HTMLInputElement).value), true)}
          disabled={disabled || duration === 0}
          className={cn(
            'w-full h-2 bg-secondary rounded-lg appearance-none cursor-pointer',
            'focus:outline-none focus:ring-2 focus:ring-ring focus:ring-offset-2',
            'disabled:opacity-50 disabled:cursor-not-allowed',
            '[&::-webkit-slider-thumb]:appearance-none [&::-webkit-slider-thumb]:w-4 [&::-webkit-slider-thumb]:h-4',
            '[&::-webkit-slider-thumb]:rounded-full [&::-webkit-slider-thumb]:bg-primary',
            '[&::-webkit-slider-thumb]:cursor-pointer [&::-webkit-slider-thumb]:transition-colors',
            '[&::-webkit-slider-thumb]:hover:bg-primary/90',
            '[&::-moz-range-thumb]:w-4 [&::-moz-range-thumb]:h-4 [&::-moz-range-thumb]:rounded-full',
            '[&::-moz-range-thumb]:bg-primary [&::-moz-range-thumb]:border-0 [&::-moz-range-thumb]:cursor-pointer'
          )}
          style={{
            background: `linear-gradient(to right, var(--color-primary) ${progress}%, var(--color-secondary) ${progress}%)`,
          }}
        />
        <div className="flex items-center justify-between text-xs text-muted-foreground">
          <span>{currentTimeFormatted || '00:00'}</span>
          <span>{durationFormatted || '00:00'}</span>
        </div>
      </div>

      {/* Punch In/Out Times - Show when enabled */}
      {punchInEnabled && onPunchInTimeChange && onPunchOutTimeChange && (
        <div className="flex items-center gap-3 text-xs bg-muted/50 rounded px-3 py-2">
          <div className="flex items-center gap-2 flex-1">
            <label className="text-muted-foreground flex items-center gap-1 flex-shrink-0">
              <AlignVerticalJustifyStart className="h-3 w-3" />
              Punch In
            </label>
            <input
              type="number"
              min={0}
              max={punchOutTime || duration}
              step={0.1}
              value={punchInTime.toFixed(2)}
              onChange={(e) => onPunchInTimeChange(parseFloat(e.target.value))}
              className="flex-1 px-2 py-1 bg-background border border-border rounded text-xs font-mono"
            />
            <Button
              variant="ghost"
              size="sm"
              onClick={() => onPunchInTimeChange(currentTime)}
              title="Set punch-in to current time"
              className="h-6 px-2 text-xs"
            >
              Set
            </Button>
          </div>

          <div className="flex items-center gap-2 flex-1">
            <label className="text-muted-foreground flex items-center gap-1 flex-shrink-0">
              <AlignVerticalJustifyEnd className="h-3 w-3" />
              Punch Out
            </label>
            <input
              type="number"
              min={punchInTime}
              max={duration}
              step={0.1}
              value={punchOutTime.toFixed(2)}
              onChange={(e) => onPunchOutTimeChange(parseFloat(e.target.value))}
              className="flex-1 px-2 py-1 bg-background border border-border rounded text-xs font-mono"
            />
            <Button
              variant="ghost"
              size="sm"
              onClick={() => onPunchOutTimeChange(currentTime)}
              title="Set punch-out to current time"
              className="h-6 px-2 text-xs"
            >
              Set
            </Button>
          </div>
        </div>
      )}

      {/* Transport Controls */}
      <div className="flex items-center justify-between gap-4">
        <div className="flex items-center gap-2">
          <Button
            variant="outline"
            size="icon"
            onClick={onStop}
            disabled={disabled || (!isPlaying && !isPaused)}
            title="Stop"
          >
            <SkipBack className="h-4 w-4" />
          </Button>

          <Button
            variant="default"
            size="icon"
            onClick={handlePlayPause}
            disabled={disabled}
            title={isPlaying ? 'Pause' : 'Play'}
            className="h-12 w-12"
          >
            {isPlaying ? (
              <Pause className="h-6 w-6" />
            ) : (
              <Play className="h-6 w-6 ml-0.5" />
            )}
          </Button>

          <Button
            variant="outline"
            size="icon"
            onClick={onStop}
            disabled={disabled || (!isPlaying && !isPaused)}
            title="Stop"
          >
            <Square className="h-4 w-4" />
          </Button>

          {/* Record Button */}
          {(onStartRecording || onStopRecording) && (
            <>
              <Button
                variant="outline"
                size="icon"
                onClick={isRecording ? onStopRecording : onStartRecording}
                disabled={disabled}
                title={isRecording ? 'Stop Recording' : 'Start Recording'}
                className={cn(
                  isRecording && 'bg-red-500/20 hover:bg-red-500/30 border-red-500/50',
                  isRecording && 'animate-pulse'
                )}
              >
                <Circle className={cn('h-4 w-4', isRecording && 'text-red-500 fill-red-500')} />
              </Button>

              {/* Recording Options */}
              <div className="flex items-center gap-1 border-l border-border pl-2 ml-1">
                {/* Punch In/Out Toggle */}
                {onPunchInEnabledChange && (
                  <Button
                    variant="ghost"
                    size="icon-sm"
                    onClick={() => onPunchInEnabledChange(!punchInEnabled)}
                    title="Toggle Punch In/Out Recording"
                    className={cn(
                      punchInEnabled && 'bg-primary/20 hover:bg-primary/30'
                    )}
                  >
                    <AlignVerticalJustifyStart className={cn('h-3.5 w-3.5', punchInEnabled && 'text-primary')} />
                  </Button>
                )}

                {/* Overdub Mode Toggle */}
                {onOverdubEnabledChange && (
                  <Button
                    variant="ghost"
                    size="icon-sm"
                    onClick={() => onOverdubEnabledChange(!overdubEnabled)}
                    title="Toggle Overdub Mode (layer recordings)"
                    className={cn(
                      overdubEnabled && 'bg-primary/20 hover:bg-primary/30'
                    )}
                  >
                    <Layers className={cn('h-3.5 w-3.5', overdubEnabled && 'text-primary')} />
                  </Button>
                )}
              </div>
            </>
          )}
        </div>

        {/* Volume Control & Master Meter */}
        <div className="flex items-center gap-4">
          {/* Master Meter */}
          <MasterMeter
            peakLevel={masterPeakLevel}
            rmsLevel={masterRmsLevel}
            isClipping={masterIsClipping}
            onResetClip={onResetClip}
          />

          {/* Volume Control */}
          <div className="flex items-center gap-3 min-w-[200px]">
            <Button
              variant="ghost"
              size="icon"
              onClick={handleMuteToggle}
              title={isMuted ? 'Unmute' : 'Mute'}
            >
              {isMuted || volume === 0 ? (
                <VolumeX className="h-5 w-5" />
              ) : (
                <Volume2 className="h-5 w-5" />
              )}
            </Button>

            <Slider
              value={volume}
              onChange={handleVolumeChange}
              min={0}
              max={1}
              step={0.01}
              className="flex-1"
            />
          </div>
        </div>
      </div>
    </div>
  );
}
