import type { VmValue } from '@mirascript/mirascript';
import type { Tagged } from 'type-fest';
import type { LegacyType, TsTypeOf, TypeInfo } from './type.js';
import type { Scope } from './scope.js';
import type { Evaluator } from './main.js';
const { defineProperty } = Object;

/** 表达式的标记属性 */
export const ExpressionTag = 'ɵexp' as const;

// 使用 `type` 确保 Expression 是一个 VmRecord
/** 表示一个表达式 */
export type Expression<T extends VmValue = VmValue> = {
    /** 标记，表示求值结果的类型，"" 表示无需转换类型 */
    readonly [ExpressionTag]: TypeInfo | LegacyType | '';
    /** 表达式内容 */
    readonly source: ExpressionSource<T>;
};

/** 编译后的表达式 */
export type CompiledExpression<T extends VmValue = VmValue> = Expression<T> & ExpressionFunction<T>;
/** 包装一个 {@link ExpressionFunction<T>} */
export function CompiledExpression<S extends TypeInfo | LegacyType, F extends ExpressionFunction<TsTypeOf<S>>>(
    fn: F,
    source: string,
    returnType: S,
): F & Expression<TsTypeOf<S>>;
/** 包装一个 {@link ExpressionFunction<T>} */
export function CompiledExpression<T extends VmValue, F extends ExpressionFunction<T>>(
    fn: F,
    source: string,
    returnType?: TypeInfo | LegacyType | '',
): F & Expression<T>;
/** 包装一个 {@link ExpressionFunction<T>} */
export function CompiledExpression<T extends VmValue, F extends ExpressionFunction<T>>(
    fn: F,
    source: string,
    returnType: TypeInfo | LegacyType | '' = '',
): F & Expression<T> {
    if (typeof fn != 'function') {
        throw new TypeError(`Invalid compiled expression function ${String(fn)}`);
    }
    if (isExpression(fn)) {
        fn = fn.bind(null) as F;
    }
    defineProperty(fn, ExpressionTag, { value: returnType || '' });
    defineProperty(fn, 'source', { value: source });
    return fn as F & Expression<T>;
}

/** 表示一个表达式内容 */
export type ExpressionSource<T extends VmValue = VmValue> = Tagged<string, 'ExpressionResult', T>;

/** 表示表达式或值 */
export type ExpressionOrValue<T extends VmValue = VmValue> = Expression<T> | T;
/** 创建一个指定类型的表达式 */
export function Expression<S extends TypeInfo | LegacyType>(
    source: string | Expression<TsTypeOf<S>>,
    returnType: S,
): Expression<TsTypeOf<S>>;
/** 创建一个不转换结果类型的表达式 */
export function Expression<T extends VmValue = VmValue>(source: string | Expression<T>): Expression<T>;

/** 创建一个表达式 */
export function Expression<T extends VmValue = VmValue>(
    source: string | Expression<T>,
    returnType: TypeInfo | LegacyType | '' = '',
): Expression<T> {
    if (source == null) throw new TypeError(`Invalid expression ${String(source)}`);
    const s = isExpression(source) ? source.source : source;
    if (typeof s != 'string') throw new TypeError(`Invalid expression ${String(s)}`);
    return { [ExpressionTag]: returnType || '', source: s as ExpressionSource<T> };
}

/** 检查是否为表达式 */
export function isExpression<T extends VmValue>(value: unknown): value is Expression<T> | CompiledExpression<T> {
    if (value == null || (typeof value != 'object' && typeof value != 'function')) return false;
    return typeof (value as Expression<T>)[ExpressionTag] == 'string';
}

/** 表示一个表达式求值的结果 */
export type ExpressionResult<T> = T extends Expression<infer R> ? R : T;

/** 表示一个含表达式对象求值的结果 */
export type ExpressionResultObject<T> = {
    [K in keyof T]: ExpressionResult<T[K]>;
};

/**
 * 表示一个具有类似表达式功能的 JS 函数
 */
export type ExpressionFunction<out T> = (
    /** 当前作用域 */
    scope: Scope,
    /** 当前求值器 */
    evaluator: Evaluator,
) => T | null;