import type { ContextMenu } from "./ContextMenu"
import type { LGraphNode } from "./LGraphNode"
import type { LinkDirection, RenderShape } from "./types/globalEnums"
import type { LinkId } from "./LLink"

export type Dictionary<T> = { [key: string]: T }

export type CanvasColour = string | CanvasGradient | CanvasPattern

export interface IInputOrOutput {
    // If an input, this will be defined
    input?: INodeInputSlot
    // If an output, this will be defined
    output?: INodeOutputSlot
}

export interface IFoundSlot extends IInputOrOutput {
    // Slot index
    slot: number
    // Centre point of the rendered slot connection
    link_pos: Point
}

/** A point on the canvas: x, y */
export type Point = [x: number, y: number] | Float32Array | Float64Array

/** A size: width, height */
export type Size = [width: number, height: number] | Float32Array | Float64Array

/** A very firm array */
type ArRect = [x: number, y: number, width: number, height: number]

/** A rectangle starting at top-left coordinates: x, y, width, height */
export type Rect = ArRect | Float32Array | Float64Array

// TODO: Need regular arrays also?
export type Rect32 = Float32Array

/** Union of property names that are of type Match */
export type KeysOfType<T, Match> = { [P in keyof T]: T[P] extends Match ? P : never }[keyof T]

/** A new type that contains only the properties of T that are of type Match */
export type PickByType<T, Match> = { [P in keyof T]: Extract<T[P], Match> }

/** The names of all methods and functions in T */
export type MethodNames<T> = KeysOfType<T, (...args: any) => any>

export interface IBoundaryNodes {
    top: LGraphNode
    right: LGraphNode
    bottom: LGraphNode
    left: LGraphNode
}

export type Direction = "top" | "bottom" | "left" | "right"

// TODO: Rename IOptionalSlotsData
export interface IOptionalInputsData {
    content: string
    value?
    className?: string
}

export type ISlotType = number | string

export interface INodeSlot {
    name: string
    type: ISlotType
    dir?: LinkDirection
    removable?: boolean
    shape?: RenderShape
    not_subgraph_input?: boolean
    color_off?: CanvasColour
    color_on?: CanvasColour
    label?: string
    locked?: boolean
    nameLocked?: boolean
    pos?: Point
    widget?: unknown
}

export interface INodeFlags {
    skip_repeated_outputs?: boolean
    allow_interaction?: boolean
    pinned?: boolean
    collapsed?: boolean
}

export interface INodeInputSlot extends INodeSlot {
    link?: LinkId
    not_subgraph_input?: boolean
}

export interface INodeOutputSlot extends INodeSlot {
    links?: LinkId[]
    _data?: unknown
    slot_index?: number
    not_subgraph_output?: boolean
}

/** Links */
export interface ConnectingLink extends IInputOrOutput {
    node: LGraphNode
    slot: number
    pos: Point
    direction?: LinkDirection
}

/** ContextMenu */
export interface IContextMenuOptions {
    ignore_item_callbacks?: boolean
    title?: string
    parentMenu?: ContextMenu
    className?: string
    event?: MouseEvent
    extra?: unknown
    scroll_speed?: number
    left?: number
    top?: number
    scale?: string
    node?: LGraphNode
    autoopen?: boolean
    callback?(value?: unknown, options?: unknown, event?: MouseEvent, previous_menu?: ContextMenu, node?: LGraphNode): void
}

export interface IContextMenuValue {
    title?: string
    value?: string
    content: string
    has_submenu?: boolean
    disabled?: boolean
    className?: any
    submenu?: unknown
    property?: string
    type?: string
    slot?: IFoundSlot
    callback?: IContextMenuOptions["callback"]
}