import type * as Native from './css.js'
import type * as Config from './config.js'
import type * as ThemeUtil from './theme.js'
import type * as Util from './util.js'

export { Native }

/** CSS style declaration object. */
export interface CSSProperties
	extends Native.StandardLonghandProperties,
		Native.StandardShorthandProperties,
		Native.SvgProperties {}

type ValueByPropertyName<PropertyName> = PropertyName extends keyof CSSProperties ? CSSProperties[PropertyName] : never

type TokenByPropertyName<PropertyName, Theme, ThemeMap> = PropertyName extends keyof ThemeMap
	? TokenByScaleName<ThemeMap[PropertyName], Theme>
	: never

type TokenByScaleName<ScaleName, Theme> = ScaleName extends keyof Theme
	? Util.Prefixed<'$', keyof Theme[ScaleName]>
	: never

/** Returns a Style interface, leveraging the given media and style map. */
export type CSS<Media = {}, Theme = {}, ThemeMap = Config.DefaultThemeMap, Utils = {}> =
	// nested at-rule css styles
	{
		[K in Util.Prefixed<'@', keyof Media>]?: CSS<Media, Theme, ThemeMap, Utils>
	} & { // known property styles
		[K in keyof CSSProperties as K extends keyof Utils ? never : K]?:
			| ValueByPropertyName<K>
			| TokenByPropertyName<K, Theme, ThemeMap>
			| Native.Globals
			| ThemeUtil.ScaleValue
			| Util.Index
			| undefined
	} & { // known utility styles
		[K in keyof Utils]?: Utils[K] extends (arg: infer P) => any
			?
					| (P extends any[]
							?
									| ($$PropertyValue extends keyof P[0]
											?
													| ValueByPropertyName<P[0][$$PropertyValue]>
													| TokenByPropertyName<P[0][$$PropertyValue], Theme, ThemeMap>
													| Native.Globals
													| ThemeUtil.ScaleValue
													| undefined
											: $$ScaleValue extends keyof P[0]
												? TokenByScaleName<P[0][$$ScaleValue], Theme> | { scale: P[0][$$ScaleValue] } | undefined
												: never)[]
									| P
							: $$PropertyValue extends keyof P
								?
										| ValueByPropertyName<P[$$PropertyValue]>
										| TokenByPropertyName<P[$$PropertyValue], Theme, ThemeMap>
										| Native.Globals
										| undefined
								: $$ScaleValue extends keyof P
									? TokenByScaleName<P[$$ScaleValue], Theme> | { scale: P[$$ScaleValue] } | undefined
									: never)
					| P
			: never
	} & { // known theme styles
		[K in keyof ThemeMap as K extends keyof CSSProperties ? never : K extends keyof Utils ? never : K]?:
			| Native.Globals
			| Util.Index
			| undefined
	} & { // unknown css declaration styles
		/** Unknown property. */
		[K: string]: number | string | CSS<Media, Theme, ThemeMap, Utils> | {} | undefined
	}

/** Unique symbol used to reference a property value. */
export declare const $$PropertyValue: unique symbol

/** Unique symbol used to reference a property value. */
export type $$PropertyValue = typeof $$PropertyValue

/** Unique symbol used to reference a token value. */
export declare const $$ScaleValue: unique symbol

/** Unique symbol used to reference a token value. */
export type $$ScaleValue = typeof $$ScaleValue

export declare const $$ThemeValue: unique symbol

export type $$ThemeValue = typeof $$ThemeValue

// https://github.com/microsoft/TypeScript/issues/37888#issuecomment-846638356
export type WithPropertyValue<T> = {
	readonly [K in $$PropertyValue]: T
}
export type WithScaleValue<T> = {
	readonly [K in $$ScaleValue]: T
}