feat(sets): manage conflicts on import

Author: chiptus

CLAUDE.md

@@ -113,6 +113,8 @@ src/
 - **Component Extraction**: When a section of JSX + logic becomes substantial (>30 lines) or reusable, extract it into a separate component. Place in appropriate directory: page-specific components in `components/PageName/`, reusable ones in `components/`
 - **Forms**: ALL forms must use react-hook-form with proper validation. Never use plain HTML forms or manual state management for form inputs. Use @hookform/resolvers for validation schemas when needed.
 - **Long Components**: Break long components (>150 lines) into smaller focused pieces. Follow the FilterSortControls pattern of primary controls + expandable sections.
+- No barrel exports - always import directly from file path
+- Use `cn` for conditional class names instead of template literals
 
 #### Function Definitions After Return in React Components
 

src/hooks/queries/artists/useDuplicateArtists.ts

@@ -27,7 +27,8 @@ async function fetchDuplicateArtists(): Promise<DuplicateGroup[]> {
 
   const nameCounts = duplicateNames.reduce(
     (acc, artist) => {
-      acc[artist.name] = (acc[artist.name] || 0) + 1;
+      acc[artist.name.toLocaleLowerCase()] =
+        (acc[artist.name.toLocaleLowerCase()] || 0) + 1;
       return acc;
     },
     {} as Record<string, number>,
@@ -52,7 +53,7 @@ async function fetchDuplicateArtists(): Promise<DuplicateGroup[]> {
         artist_music_genres (music_genre_id)
       `,
       )
-      .eq("name", name)
+      .ilike("name", name)
       .eq("archived", false)
       .order("created_at", { ascending: false });
 

src/hooks/useImportConflictResolution.ts

@@ -0,0 +1,96 @@
+import { useState, useCallback } from "react";
+import type {
+  ImportConflict,
+  ConflictResolution,
+} from "@/services/csv/conflictDetector";
+
+interface UseImportConflictResolutionProps {
+  conflicts: ImportConflict[];
+  onResolutionsChange?: (resolutions: Map<number, ConflictResolution>) => void;
+}
+
+export function useImportConflictResolution({
+  conflicts,
+  onResolutionsChange,
+}: UseImportConflictResolutionProps) {
+  const [resolutions, setResolutions] = useState<
+    Map<number, ConflictResolution>
+  >(new Map());
+  const [activeConflictIndex, setActiveConflictIndex] = useState<number | null>(
+    null,
+  );
+
+  const updateResolution = useCallback(
+    (conflictIndex: number, resolution: ConflictResolution) => {
+      setResolutions((prev) => {
+        const newResolutions = new Map(prev);
+        newResolutions.set(conflictIndex, resolution);
+        onResolutionsChange?.(newResolutions);
+        return newResolutions;
+      });
+    },
+    [onResolutionsChange],
+  );
+
+  const applyBulkResolution = useCallback(
+    (resolution: ConflictResolution) => {
+      setResolutions((prev) => {
+        const newResolutions = new Map(prev);
+        conflicts.forEach((_, index) => {
+          if (!newResolutions.has(index)) {
+            newResolutions.set(index, resolution);
+          }
+        });
+        onResolutionsChange?.(newResolutions);
+        return newResolutions;
+      });
+    },
+    [conflicts, onResolutionsChange],
+  );
+
+  const getUnresolvedCount = useCallback(() => {
+    return conflicts.length - resolutions.size;
+  }, [conflicts.length, resolutions.size]);
+
+  const getResolutionSummary = useCallback(() => {
+    const summary = {
+      skip: 0,
+      import_new: 0,
+      merge: 0,
+    };
+
+    resolutions.forEach((resolution) => {
+      summary[resolution.type]++;
+    });
+
+    return summary;
+  }, [resolutions]);
+
+  const openConflictComparison = useCallback(
+    (conflictIndex: number, _targetArtistId?: string) => {
+      setActiveConflictIndex(conflictIndex);
+    },
+    [],
+  );
+
+  const closeConflictComparison = useCallback(() => {
+    setActiveConflictIndex(null);
+  }, []);
+
+  const getActiveConflict = useCallback(() => {
+    if (activeConflictIndex === null) return null;
+    return conflicts[activeConflictIndex] || null;
+  }, [conflicts, activeConflictIndex]);
+
+  return {
+    resolutions,
+    activeConflictIndex,
+    updateResolution,
+    applyBulkResolution,
+    getUnresolvedCount,
+    getResolutionSummary,
+    openConflictComparison,
+    closeConflictComparison,
+    getActiveConflict,
+  };
+}

src/lib/timeUtils.ts

@@ -108,9 +108,19 @@ export function toDatetimeLocal(isoString: string | null): string {
 
 // Helper function to convert local datetime-local to UTC ISO string
 export function toISOString(datetimeLocal: string): string {
-  if (!datetimeLocal) return "";
-  const localDate = new Date(datetimeLocal);
-  const userTimeZone = getUserTimeZone();
-  const utcDate = fromZonedTime(localDate, userTimeZone);
+  return convertLocalTimeToUTC(datetimeLocal, getUserTimeZone()) || "";
+}
+
+// Helper function to convert local time string to UTC for database storage (used in CSV imports)
+export function convertLocalTimeToUTC(
+  timeString: string | undefined,
+  timezone: string,
+): string | null {
+  if (!timeString) return null;
+
+  // Parse the time string and interpret it as being in the specified timezone
+  // First create a date object assuming the time is in the target timezone
+  const utcDate = fromZonedTime(timeString, timezone);
+
   return utcDate.toISOString();
 }