/**
 * Shared test fixtures — return values of `src/context/*` and `src/hooks/*`.
 *
 * None of these hooks export their result interface (e.g. `useAnalytics`'s
 * `UseAnalyticsResult` is private to useAnalytics.ts), and this file
 * deliberately does not add exports to make that possible — `ReturnType<typeof
 * theHook>` gets the same fully-typed result without touching source files.
 * `import type` erases at compile time, so this doesn't pull the hooks'
 * runtime code (or React) into the test bundle.
 */

import { vi } from 'vitest'
import type { useWorkspace } from '@/context/WorkspaceContext'
import type { useAuth } from '@/context/AuthContext'
import type { useAnalytics } from '@/hooks/useAnalytics'
import type { useParentalLeave } from '@/hooks/useParentalLeave'
import type { usePlannedDays } from '@/hooks/usePlannedDays'
import type { useScraperFetch } from '@/hooks/useScraperFetch'
import type { useWorkspaceMembers } from '@/hooks/useWorkspaceMembers'
import type { useOptimizationTips } from '@/hooks/useOptimizationTips'
import type { useDayOverrides } from '@/hooks/useDayOverrides'
import type { useLeaveWishes } from '@/hooks/useLeaveWishes'
import type { usePlanProposal } from '@/hooks/usePlanProposal'
import type { usePlanApply } from '@/hooks/usePlanApply'
import type { useVacationDays } from '@/hooks/useVacationDays'
import type { useChildSettings } from '@/hooks/useChildSettings'
import type { useCalendarDays } from '@/hooks/useCalendarDays'
import type { useShowWeekNumbers } from '@/hooks/useCalendarPreferences'
import { MOCK_CHILD, MOCK_PARENT_A, MOCK_VACATION_DAYS, MOCK_WORKSPACE, makeParentalLeaveFetch } from './mockData'
import { makeWorkspaceOverview } from './analytics'
import { makeCalendarWindow } from './calendar'

// ---------------------------------------------------------------------------
// Contexts
// ---------------------------------------------------------------------------

export function makeWorkspaceContextValue(
  overrides: Partial<ReturnType<typeof useWorkspace>> = {},
): ReturnType<typeof useWorkspace> {
  return {
    workspace: MOCK_WORKSPACE,
    isLoading: false,
    error: null,
    workspaceId: MOCK_WORKSPACE.id,
    setWorkspaceId: vi.fn(),
    refetch: vi.fn(),
    children: [{ id: MOCK_CHILD.id, name: MOCK_CHILD.name, birth_date: MOCK_CHILD.birthDate }],
    selectedChildId: MOCK_CHILD.id,
    selectChild: vi.fn(),
    personalDataUuid: MOCK_PARENT_A.uuid,
    parentName: MOCK_PARENT_A.name,
    refreshContext: vi.fn(),
    ...overrides,
  }
}

export function makeAuthContextValue(
  overrides: Partial<ReturnType<typeof useAuth>> = {},
): ReturnType<typeof useAuth> {
  return {
    accessToken: 'token-123',
    isAuthenticated: true,
    isLoading: false,
    login: vi.fn(),
    register: vi.fn(),
    logout: vi.fn(),
    ...overrides,
  }
}

// ---------------------------------------------------------------------------
// Data-fetching hooks
// ---------------------------------------------------------------------------

export function makeAnalyticsResult(
  overrides: Partial<ReturnType<typeof useAnalytics>> = {},
): ReturnType<typeof useAnalytics> {
  return {
    data: makeWorkspaceOverview(),
    isLoading: false,
    error: null,
    refresh: vi.fn(),
    ...overrides,
  }
}

export function makeParentalLeaveResult(
  overrides: Partial<ReturnType<typeof useParentalLeave>> = {},
): ReturnType<typeof useParentalLeave> {
  return {
    data: makeParentalLeaveFetch(),
    isLoading: false,
    error: null,
    refresh: vi.fn(),
    ...overrides,
  }
}

export function makePlannedDaysResult(
  overrides: Partial<ReturnType<typeof usePlannedDays>> = {},
): ReturnType<typeof usePlannedDays> {
  return {
    data: [],
    isLoading: false,
    error: null,
    refresh: vi.fn(),
    add: vi.fn(),
    update: vi.fn(),
    remove: vi.fn(),
    ...overrides,
  }
}

export function makeScraperFetchResult(
  overrides: Partial<ReturnType<typeof useScraperFetch>> = {},
): ReturnType<typeof useScraperFetch> {
  return {
    sessionId: null,
    pollData: null,
    resolvedIds: null,
    error: null,
    isUnauthorized: false,
    start: vi.fn(),
    cancel: vi.fn(),
    isRunning: false,
    isTerminal: false,
    ...overrides,
  }
}

export function makeWorkspaceMembersResult(
  overrides: Partial<ReturnType<typeof useWorkspaceMembers>> = {},
): ReturnType<typeof useWorkspaceMembers> {
  return {
    data: [MOCK_PARENT_A],
    isLoading: false,
    error: null,
    refresh: vi.fn(),
    ...overrides,
  }
}

export function makeOptimizationTipsResult(
  overrides: Partial<ReturnType<typeof useOptimizationTips>> = {},
): ReturnType<typeof useOptimizationTips> {
  return {
    data: [],
    isLoading: false,
    error: null,
    refresh: vi.fn(),
    dismiss: vi.fn(),
    ...overrides,
  }
}

export function makeDayOverridesResult(
  overrides: Partial<ReturnType<typeof useDayOverrides>> = {},
): ReturnType<typeof useDayOverrides> {
  return {
    data: [],
    isLoading: false,
    error: null,
    upsert: vi.fn(),
    remove: vi.fn(),
    ...overrides,
  }
}

export function makeLeaveWishesResult(
  overrides: Partial<ReturnType<typeof useLeaveWishes>> = {},
): ReturnType<typeof useLeaveWishes> {
  return {
    data: [],
    isLoading: false,
    isRefreshing: false,
    error: null,
    refresh: vi.fn(),
    add: vi.fn(),
    update: vi.fn(),
    remove: vi.fn(),
    ...overrides,
  }
}

export function makePlanProposalResult(
  overrides: Partial<ReturnType<typeof usePlanProposal>> = {},
): ReturnType<typeof usePlanProposal> {
  return {
    data: null,
    isLoading: false,
    error: null,
    propose: vi.fn(),
    ...overrides,
  }
}

export function makePlanApplyResult(
  overrides: Partial<ReturnType<typeof usePlanApply>> = {},
): ReturnType<typeof usePlanApply> {
  return {
    response: null,
    isLoading: false,
    error: null,
    apply: vi.fn(),
    ...overrides,
  }
}

export function makeVacationDaysResult(
  overrides: Partial<ReturnType<typeof useVacationDays>> = {},
): ReturnType<typeof useVacationDays> {
  return {
    data: [MOCK_VACATION_DAYS],
    isLoading: false,
    error: null,
    upsert: vi.fn(),
    ...overrides,
  }
}

export function makeChildSettingsResult(
  overrides: Partial<ReturnType<typeof useChildSettings>> = {},
): ReturnType<typeof useChildSettings> {
  return {
    data: MOCK_CHILD,
    isLoading: false,
    error: null,
    update: vi.fn(),
    ...overrides,
  }
}

export function makeCalendarDaysResult(
  overrides: Partial<ReturnType<typeof useCalendarDays>> = {},
): ReturnType<typeof useCalendarDays> {
  return {
    data: makeCalendarWindow(),
    isLoading: false,
    error: null,
    refetch: vi.fn(),
    ...overrides,
  }
}

// ---------------------------------------------------------------------------
// Local-storage-backed preference hook (a tuple, not an object)
// ---------------------------------------------------------------------------

export function makeShowWeekNumbersTuple(
  show = false,
  setShow: (show: boolean) => void = vi.fn(),
): ReturnType<typeof useShowWeekNumbers> {
  return [show, setShow]
}