import { computed, ref, type ComputedRef, type Ref, type WritableComputedRef } from 'vue'
import type {
  PageSelectorItem,
  PageSelectorItemInput,
  PillNavItem,
  PillNavItemInput,
} from '../types'

type ReadableRef<T> = Readonly<Ref<T>>

export interface PluginWorkspaceNavigationOptions {
  activeView: () => string | undefined
  defaultActiveView: () => string | undefined
  currentPillId: () => string | undefined
  currentPageSelectorId: () => string | undefined
  pillNav: () => PillNavItemInput[] | undefined
  pageSelector: () => PageSelectorItemInput[] | undefined
  panelIds: () => string[]
  generatedPillNav: ReadableRef<readonly PillNavItem[]>
  generatedDefaultView: ReadableRef<string>
  emitActiveView: (viewId: string) => void
  emitPageSelectorSelect: (page: PageSelectorItem) => void
  emitPillSelect: (item: PillNavItem) => void
}

export interface PluginWorkspaceNavigation {
  resolvedPillNav: ComputedRef<PillNavItemInput[] | undefined>
  firstConfiguredViewId: ComputedRef<string>
  resolvedActiveView: WritableComputedRef<string>
  resolvedCurrentPillId: ComputedRef<string>
  resolvedCurrentPageSelectorId: ComputedRef<string>
  setActiveView: (viewId: string) => void
  handlePageSelectorSelect: (page: PageSelectorItem) => void
  handlePillSelect: (item: PillNavItem) => void
}

export function usePluginWorkspaceNavigation(
  options: PluginWorkspaceNavigationOptions,
): PluginWorkspaceNavigation {
  const internalActiveView = ref(options.defaultActiveView())

  const resolvedPillNav = computed<PillNavItemInput[] | undefined>(() => {
    if (options.pillNav() !== undefined) return options.pillNav()
    return options.generatedPillNav.value.length > 0
      ? [...options.generatedPillNav.value]
      : undefined
  })

  const firstConfiguredViewId = computed(() =>
    options.defaultActiveView()
      ?? firstItemId(options.pillNav())
      ?? options.generatedDefaultView.value
      ?? firstItemId(options.pageSelector())
      ?? options.panelIds()[0]
      ?? '',
  )

  const resolvedActiveView = computed({
    get: () =>
      options.activeView()
        ?? options.currentPillId()
        ?? options.currentPageSelectorId()
        ?? internalActiveView.value
        ?? firstConfiguredViewId.value,
    set: (value: string) => {
      internalActiveView.value = value
      options.emitActiveView(value)
    },
  })

  const resolvedCurrentPillId = computed(() => options.currentPillId() ?? resolvedActiveView.value)
  const resolvedCurrentPageSelectorId = computed(() =>
    options.currentPageSelectorId() ?? resolvedActiveView.value,
  )

  function setActiveView(viewId: string) {
    resolvedActiveView.value = viewId
  }

  function handlePageSelectorSelect(page: PageSelectorItem) {
    setActiveView(page.id)
    options.emitPageSelectorSelect(page)
  }

  function handlePillSelect(item: PillNavItem) {
    setActiveView(item.id)
    options.emitPillSelect(item)
  }

  return {
    resolvedPillNav,
    firstConfiguredViewId,
    resolvedActiveView,
    resolvedCurrentPillId,
    resolvedCurrentPageSelectorId,
    setActiveView,
    handlePageSelectorSelect,
    handlePillSelect,
  }
}

function firstItemId(items?: readonly (string | { id: string })[]): string | undefined {
  const item = items?.[0]
  if (item === undefined) return undefined
  return typeof item === 'string' ? item : item.id
}