import type {
	AtomFamilyToken,
	AtomIOToken,
	AtomToken,
	HeldSelectorFamilyToken,
	HeldSelectorToken,
	MutableAtomFamilyToken,
	MutableAtomToken,
	PureSelectorFamilyToken,
	PureSelectorToken,
	ReadableFamilyToken,
	ReadableToken,
	ReadonlyHeldSelectorFamilyToken,
	ReadonlyHeldSelectorToken,
	ReadonlyPureSelectorFamilyToken,
	ReadonlyPureSelectorToken,
	ReadonlySelectorFamilyToken,
	ReadonlySelectorToken,
	RegularAtomFamilyToken,
	RegularAtomToken,
	SelectorFamilyToken,
	SelectorToken,
	TimelineFamilyToken,
	TimelineManageable,
	TimelineToken,
	TransactionToken,
	WritableFamilyToken,
	WritableHeldSelectorFamilyToken,
	WritableHeldSelectorToken,
	WritablePureSelectorFamilyToken,
	WritablePureSelectorToken,
	WritableSelectorFamilyToken,
	WritableSelectorToken,
	WritableToken,
} from "atom.io"
import { NotFoundError } from "atom.io"
import type { Canonical } from "atom.io/foundations/canonical"

import type { Transceiver } from "../mutable/index.ts"
import type {
	Atom,
	AtomFamily,
	AtomIOInternalResource,
	HeldSelector,
	HeldSelectorFamily,
	MutableAtom,
	MutableAtomFamily,
	PureSelector,
	PureSelectorFamily,
	ReadableFamily,
	ReadableState,
	ReadonlyHeldSelector,
	ReadonlyHeldSelectorFamily,
	ReadonlyPureSelector,
	ReadonlyPureSelectorFamily,
	ReadonlySelector,
	ReadonlySelectorFamily,
	RegularAtom,
	RegularAtomFamily,
	Selector,
	SelectorFamily,
	WritableFamily,
	WritableHeldSelector,
	WritableHeldSelectorFamily,
	WritablePureSelector,
	WritablePureSelectorFamily,
	WritableSelector,
	WritableSelectorFamily,
	WritableState,
} from "../state-types.ts"
import type { Timeline, TimelineFamily } from "../timeline/index.ts"
import type { Transaction } from "../transaction/index.ts"
import type { Fn } from "../utility-types.ts"
import type { Store } from "./store.ts"

export function withdraw<T, E>(
	store: Store,
	token: RegularAtomToken<T, any, E>,
): RegularAtom<T, E>
export function withdraw<T extends Transceiver<any, any, any>>(
	store: Store,
	token: MutableAtomToken<T, any>,
): MutableAtom<T>
export function withdraw<T, E>(
	store: Store,
	token: AtomToken<T, any, E>,
): Atom<T, E>
export function withdraw<T>(
	store: Store,
	token: WritableHeldSelectorToken<T>,
): WritableHeldSelector<T>
export function withdraw<T>(
	store: Store,
	token: ReadonlyHeldSelectorToken<T>,
): ReadonlyHeldSelector<T>
export function withdraw<T, E>(
	store: Store,
	token: WritablePureSelectorToken<T, any, E>,
): WritablePureSelector<T, E>
export function withdraw<T, E>(
	store: Store,
	token: ReadonlyPureSelectorToken<T, any, E>,
): ReadonlyPureSelector<T, E>
export function withdraw<T, E>(
	store: Store,
	token: ReadonlySelectorToken<T, any, E>,
): ReadonlySelector<T, E>
export function withdraw<T, E>(
	store: Store,
	token: WritableSelectorToken<T, any, E>,
): WritableSelector<T, E>
export function withdraw<T>(
	store: Store,
	token: HeldSelectorToken<T>,
): HeldSelector<T>
export function withdraw<T, E>(
	store: Store,
	token: PureSelectorToken<T, any, E>,
): PureSelector<T, E>
export function withdraw<T, E>(
	store: Store,
	token: SelectorToken<T, any, E>,
): Selector<T, E>
export function withdraw<T, E>(
	store: Store,
	token: WritableToken<T, any, E>,
): WritableState<T, E>
export function withdraw<T, E>(
	store: Store,
	token: ReadableToken<T, any, E>,
): ReadableState<T, E>

export function withdraw<T, K extends Canonical, E>(
	store: Store,
	token: RegularAtomFamilyToken<T, K, E>,
): RegularAtomFamily<T, K, E>
export function withdraw<
	T extends Transceiver<any, any, any>,
	K extends Canonical,
>(store: Store, token: MutableAtomFamilyToken<T, K>): MutableAtomFamily<T, K>
export function withdraw<T, K extends Canonical, E>(
	store: Store,
	token: AtomFamilyToken<T, K, E>,
): AtomFamily<T, K, E>
export function withdraw<T, K extends Canonical>(
	store: Store,
	token: ReadonlyHeldSelectorFamilyToken<T, K>,
): ReadonlyHeldSelectorFamily<T, K>
export function withdraw<T, K extends Canonical>(
	store: Store,
	token: WritableHeldSelectorFamilyToken<T, K>,
): WritableHeldSelectorFamily<T, K>
export function withdraw<T, K extends Canonical, E>(
	store: Store,
	token: ReadonlyPureSelectorFamilyToken<T, K, E>,
): ReadonlyPureSelectorFamily<T, K, E>
export function withdraw<T, K extends Canonical, E>(
	store: Store,
	token: WritablePureSelectorFamilyToken<T, K, E>,
): WritablePureSelectorFamily<T, K, E>
export function withdraw<T, K extends Canonical, E>(
	store: Store,
	token: ReadonlySelectorFamilyToken<T, K, E>,
): ReadonlySelectorFamily<T, K, E>
export function withdraw<T, K extends Canonical, E>(
	store: Store,
	token: WritableSelectorFamilyToken<T, K, E>,
): WritableSelectorFamily<T, K, E>
export function withdraw<T, K extends Canonical>(
	store: Store,
	token: HeldSelectorFamilyToken<T, K>,
): HeldSelectorFamily<T, K>
export function withdraw<T, K extends Canonical, E>(
	store: Store,
	token: PureSelectorFamilyToken<T, K, E>,
): PureSelectorFamily<T, K, E>
export function withdraw<T, K extends Canonical, E>(
	store: Store,
	token: SelectorFamilyToken<T, K, E>,
): SelectorFamily<T, K, E>
export function withdraw<T, K extends Canonical, E>(
	store: Store,
	token: WritableFamilyToken<T, K, E>,
): WritableFamily<T, K, E>
export function withdraw<T, K extends Canonical, E>(
	store: Store,
	token: ReadableFamilyToken<T, K, E>,
): ReadableFamily<T, K, E>

export function withdraw<T extends Fn>(
	store: Store,
	token: TransactionToken<T>,
): Transaction<T extends Fn ? T : never>
export function withdraw<K extends Canonical, M extends TimelineManageable>(
	store: Store,
	token: TimelineFamilyToken<K, M>,
): TimelineFamily<K, M>
export function withdraw<T>(
	store: Store,
	token: TimelineToken<T>,
): Timeline<T extends TimelineManageable ? T : never>

export function withdraw<T, E>(
	store: Store,
	token: WritableToken<T, any, E>,
): WritableState<T, E>
export function withdraw<T, E>(
	store: Store,
	token: ReadableToken<T, any, E>,
): ReadableState<T, E>

export function withdraw(
	store: Store,
	token: AtomIOToken,
): AtomIOInternalResource

export function withdraw(
	store: Store,
	token: AtomIOToken,
): AtomIOInternalResource {
	let withdrawn: AtomIOInternalResource | undefined
	let target: Store | null = store
	while (target !== null) {
		switch (token.type) {
			case `atom`:
			case `mutable_atom`:
				withdrawn = target.atoms.get(token.key)
				break
			case `writable_pure_selector`:
			case `writable_held_selector`:
				withdrawn = target.writableSelectors.get(token.key)
				break
			case `readonly_pure_selector`:
			case `readonly_held_selector`:
				withdrawn = target.readonlySelectors.get(token.key)
				break
			case `atom_family`:
			case `mutable_atom_family`:
			case `writable_pure_selector_family`:
			case `readonly_pure_selector_family`:
			case `writable_held_selector_family`:
			case `readonly_held_selector_family`:
				withdrawn = target.families.get(token.key)
				break
			case `timeline`:
				withdrawn = target.timelines.get(token.key)
				break
			case `timeline_family`:
				withdrawn = target.timelineFamilies.get(token.key)
				break
			case `transaction`:
				withdrawn = target.transactions.get(token.key)
				break
		}
		if (withdrawn) {
			return withdrawn
		}
		target = target.child
	}
	throw new NotFoundError(token, store.config.name)
}