import { CSSProperties, Component, DefineComponent, PropType, Slots, VNode, VNodeChild } from 'vue'

import { MaybePromise, PartialKeys, useHistoryStack } from '@ithinkdt/common'
import { DictItem } from '@ithinkdt/common/dict'
import { HttpMethod } from '@ithinkdt/common/request'
import { PageResponse } from '@ithinkdt/page'

import { type EntityField, EntityFieldType } from './entity.js'

export interface BaseState {
    type: unknown
    name: string
    description?: string
}

export interface VarState extends BaseState {
    type: 'var'
    varType?: 'string' | 'number' | 'boolean' | 'custom'
    defaultValue?: string | number | boolean
    content?: string
    resetable?: boolean
}

export interface FetchState extends BaseState {
    type: 'fetch'
    method: HttpMethod
    api: string
    params?: string
}

export interface EntityState extends BaseState {
    type: 'entity'
    modelName?: string
    queryConfig?: Record<string, string | false>
    _modelName?: string
    autoFetch?: boolean
    listType?: 'page' | 'list'
    presets?: ('get' | 'post' | 'put' | 'delete')[]
    initValue?: {
        fields?: EntityField[]
        list?: Record<string, unknown>[]
        modelName?: string
        loading?: boolean
        total?: number
        currentPage?: number
        pageSize?: number
        search?: Record<string, unknown>
        sort?: { order?: 'asc' | 'desc', name?: string }
    }
}

export interface StateDefinitions {
    var: VarState
    fetch: FetchState
    entity: EntityState
}

export interface BaseMethod {
    type: unknown
    name: string
    description?: string
    hidden?: boolean
    deletable?: boolean
}

export interface ScriptMethod extends BaseMethod {
    type: 'script'
    script: string
}

export interface MethodDefinitions {
    script: ScriptMethod
}

export interface LcNode<Extra extends {} = {}> {
    id: string
    type: string
    label: string
    props: Record<string, unknown>
    css: string
    css2: string
    listeners: [string, string, string[]?][]
    children: Record<string, LcNode[]>
    hidable?: boolean
    deletable?: boolean
    cloneable?: boolean
    container?: boolean
    form?: boolean

    __extra?: Extra
}

export interface LcSchema {
    state: StateDefinitions[keyof StateDefinitions][]
    methods: MethodDefinitions[keyof MethodDefinitions][]
    name: string
    tree: LcNode
    css: string
    css2: string
}

type StateType<T extends keyof StateDefinitions, IsRenderer extends boolean = false> = T extends infer T1 extends
keyof StateDefinitions
    ? LcStateDefinition<StateDefinitions[T1], IsRenderer>
    : never

type MethodType<T extends keyof MethodDefinitions, IsRenderer extends boolean = false> = T extends infer T1 extends
keyof MethodDefinitions
    ? LcMethodDefinition<MethodDefinitions[T1], IsRenderer>
    : never

export interface ProviderDoc {
    name: string
    snippet: string
    description: string | (() => VNodeChild)
    type: 'const' | 'util'
    tip?: string | (() => VNodeChild)
}

export declare class LowcodeEngineCore {
    providers: Record<string, unknown>
    stateDefinitions: StateType<keyof StateDefinitions>[]
    state: Record<string, unknown>
    methods: Record<string, () => void>

    setSchema(schema: Partial<LcSchema>, after?: () => void): Promise<LcSchema>

    defineState<T extends keyof StateDefinitions>(
        name: string,
        type: T,
        config: PartialKeys<StateDefinitions[T], 'name' | 'type' | 'description'>,
    ): Promise<StateDefinitions[T]>

    defineMethod<T extends keyof MethodDefinitions>(
        name: string,
        type: T,
        config: PartialKeys<MethodDefinitions[T], 'name' | 'type' | 'description'>,
    ): Promise<() => void>

    getFnFromScriptDefault(script: string): Promise<() => void>
}

export interface LcMaterialPropItem {
    label: string
    prop: string
    type: string
    defaultValue?: unknown
}

export interface LcWorkbenchOptions<MaterialNameMap extends {}> {
    silence?: boolean
    getDictTypes: () => Promise<DictItem[]>
    getApis: () => Promise<unknown[]>
    getApi: (code: string) => Promise<unknown>
    icons: {
        renderer: (props: { modelValue: string | null, onUpdateModelValue: (modelValue: string | null) => void }) => VNode
    }
    file: {
        removeFile: (fileId: string) => Promise<unknown>
        getFileInfos: (fileIds: string[]) => Promise<{
            id: string
            name: string
            size: number
            url: string
            type: string
        }[]>
        previewFileUrl: (fileId: string) => string
        downloadFileUrl: (fileId: string) => string
        uploadFile: (file: File, options?: {
            onProgress?: ((percent: number) => void) | undefined
        }) => Promise<string>
    }
    materials: Record<string, { label: string, materials: (LcMaterial | LcMaterial[])[] }>
    mapPropItems?: (
        items: LcMaterialPropItem[],
        ops: { type: string, props: Record<string, unknown>, engine: LowcodeEngineWorkbench<MaterialNameMap> },
    ) => LcMaterialPropItem[]
    mapProItems?: (
        items: LcMaterialPropItem[],
        ops: { type: string, props: Record<string, unknown>, engine: LowcodeEngineWorkbench<MaterialNameMap> },
    ) => LcMaterialPropItem[]

    templates?: Record<string, { label: string, templates: LcTemplate<MaterialNameMap>[] }>
    stateDefinitions?: StateType<keyof StateDefinitions>[]
    methodDefinitions?: MethodType<keyof MethodDefinitions>[]
    providers?: Record<string, unknown>
    providerDocs?: ProviderDoc[]
}

type InsertParams<Extra extends {} = {}> = Extra & {
    index?: number
    slot?: string
    replace?: boolean
}

export declare class LowcodeEngineWorkbench<
    MaterialNameMap extends {} = Record<string, LcMaterial>,
> extends LowcodeEngineCore {
    revocable: boolean
    redoable: boolean
    set schema(schema: Partial<LcSchema>)
    get schema(): LcSchema

    materials: Record<string, { label: string, materials: LcMaterial[] }>
    templates: Record<string, { label: string, templates: LcTemplate[] }>

    readonly materialMap: Map<keyof MaterialNameMap, LcMaterial>

    Workbench: DefineComponent<
        {
            terminal: PropType<'WEB' | 'MOBILE'>
        },
        {},
        {
            onRefresh?: () => void
            onSubmit?: (schema: LcSchema) => void
        }
    >

    current: LcNode
    hovered?: LcNode

    constructor(_: LcWorkbenchOptions<MaterialNameMap>)

    addState<T extends keyof StateDefinitions>(
        name: string,
        type: T,
        description: string,
        config: PartialKeys<StateDefinitions[T], 'name' | 'type' | 'description'>,
    ): Promise<StateDefinitions[T]>

    removeState(name: string): void
    addMethod<T extends keyof MethodDefinitions>(
        name: string,
        type: T,
        description: string,
        config: PartialKeys<MethodDefinitions[T], 'name' | 'type' | 'description'>,
    ): Promise<() => void>
    removeMethod(name: string): void

    undo: (pointer?: number) => void
    redo: (pointer?: number) => void
    historyStack: ReturnType<typeof useHistoryStack>

    toJSON(): Required<LcSchema>
    createNode<T extends keyof MaterialNameMap>(
        type: T,
        defaults?: Partial<Omit<LcNode, 'css' | 'css2'> & { css: CSSProperties, css2: CSSProperties }>,
        reuse?: boolean,
    ): LcNode<NonNullable<MaterialNameMap[T] extends LcMaterial ? MaterialNameMap[T]['__extra'] : never>>

    insertNode<Node extends LcNode, ParentNode extends LcNode>(
        node: Node,
        parent?: ParentNode,
        ops?: number | InsertParams<NonNullable<ParentNode['__extra']>>,
    ): Node
}

export interface LcMaterial<Name extends string = string, Extra extends {} = {}> {
    name: string
    key: Name
    icon: Component
    component?: DefineComponent | (() => Promise<DefineComponent>)
    render?: <MaterialNameMap extends {} = Record<string, LcMaterial>>(
        props: Record<string, unknown>,
        options: { slots: Slots },
        engine: LowcodeEngineWorkbench<MaterialNameMap>,
    ) => VNodeChild
    onChildAdd?: (
        child: LcNode,
        options: { node: LcNode, engine: LowcodeEngineWorkbench } & InsertParams<Extra>,
    ) => LcNode | undefined | void
    wrap?: boolean | 'before' | 'after'
    form?: boolean
    inline?: boolean
    custom?: {
        size?: boolean
        text?: boolean
        box?: boolean
        border?: boolean
        background?: boolean
        boxShadow?: boolean
        position?: boolean
    }
    modelValue?: string
    events?: (string | [string, string | ((params: { props: Record<string, unknown> }) => string)])[]
    props?: Record<string, unknown> | (() => Record<string, unknown>)
    css?: (cls: string) => CSSProperties
    css2?: (cls: string) => CSSProperties
    items: (node: LcNode) => LcMaterialPropItem[]

    __extra?: Extra
}

export interface LcComponent {
    key: string
    component?: Component | (() => Promise<Component>)
    render?: (props: Record<string, unknown>, options: { slots: Slots }, engine: LowcodeEngineCore) => VNodeChild
}

export interface LcTemplate<MaterialNameMap extends {} = Record<string, LcMaterial>> {
    name: string
    key: string
    icon: Component
    generate(engine: LowcodeEngineWorkbench<MaterialNameMap>): Promise<LcNode[]>
}

interface _LcStateDefinition<Config extends StateDefinitions[keyof StateDefinitions]> {
    label: string
    key: string
    color?: string
    install: <MaterialNameMap extends {} = Record<string, LcMaterial>>(
        name: string,
        config: Config,
        engine: LowcodeEngineWorkbench<MaterialNameMap>,
    ) => MaybePromise<void>

    uninstall: <MaterialNameMap extends {} = Record<string, LcMaterial>>(
        name: string,
        config: Config,
        engine: LowcodeEngineWorkbench<MaterialNameMap>,
    ) => void

    apply: (name: string, config: Config, engine: LowcodeEngineCore) => MaybePromise<void>
    getTip: (
        name: string,
        config: Config,
        engine: LowcodeEngineCore,
    ) => MaybePromise<string | { tip: string, type?: 'json' | 'ts' }>
    getDefault: () => Partial<Config>

    config: (config: Config, engine: LowcodeEngineWorkbench) => VNodeChild
}

export type LcStateDefinition<
    Config extends StateDefinitions[keyof StateDefinitions],
    IsRenderer extends boolean = false,
> = IsRenderer extends true ? Pick<_LcStateDefinition<Config>, 'key' | 'apply'> : _LcStateDefinition<Config>

interface _LcMethodDefinition<Config extends MethodDefinitions[keyof MethodDefinitions]> {
    label: string
    key: string
    color?: string
    install: <MaterialNameMap extends {} = Record<string, LcMaterial>>(
        name: string,
        config: Config,
        engine: LowcodeEngineWorkbench<MaterialNameMap>,
    ) => MaybePromise<void>

    uninstall: <MaterialNameMap extends {} = Record<string, LcMaterial>>(
        name: string,
        config: Config,
        engine: LowcodeEngineWorkbench<MaterialNameMap>,
    ) => void

    apply: (name: string, config: Config, engine: LowcodeEngineCore) => MaybePromise<void>
    getTip: (name: string, config: Config, engine: LowcodeEngineCore) => MaybePromise<string>
    getDefault: () => Partial<Config>

    config: (config: Config, engine: LowcodeEngineWorkbench) => VNodeChild
}

export type LcMethodDefinition<
    Config extends MethodDefinitions[keyof MethodDefinitions],
    IsRenderer extends boolean = false,
> = IsRenderer extends true ? Pick<_LcMethodDefinition<Config>, 'key' | 'apply'> : _LcMethodDefinition<Config>

export interface EntityApi {
    <R = unknown>(
        this: void,
        method: HttpMethod,
        model: string,
        params?: Record<string, unknown>,
    ): Promise<{
        status: boolean
        code: number
        message: string
        data: R
        headers: Headers
    }>
    fetchOne<R extends Record<string, unknown> = Record<string, unknown>>(
        this: void,
        config: Required<Pick<EntityState, 'modelName' | '_modelName'>>,
        id: string,
    ): Promise<R>
    deleteOne(this: void, config: Required<Pick<EntityState, 'modelName' | '_modelName'>>, id: string): Promise<void>
    deleteBatch(
        this: void,
        config: Required<Pick<EntityState, 'modelName' | '_modelName'>>,
        ids: string[],
    ): Promise<void>
    postOne(
        this: void,
        config: Required<Pick<EntityState, 'modelName' | '_modelName'>>,
        one: Record<string, unknown>,
    ): Promise<void>
    putOne(
        this: void,
        config: Required<Pick<EntityState, 'modelName' | '_modelName'>>,
        one: Record<string, unknown>,
    ): Promise<void>

    fetchList<R extends Record<string, unknown> = Record<string, unknown>>(
        this: void,
        config: Required<Pick<EntityState, 'modelName' | '_modelName' | 'queryConfig'>>,
        params: Record<string, unknown>,
    ): Promise<R[]>

    fetchPage<R extends Record<string, unknown> = Record<string, unknown>>(
        this: void,
        config: Required<Pick<EntityState, 'modelName' | '_modelName' | 'queryConfig'>>,
        params: {
            query: Record<string, unknown>
            pagin: { currentPage: number, pageSize: number }
            sort: { name: string, order: 'asc' | 'desc' }
        },
    ): Promise<PageResponse<R>>
}

export declare function getFieldFormMap<MaterialNameMap extends {} = Record<string, LcMaterial>>(): Partial<
    Record<
        EntityFieldType,
        [
            type: keyof MaterialNameMap | ((field: EntityField, custom: Record<string, unknown>) => keyof MaterialNameMap),
            model: (
                field: EntityField,
                custom: Record<string, unknown>,
            ) => [
                Record<string, unknown>,
                    Partial<Omit<LcNode, 'css' | 'css2'> & { css: CSSProperties, css2: CSSProperties }>?,
            ],
            formItemModel: (
                field: EntityField,
            ) => [
                Record<string, unknown>,
                    Partial<Omit<LcNode, 'css' | 'css2'> & { css: CSSProperties, css2: CSSProperties }>?,
            ],
        ]
    >
>
export declare function getFieldQueryFormMap<MaterialNameMap extends {} = Record<string, LcMaterial>>(): Partial<
    Record<
        EntityFieldType,
        [
            keyof MaterialNameMap | ((field: EntityField, custom: Record<string, unknown>) => keyof MaterialNameMap),
            (
                field: EntityField,
                custom: Record<string, unknown>,
            ) => [
                Record<string, unknown>,
                Partial<Omit<LcNode, 'css' | 'css2'> & { css: CSSProperties, css2: CSSProperties }>?,
            ],
            string?,
        ]
    >
>