"use client";

import { useState } from "react";
import { Button } from "@/components/ui/button";
import { Input } from "@/components/ui/input";
import { Badge } from "@/components/ui/badge";
import { LoadingSpinner } from "@/components/common/LoadingSpinner";
import { CodeFormModal } from "./CodeFormModal";
import { SortableCodeItem } from "./SortableCodeItem";
import { AlertModal } from "@/components/common/AlertModal";
import { Search, Plus } from "lucide-react";
import { cn } from "@/lib/utils";
import { useDeleteCode, useReorderCodes } from "@/hooks/queries/useCodes";
import { useCodesInfinite } from "@/hooks/queries/useCodesInfinite";
import type { CodeInfo } from "@/types/commonCode";

// Drag and Drop
import { DndContext, DragOverlay } from "@dnd-kit/core";
import { SortableContext, verticalListSortingStrategy } from "@dnd-kit/sortable";
import { useDragAndDrop } from "@/hooks/useDragAndDrop";
import { useSearchAndFilter } from "@/hooks/useSearchAndFilter";

interface CodeDetailPanelProps {
  categoryCode: string;
}

export function CodeDetailPanel({ categoryCode }: CodeDetailPanelProps) {
  // 검색 및 필터 상태 (먼저 선언)
  const [searchTerm, setSearchTerm] = useState("");
  const [showActiveOnly, setShowActiveOnly] = useState(false);

  // React Query로 코드 데이터 관리 (무한 스크롤)
  const {
    data: codes = [],
    isLoading,
    error,
    handleScroll,
    isFetchingNextPage,
    hasNextPage,
  } = useCodesInfinite(categoryCode, {
    search: searchTerm || undefined,
    active: showActiveOnly || undefined,
  });
  const deleteCodeMutation = useDeleteCode();
  const reorderCodesMutation = useReorderCodes();

  // 드래그앤드롭을 위해 필터링된 코드 목록 사용
  const { filteredItems: filteredCodes } = useSearchAndFilter(codes, {
    searchFields: ["code_name", "code_value"],
  });

  // 모달 상태
  const [showFormModal, setShowFormModal] = useState(false);
  const [editingCode, setEditingCode] = useState<CodeInfo | null>(null);
  const [showDeleteModal, setShowDeleteModal] = useState(false);
  const [deletingCode, setDeletingCode] = useState<CodeInfo | null>(null);

  // 드래그 앤 드롭 훅 사용
  const dragAndDrop = useDragAndDrop<CodeInfo>({
    items: filteredCodes,
    onReorder: async (reorderedItems) => {
      await reorderCodesMutation.mutateAsync({
        categoryCode,
        codes: reorderedItems.map((item) => ({
          codeValue: item.id,
          sortOrder: item.sortOrder,
        })),
      });
    },
    getItemId: (code: CodeInfo) => code.codeValue || code.code_value,
  });

  // 새 코드 생성
  const handleNewCode = () => {
    setEditingCode(null);
    setShowFormModal(true);
  };

  // 코드 수정
  const handleEditCode = (code: CodeInfo) => {
    setEditingCode(code);
    setShowFormModal(true);
  };

  // 코드 삭제 확인
  const handleDeleteCode = (code: CodeInfo) => {
    setDeletingCode(code);
    setShowDeleteModal(true);
  };

  // 코드 삭제 실행
  const handleConfirmDelete = async () => {
    if (!deletingCode) return;

    try {
      await deleteCodeMutation.mutateAsync({
        categoryCode,
        codeValue: deletingCode.codeValue || deletingCode.code_value,
      });

      setShowDeleteModal(false);
      setDeletingCode(null);
    } catch (error) {
      console.error("코드 삭제 실패:", error);
    }
  };

  // 드래그 앤 드롭 로직은 useDragAndDrop 훅에서 처리

  if (!categoryCode) {
    return (
      <div className="flex h-full items-center justify-center">
        <div className="text-center text-gray-500">
          <p>카테고리를 선택하세요</p>
        </div>
      </div>
    );
  }

  if (error) {
    return (
      <div className="flex h-full items-center justify-center">
        <div className="text-center">
          <p className="text-destructive">코드를 불러오는 중 오류가 발생했습니다.</p>
          <Button variant="outline" onClick={() => window.location.reload()} className="mt-2">
            다시 시도
          </Button>
        </div>
      </div>
    );
  }

  return (
    <div className="flex h-full flex-col">
      {/* 검색 및 필터 */}
      <div className="border-b p-4">
        <div className="space-y-3">
          {/* 검색 */}
          <div className="relative">
            <Search className="absolute top-1/2 left-3 h-4 w-4 -translate-y-1/2 text-gray-400" />
            <Input
              placeholder="코드 검색..."
              value={searchTerm}
              onChange={(e) => setSearchTerm(e.target.value)}
              className="pl-10"
            />
          </div>

          {/* 활성 필터 */}
          <div className="flex items-center space-x-2">
            <input
              type="checkbox"
              id="activeOnlyCodes"
              checked={showActiveOnly}
              onChange={(e) => setShowActiveOnly(e.target.checked)}
              className="rounded border-gray-300"
            />
            <label htmlFor="activeOnlyCodes" className="text-sm text-muted-foreground">
              활성 코드만 표시
            </label>
          </div>

          {/* 새 코드 버튼 */}
          <Button onClick={handleNewCode} className="w-full" size="sm">
            <Plus className="mr-2 h-4 w-4" />새 코드
          </Button>
        </div>
      </div>

      {/* 코드 목록 (무한 스크롤) */}
      <div className="h-96 overflow-y-auto" onScroll={handleScroll}>
        {isLoading ? (
          <div className="flex h-32 items-center justify-center">
            <LoadingSpinner />
          </div>
        ) : filteredCodes.length === 0 ? (
          <div className="p-4 text-center text-gray-500">
            {codes.length === 0 ? "코드가 없습니다." : "검색 결과가 없습니다."}
          </div>
        ) : (
          <>
            <div className="p-2">
              <DndContext {...dragAndDrop.dndContextProps}>
                <SortableContext
                  items={filteredCodes.map((code) => code.codeValue || code.code_value)}
                  strategy={verticalListSortingStrategy}
                >
                  <div className="space-y-1">
                    {filteredCodes.map((code, index) => (
                      <SortableCodeItem
                        key={`${code.codeValue || code.code_value}-${index}`}
                        code={code}
                        categoryCode={categoryCode}
                        onEdit={() => handleEditCode(code)}
                        onDelete={() => handleDeleteCode(code)}
                      />
                    ))}
                  </div>
                </SortableContext>

                <DragOverlay dropAnimation={null}>
                  {dragAndDrop.activeItem ? (
                    <div className="cursor-grabbing rounded-lg border border-gray-300 bg-white p-3 shadow-lg">
                      {(() => {
                        const activeCode = dragAndDrop.activeItem;
                        if (!activeCode) return null;
                        return (
                          <div className="flex items-start justify-between">
                            <div className="min-w-0 flex-1">
                              <div className="flex items-center gap-2">
                                <h3 className="font-medium text-gray-900">
                                  {activeCode.codeName || activeCode.code_name}
                                </h3>
                                <Badge
                                  variant={
                                    activeCode.isActive === "Y" || activeCode.is_active === "Y"
                                      ? "default"
                                      : "secondary"
                                  }
                                  className={cn(
                                    "transition-colors",
                                    activeCode.isActive === "Y" || activeCode.is_active === "Y"
                                      ? "bg-green-100 text-green-800"
                                      : "bg-gray-100 text-muted-foreground",
                                  )}
                                >
                                  {activeCode.isActive === "Y" || activeCode.is_active === "Y" ? "활성" : "비활성"}
                                </Badge>
                              </div>
                              <p className="mt-1 text-sm text-muted-foreground">
                                {activeCode.codeValue || activeCode.code_value}
                              </p>
                              {activeCode.description && (
                                <p className="mt-1 text-sm text-gray-500">{activeCode.description}</p>
                              )}
                            </div>
                          </div>
                        );
                      })()}
                    </div>
                  ) : null}
                </DragOverlay>
              </DndContext>
            </div>

            {/* 무한 스크롤 로딩 인디케이터 */}
            {isFetchingNextPage && (
              <div className="flex items-center justify-center py-4">
                <LoadingSpinner size="sm" />
                <span className="ml-2 text-sm text-gray-500">코드를 더 불러오는 중...</span>
              </div>
            )}

            {/* 모든 코드 로드 완료 메시지 */}
            {!hasNextPage && codes.length > 0 && (
              <div className="py-4 text-center text-sm text-gray-500">모든 코드를 불러왔습니다.</div>
            )}
          </>
        )}
      </div>

      {/* 코드 폼 모달 */}
      {showFormModal && (
        <CodeFormModal
          isOpen={showFormModal}
          onClose={() => {
            setShowFormModal(false);
            setEditingCode(null);
          }}
          categoryCode={categoryCode}
          editingCode={editingCode}
          codes={codes}
        />
      )}

      {/* 삭제 확인 모달 */}
      {showDeleteModal && (
        <AlertModal
          isOpen={showDeleteModal}
          onClose={() => setShowDeleteModal(false)}
          type="error"
          title="코드 삭제"
          message="정말로 이 코드를 삭제하시겠습니까? 이 작업은 되돌릴 수 없습니다."
          confirmText="삭제"
          onConfirm={handleConfirmDelete}
        />
      )}
    </div>
  );
}
