import React, { useState, useRef } from 'react';
import { UploadCloud, CheckCircle2, Loader2, X, File as FileIcon } from 'lucide-react';

interface FileUploadProps {
  label?: string;
  accept?: string;
  maxSizeMB?: number;
  onUploadSuccess: (url: string, filename: string) => void;
  onUploadError?: (error: string) => void;
  defaultUrl?: string; // If a file is already uploaded
  className?: string;
}

export function FileUpload({
  label = 'Upload File',
  accept = 'image/jpeg, image/png, image/webp, application/pdf',
  maxSizeMB = 5,
  onUploadSuccess,
  onUploadError,
  defaultUrl,
  className = '',
}: FileUploadProps) {
  const [isDragging, setIsDragging] = useState(false);
  const [isUploading, setIsUploading] = useState(false);
  const [fileUrl, setFileUrl] = useState<string | null>(defaultUrl || null);
  const [filename, setFilename] = useState<string | null>(defaultUrl ? defaultUrl.split('/').pop() || null : null);
  const fileInputRef = useRef<HTMLInputElement>(null);

  const handleDragOver = (e: React.DragEvent) => {
    e.preventDefault();
    setIsDragging(true);
  };

  const handleDragLeave = (e: React.DragEvent) => {
    e.preventDefault();
    setIsDragging(false);
  };

  const handleDrop = (e: React.DragEvent) => {
    e.preventDefault();
    setIsDragging(false);
    if (e.dataTransfer.files && e.dataTransfer.files.length > 0) {
      handleFileSelected(e.dataTransfer.files[0]);
    }
  };

  const handleFileInput = (e: React.ChangeEvent<HTMLInputElement>) => {
    if (e.target.files && e.target.files.length > 0) {
      handleFileSelected(e.target.files[0]);
    }
  };

  const handleFileSelected = async (file: File) => {
    // Validate size
    if (file.size > maxSizeMB * 1024 * 1024) {
      const errorMsg = `File size exceeds ${maxSizeMB}MB limit.`;
      if (onUploadError) onUploadError(errorMsg);
      else alert(errorMsg);
      return;
    }

    // Validate type (basic client check)
    const allowedTypes = accept.split(',').map((t) => t.trim());
    if (accept !== '*' && !allowedTypes.includes(file.type) && !allowedTypes.some(t => file.type.match(new RegExp(t.replace('*', '.*'))))) {
       // Just a loose fallback check. The server will strictly validate.
    }

    setIsUploading(true);
    const formData = new FormData();
    formData.append('file', file);

    try {
      const res = await fetch('/api/upload', {
        method: 'POST',
        body: formData,
      });

      const data = await res.json();

      if (!res.ok) {
        throw new Error(data.error || 'Upload failed');
      }

      setFileUrl(data.url);
      setFilename(data.filename);
      onUploadSuccess(data.url, data.filename);
    } catch (err: any) {
      if (onUploadError) onUploadError(err.message);
      else alert(err.message);
    } finally {
      setIsUploading(false);
      if (fileInputRef.current) {
        fileInputRef.current.value = ''; // Reset input
      }
    }
  };

  const handleRemove = (e: React.MouseEvent) => {
    e.stopPropagation();
    setFileUrl(null);
    setFilename(null);
    onUploadSuccess('', ''); // Empty url means removed
  };

  return (
    <div className={`w-full ${className}`}>
      {label && <label className="block text-sm font-medium text-slate-700 dark:text-slate-300 mb-2">{label}</label>}
      
      <div
        className={`relative border-2 border-dashed rounded-xl p-6 transition-all duration-200 
          ${isDragging ? 'border-indigo-500 bg-indigo-50 dark:bg-indigo-500/10' : 'border-slate-300 dark:border-slate-700 bg-slate-50 dark:bg-slate-800/50 hover:bg-slate-100 dark:hover:bg-slate-800'}
          ${fileUrl ? 'border-green-500/50 bg-green-50/50 dark:bg-green-500/5' : ''}
        `}
        onDragOver={handleDragOver}
        onDragLeave={handleDragLeave}
        onDrop={handleDrop}
        onClick={() => !isUploading && fileInputRef.current?.click()}
      >
        <input
          type="file"
          ref={fileInputRef}
          onChange={handleFileInput}
          accept={accept}
          className="hidden"
          disabled={isUploading}
        />

        <div className="flex flex-col items-center justify-center text-center space-y-3 cursor-pointer">
          {isUploading ? (
            <>
              <Loader2 className="h-10 w-10 text-indigo-500 animate-spin" />
              <p className="text-sm text-slate-600 dark:text-slate-400 font-medium">Uploading file...</p>
            </>
          ) : fileUrl ? (
            <>
              <div className="h-12 w-12 rounded-full bg-green-100 dark:bg-green-500/20 flex items-center justify-center text-green-600 dark:text-green-400 mb-2">
                <CheckCircle2 className="h-6 w-6" />
              </div>
              <div className="space-y-1">
                <p className="text-sm font-semibold text-slate-900 dark:text-white flex items-center justify-center gap-2">
                  <FileIcon className="h-4 w-4 text-slate-500" />
                  {filename || 'File uploaded successfully'}
                </p>
                <button
                  type="button"
                  onClick={handleRemove}
                  className="text-xs text-red-500 hover:text-red-600 font-medium flex items-center justify-center gap-1 mx-auto mt-2"
                >
                  <X className="h-3 w-3" /> Remove File
                </button>
              </div>
            </>
          ) : (
            <>
              <div className={`h-12 w-12 rounded-full flex items-center justify-center mb-2 transition-colors
                ${isDragging ? 'bg-indigo-100 text-indigo-600 dark:bg-indigo-500/20 dark:text-indigo-400' : 'bg-slate-100 text-slate-500 dark:bg-slate-800 dark:text-slate-400'}
              `}>
                <UploadCloud className="h-6 w-6" />
              </div>
              <div>
                <p className="text-sm font-medium text-slate-900 dark:text-white">
                  <span className="text-indigo-600 dark:text-indigo-400 hover:underline">Click to upload</span> or drag and drop
                </p>
                <p className="text-xs text-slate-500 dark:text-slate-400 mt-1">
                  Supported formats: JPEG, PNG, WEBP, PDF (Max {maxSizeMB}MB)
                </p>
              </div>
            </>
          )}
        </div>
      </div>
    </div>
  );
}
