// 常見但不完善的空值檢測(cè)
if (!value) { ... }  // 會(huì)把0、false、空字符串都判為空
if (value === null || value === undefined) { ... }  // 不檢查空字符串、空數(shù)組、空對(duì)象
if (Object.keys(value).length === 0) { ... }  // 不檢查Symbol屬性、繼承屬性

import { checkNull, NullCheckPresets } from './nullCheck';

// 基礎(chǔ)使用
checkNull('isNull', '');           // true
checkNull('isNotNull', 'hello');   // true

// 使用預(yù)設(shè)配置
checkNull('isNull', 0, NullCheckPresets.STRICT);   // true (嚴(yán)格模式下0為空)
checkNull('isNull', 0, NullCheckPresets.FORM);     // false (表單中0為有效值)

// 批量檢測(cè)
checkNull('isNullOne', ['', 'hello', null]);      // true (至少一個(gè)為空)
checkNull('isNullAll', ['', null, undefined]);    // true (全部為空)
checkNull('filterNull', ['hello', '', 'world']);  // ['hello', 'world']

import { nullChecker } from './nullCheck';

// 默認(rèn)檢測(cè)器
nullChecker.default('');      // true

// 嚴(yán)格模式 (0, false, NaN都視為空)
nullChecker.strict(0);        // true
nullChecker.strict(false);    // true
nullChecker.strict(NaN);      // true

// 表單模式 (0和false為有效值)
nullChecker.form(0);          // false
nullChecker.form(false);      // false
nullChecker.form('');         // true

// 深度對(duì)象檢測(cè)
const obj = Object.create({ inherited: 'value' });
nullChecker.deep(obj);        // false (檢測(cè)到繼承屬性)

import { cleanObject, NullValidator, assertNotNull } from './nullCheck';

// 數(shù)據(jù)清理
const user = { name: '', age: null, email: 'test@example.com' };
const cleaned = cleanObject(user);  // { email: 'test@example.com' }

// 表單驗(yàn)證
const validator = new NullValidator('username', '')
  .required('用戶名不能為空')
  .validate();  // ['用戶名不能為空']

// 類型守衛(wèi)
function processData(data: string | null) {
  assertNotNull(data, '數(shù)據(jù)不能為空');
  // TypeScript 知道這里 data 不是 null
  console.log(data.toUpperCase());
}

function createEmptyChecker(config: NullCheckConfig) {
  return function isEmpty(value: unknown): boolean {
    // 1. 自定義空值檢查
    if (customEmptyValues.includes(value)) return true;
    
    // 2. 基礎(chǔ)空值
    if (value == null) return true;
    
    // 3. 可配置的特殊值
    if (typeof value === 'number' && treatZeroAsEmpty && value === 0) return true;
    
    // 4. 對(duì)象深度檢測(cè)
    if (typeof value === 'object') {
      // 智能屬性檢測(cè)：支持Symbol、繼承屬性、可配置的檢測(cè)策略
      const keys = checkEnumerableOnly ? Object.keys(value) : Reflect.ownKeys(value);
      return keys.length === 0;
    }
    
    return false;
  };
}

// TypeScript 類型謂詞，提供智能類型推斷
export function isNotNull<T>(
  value: T, 
  config?: NullCheckConfig
): value is NonNullable<T> {
  return !isNull(value, config);
}

// 使用示例
const data: string | null = getUserInput();
if (isNotNull(data)) {
  // 這里 TypeScript 知道 data 是 string 類型
  processString(data);
}

const checkerCache = new WeakMap<object, ReturnType<typeof createEmptyChecker>>();

export function getCachedEmptyChecker(config: NullCheckConfig = {}) {
  const cacheKey = { ...config };
  if (!checkerCache.has(cacheKey)) {
    checkerCache.set(cacheKey, createEmptyChecker(config));
  }
  return checkerCache.get(cacheKey)!;
}

export class BatchNullChecker {
  private isEmpty: (value: unknown) => boolean;
  
  constructor(config: NullCheckConfig = {}) {
    this.isEmpty = getCachedEmptyChecker(config);
  }
  
  filter(values: unknown[]): unknown[] {
    return values.filter(value => !this.isEmpty(value));
  }
  
  // 批量操作，避免重復(fù)創(chuàng)建檢測(cè)器
}

// 表單數(shù)據(jù)驗(yàn)證
const validateForm = (formData: Record<string, any>) => {
  const requiredFields = ['username', 'email', 'password'];
  const errors: string[] = [];
  
  requiredFields.forEach(field => {
    if (isNull(formData[field], NullCheckPresets.FORM)) {
      errors.push(`${field} is required`);
    }
  });
  
  return errors;
};

// 清理API請(qǐng)求參數(shù)
const cleanApiParams = (params: Record<string, any>) => {
  return cleanObject(params, NullCheckPresets.API);
};

// 處理前：{ name: 'John', age: 0, status: '', tags: [] }
// 處理后：{ name: 'John', age: 0 }  (0和空數(shù)組保留)

// React 組件中的數(shù)據(jù)保護(hù)
const UserProfile: React.FC<{ user: User | null }> = ({ user }) => {
  const safeUser = ensureNotNull(user, DEFAULT_USER);
  
  return (
    <div>
      <h1>{safeUser.name}</h1>
      <p>Email: {safeUser.email}</p>
    </div>
  );
};

/**
 * 空值檢測(cè)配置選項(xiàng)
 */
export interface NullCheckConfig {
    // 特殊值處理
    treatZeroAsEmpty?: boolean;           // 是否把 0 視為空
    treatFalseAsEmpty?: boolean;          // 是否把 false 視為空
    treatNaNAsEmpty?: boolean;            // 是否把 NaN 視為空
    treatEmptyStringAsEmpty?: boolean;    // 是否把空字符串視為空

    // 對(duì)象檢測(cè)選項(xiàng)
    checkEnumerableOnly?: boolean;        // 是否只檢查可枚舉屬性
    checkSymbolKeys?: boolean;            // 是否檢查 Symbol 鍵
    checkInheritedProps?: boolean;        // 是否檢查繼承的屬性
    ignoreBuiltinObjects?: boolean;       // 是否忽略內(nèi)置對(duì)象的空判斷

    // 集合類型
    treatEmptyMapAsEmpty?: boolean;       // 是否把空 Map 視為空
    treatEmptySetAsEmpty?: boolean;       // 是否把空 Set 視為空

    // 自定義空值列表
    customEmptyValues?: any[];
}

/**
 * 檢測(cè)目標(biāo)類型
 */
type NullCheckTarget =
    | 'isNull'            // 檢測(cè)單個(gè)值是否為空
    | 'isNotNull'         // 檢測(cè)單個(gè)值是否非空
    | 'isNullOne'         // 檢測(cè)多個(gè)值中是否至少有一個(gè)為空
    | 'isNullAll'         // 檢測(cè)多個(gè)值是否全部為空
    | 'isNotNullAll'      // 檢測(cè)多個(gè)值是否全部非空
    | 'isNullOneByObject' // 檢測(cè)對(duì)象屬性是否存在空值
    | 'isNullAllByObject' // 檢測(cè)對(duì)象所有屬性是否都為空
    | 'filterNull'        // 過濾數(shù)組中的空值
    | 'findNull'          // 查找數(shù)組中的第一個(gè)空值
    | 'findNotNull';      // 查找數(shù)組中的第一個(gè)非空值

/**
 * 內(nèi)置檢測(cè)器類型
 */
interface NullCheckerPresets {
    default: (value: unknown) => boolean;
    strict: (value: unknown) => boolean;
    loose: (value: unknown) => boolean;
    form: (value: unknown) => boolean;
    deep: (value: unknown) => boolean;
}

/**
 * 常用配置預(yù)設(shè)
 */
export const NullCheckPresets = {
    // 默認(rèn)配置
    DEFAULT: {},

    // 嚴(yán)格配置
    STRICT: {
        treatZeroAsEmpty: true,
        treatFalseAsEmpty: true,
        treatNaNAsEmpty: true
    } as NullCheckConfig,

    // 寬松配置
    LOOSE: {
        treatEmptyStringAsEmpty: false,
        treatNaNAsEmpty: false,
        treatEmptyMapAsEmpty: false,
        treatEmptySetAsEmpty: false
    } as NullCheckConfig,

    // 表單配置
    FORM: {
        treatZeroAsEmpty: false,
        treatFalseAsEmpty: false,
        treatEmptyStringAsEmpty: true
    } as NullCheckConfig,

    // 深度配置
    DEEP: {
        checkEnumerableOnly: false,
        checkSymbolKeys: true,
        checkInheritedProps: true,
        ignoreBuiltinObjects: false
    } as NullCheckConfig,

    // 數(shù)據(jù)庫(kù)配置（NULL 和 '' 都視為空）
    DATABASE: {
        treatEmptyStringAsEmpty: true
    } as NullCheckConfig,

    // API配置（接受0和false作為有效值）
    API: {
        treatZeroAsEmpty: false,
        treatFalseAsEmpty: false,
        treatEmptyStringAsEmpty: true
    } as NullCheckConfig
};

/**
 * 統(tǒng)一空值檢測(cè)工具
 * 
 * @param target 檢測(cè)目標(biāo)類型
 * @param objOrValue 待檢測(cè)的值/對(duì)象/數(shù)組
 * @param config 檢測(cè)配置
 * @returns 根據(jù) target 返回相應(yīng)的檢測(cè)結(jié)果
 */
export function checkNull<T>(
    target: 'isNull' | 'isNotNull',
    objOrValue: T,
    config?: NullCheckConfig
): boolean;

export function checkNull<T>(
    target: 'isNullOne' | 'isNullAll' | 'isNotNullAll',
    objOrValue: T[],
    config?: NullCheckConfig
): boolean;

export function checkNull<T>(
    target: 'filterNull' | 'findNull' | 'findNotNull',
    objOrValue: T[],
    config?: NullCheckConfig
): T[] | T | undefined;

export function checkNull<T extends Record<string, unknown>>(
    target: 'isNullOneByObject' | 'isNullAllByObject',
    objOrValue: T,
    config?: NullCheckConfig
): string | boolean | undefined;

export function checkNull(
    target: NullCheckTarget,
    objOrValue: any,
    config: NullCheckConfig = {}
): any {
    // 創(chuàng)建基于配置的核心空值檢測(cè)器
    const isEmpty = createEmptyChecker(config);

    // 根據(jù)目標(biāo)類型選擇不同的檢測(cè)邏輯
    switch (target) {
        case 'isNull':
            return isEmpty(objOrValue);

        case 'isNotNull':
            return !isEmpty(objOrValue);

        case 'isNullOne':
            return Array.isArray(objOrValue)
                ? objOrValue.some(item => isEmpty(item))
                : false;

        case 'isNullAll':
            return Array.isArray(objOrValue)
                ? objOrValue.every(item => isEmpty(item))
                : false;

        case 'isNotNullAll':
            return Array.isArray(objOrValue)
                ? objOrValue.every(item => !isEmpty(item))
                : false;

        case 'isNullOneByObject':
            if (typeof objOrValue === 'object' && objOrValue !== null) {
                for (const key of Object.keys(objOrValue)) {
                    if (isEmpty(objOrValue[key])) {
                        return key; // 返回第一個(gè)空值屬性名
                    }
                }
            }
            return undefined;

        case 'isNullAllByObject':
            if (typeof objOrValue === 'object' && objOrValue !== null) {
                return Object.values(objOrValue).every(value => isEmpty(value));
            }
            return true;

        case 'filterNull':
            return Array.isArray(objOrValue)
                ? objOrValue.filter(item => !isEmpty(item))
                : [];

        case 'findNull':
            return Array.isArray(objOrValue)
                ? objOrValue.find(item => isEmpty(item))
                : undefined;

        case 'findNotNull':
            return Array.isArray(objOrValue)
                ? objOrValue.find(item => !isEmpty(item))
                : undefined;

        default:
            throw new Error(`Unknown target: ${target}`);
    }
}

/**
 * 創(chuàng)建基于配置的核心空值檢測(cè)器
 */
function createEmptyChecker(config: NullCheckConfig = {}): (value: unknown) => boolean {
    const {
        treatZeroAsEmpty = false,
        treatFalseAsEmpty = false,
        treatNaNAsEmpty = true,
        treatEmptyStringAsEmpty = true,
        checkEnumerableOnly = true,
        checkSymbolKeys = false,
        checkInheritedProps = false,
        ignoreBuiltinObjects = true,
        treatEmptyMapAsEmpty = true,
        treatEmptySetAsEmpty = true,
        customEmptyValues = []
    } = config;

    return function isEmpty(value: unknown): boolean {
        // 1. 檢查自定義空值
        if (customEmptyValues.some(emptyValue =>
            Object.is(emptyValue, value) || emptyValue === value
        )) {
            return true;
        }

        // 2. 基礎(chǔ)空值（使用 == null 同時(shí)檢查 null 和 undefined）
        if (value == null) {
            return true;
        }

        // 3. 空字符串
        if (treatEmptyStringAsEmpty && value === '') {
            return true;
        }

        // 4. 數(shù)字處理
        if (typeof value === 'number') {
            if (treatNaNAsEmpty && Number.isNaN(value)) {
                return true;
            }
            if (treatZeroAsEmpty && value === 0) {
                return true;
            }
            return false;
        }

        // 5. 布爾值處理
        if (typeof value === 'boolean') {
            return treatFalseAsEmpty && !value;
        }

        // 6. 數(shù)組處理
        if (Array.isArray(value)) {
            return value.length === 0;
        }

        // 7. Map/Set 處理
        if (treatEmptyMapAsEmpty && value instanceof Map) {
            return value.size === 0;
        }
        if (treatEmptySetAsEmpty && value instanceof Set) {
            return value.size === 0;
        }

        // 8. 對(duì)象處理
        if (typeof value === 'object') {
            // 處理內(nèi)置對(duì)象
            if (ignoreBuiltinObjects) {
                const builtinTypes = [
                    Date,        // 日期對(duì)象
                    RegExp,      // 正則對(duì)象
                    Error,       // 錯(cuò)誤對(duì)象
                    Promise,     // Promise對(duì)象
                    ArrayBuffer, // 二進(jìn)制緩沖區(qū)
                    Function     // 函數(shù)對(duì)象
                ];

                // 檢查是否為內(nèi)置對(duì)象
                if (builtinTypes.some(Ctor => value instanceof Ctor)) {
                    return false; // 內(nèi)置對(duì)象即使"空"也不視為空
                }
            }

            // 檢查對(duì)象是否為空
            let keys: (string | symbol)[] = [];

            if (checkEnumerableOnly) {
                keys = Object.keys(value);
                if (checkSymbolKeys) {
                    keys = keys.concat(Object.getOwnPropertySymbols(value));
                }
            } else {
                keys = Reflect.ownKeys(value);
            }

            // 如果需要檢查繼承的屬性
            if (checkInheritedProps) {
                for (const key in value) {
                    return false; // 只要有任何屬性（包括繼承的），就不是空
                }
                return true;
            }

            return keys.length === 0;
        }

        // 9. 其他類型（Symbol、BigInt、函數(shù)等）視為非空
        return false;
    };
}

/**
 * 創(chuàng)建預(yù)配置的檢測(cè)器實(shí)例
 */
export const nullChecker: NullCheckerPresets = {
    /**
     * 默認(rèn)配置檢測(cè)器（最常用）
     * - null/undefined 為空
     * - 空字符串為空
     * - 空數(shù)組為空
     * - 空對(duì)象（無自身可枚舉屬性）為空
     */
    default: (value: unknown) => checkNull('isNull', value),

    /**
     * 嚴(yán)格模式檢測(cè)器（包含0、false和NaN）
     * - 0 視為空
     * - false 視為空
     * - NaN 視為空
     */
    strict: (value: unknown) => checkNull('isNull', value, {
        treatZeroAsEmpty: true,
        treatFalseAsEmpty: true,
        treatNaNAsEmpty: true
    }),

    /**
     * 寬松模式檢測(cè)器（僅null/undefined）
     * - 空字符串不為空
     * - 空數(shù)組不為空
     * - 空對(duì)象不為空
     * - NaN 不為空
     */
    loose: (value: unknown) => checkNull('isNull', value, {
        treatEmptyStringAsEmpty: false,
        treatNaNAsEmpty: false,
        treatEmptyMapAsEmpty: false,
        treatEmptySetAsEmpty: false
    }),

    /**
     * 表單驗(yàn)證檢測(cè)器
     * - 0 不為空（通常為有效值）
     * - false 不為空（通常為有效值）
     * - 空字符串為空（需要填寫）
     * - 空數(shù)組為空（需要至少一項(xiàng)）
     */
    form: (value: unknown) => checkNull('isNull', value, {
        treatZeroAsEmpty: false,
        treatFalseAsEmpty: false,
        treatEmptyStringAsEmpty: true
    }),

    /**
     * 深度對(duì)象檢測(cè)器
     * - 檢查繼承屬性
     * - 檢查Symbol屬性
     * - 不忽略內(nèi)置對(duì)象
     */
    deep: (value: unknown) => checkNull('isNull', value, {
        checkInheritedProps: true,
        checkSymbolKeys: true,
        ignoreBuiltinObjects: false
    })
};

/**
 * 快捷方法（保持原有API兼容）
 */

// 單個(gè)值檢測(cè)
export const isNull = (value: unknown) => checkNull('isNull', value);
export const isNotNull = <T>(value: T) => checkNull('isNotNull', value) as value is NonNullable<T>;

// 數(shù)組檢測(cè)
export const isNullOne = (...values: unknown[]) => checkNull('isNullOne', values);
export const isNullAll = (...values: unknown[]) => checkNull('isNullAll', values);
export const isNotNullAll = (...values: unknown[]) => checkNull('isNotNullAll', values);

// 對(duì)象檢測(cè)
export const isNullOneByObject = (obj: Record<string, unknown>) =>
    checkNull('isNullOneByObject', obj) as string | undefined;
export const isNullAllByObject = (obj: Record<string, unknown>) =>
    checkNull('isNullAllByObject', obj) as boolean;

// 數(shù)組操作
export const filterNull = <T>(arr: T[]) => checkNull('filterNull', arr) as T[];
export const findNull = <T>(arr: T[]) => checkNull('findNull', arr) as T | undefined;
export const findNotNull = <T>(arr: T[]) => checkNull('findNotNull', arr) as T | undefined;

/**
 * 創(chuàng)建自定義檢測(cè)器
 * @param config 檢測(cè)配置
 * @returns 自定義檢測(cè)函數(shù)
 */
export function createNullChecker(config: NullCheckConfig) {
    const isEmpty = createEmptyChecker(config);

    return {
        isEmpty: (value: unknown) => isEmpty(value),
        isNotEmpty: (value: unknown) => !isEmpty(value),
        filter: <T>(arr: T[]) => arr.filter(item => !isEmpty(item)),
        findEmpty: <T>(arr: T[]) => arr.find(item => isEmpty(item)),
        findNotEmpty: <T>(arr: T[]) => arr.find(item => !isEmpty(item))
    };
}

/**
 * 性能優(yōu)化：緩存配置檢測(cè)器
 */
const checkerCache = new WeakMap<object, ReturnType<typeof createEmptyChecker>>();

export function getCachedEmptyChecker(config: NullCheckConfig = {}) {
    // 使用配置對(duì)象本身作為緩存鍵
    const cacheKey = { ...config };
    if (!checkerCache.has(cacheKey)) {
        checkerCache.set(cacheKey, createEmptyChecker(config));
    }
    return checkerCache.get(cacheKey)!;
}

/**
 * 批量檢測(cè)工具（性能優(yōu)化版）
 */
export class BatchNullChecker {
    private isEmpty: (value: unknown) => boolean;

    constructor(config: NullCheckConfig = {}) {
        this.isEmpty = getCachedEmptyChecker(config);
    }

    checkOne(value: unknown): boolean {
        return this.isEmpty(value);
    }

    checkAll(values: unknown[]): boolean {
        return values.every(value => this.isEmpty(value));
    }

    checkAny(values: unknown[]): boolean {
        return values.some(value => this.isEmpty(value));
    }

    filter(values: unknown[]): unknown[] {
        return values.filter(value => !this.isEmpty(value));
    }

    map<T, R>(values: T[], mapper: (value: T) => R): (R | null)[] {
        return values.map(value =>
            this.isEmpty(value) ? null : mapper(value)
        );
    }

    reduce<T, R>(
        values: T[],
        reducer: (acc: R, value: T) => R,
        initialValue: R
    ): R {
        return values.reduce((acc, value) => {
            return this.isEmpty(value) ? acc : reducer(acc, value);
        }, initialValue);
    }
}

/**
 * 鏈?zhǔn)秸{(diào)用工具
 */
export function nullCheckChain(value: unknown) {
    return {
        value,

        with(config: NullCheckConfig) {
            const isEmpty = createEmptyChecker(config);
            return {
                value: this.value,
                isEmpty: () => isEmpty(this.value),
                isNotEmpty: () => !isEmpty(this.value)
            };
        },

        isEmpty(config?: NullCheckConfig) {
            return checkNull('isNull', this.value, config);
        },

        isNotEmpty(config?: NullCheckConfig) {
            return checkNull('isNotNull', this.value, config);
        },

        ifEmpty<T>(callback: () => T, config?: NullCheckConfig): T | undefined {
            if (checkNull('isNull', this.value, config)) {
                return callback();
            }
            return undefined;
        },

        ifNotEmpty<T>(callback: (value: NonNullable<typeof this.value>) => T, config?: NullCheckConfig): T | undefined {
            if (checkNull('isNotNull', this.value, config)) {
                return callback(this.value as NonNullable<typeof this.value>);
            }
            return undefined;
        }
    };
}

/**
 * 空值轉(zhuǎn)換工具
 */
export function toDefaultIfNull<T>(
    value: T,
    defaultValue: T,
    config?: NullCheckConfig
): T {
    return isNull(value, config) ? defaultValue : value;
}

export function toNullIfEmpty<T>(
    value: T,
    config?: NullCheckConfig
): T | null {
    return isNull(value, config) ? null : value;
}

export function coalesce<T>(...values: T[]): T | undefined {
    return findNotNull(values);
}

/**
 * 對(duì)象清理工具
 */
export function cleanObject<T extends Record<string, any>>(
    obj: T,
    config?: NullCheckConfig
): Partial<T> {
    const result: Partial<T> = {};

    for (const [key, value] of Object.entries(obj)) {
        if (!isNull(value, config)) {
            result[key as keyof T] = value;
        }
    }

    return result;
}

export function cleanObjectDeep<T extends Record<string, any>>(
    obj: T,
    config?: NullCheckConfig
): Partial<T> {
    const result: Partial<T> = {};

    for (const [key, value] of Object.entries(obj)) {
        if (isNull(value, config)) {
            continue;
        }

        // 遞歸處理嵌套對(duì)象
        if (typeof value === 'object' && value !== null && !Array.isArray(value)) {
            const cleaned = cleanObjectDeep(value, config);
            if (!isNull(cleaned, config)) {
                result[key as keyof T] = cleaned as T[keyof T];
            }
        } else {
            result[key as keyof T] = value;
        }
    }

    return result;
}

/**
 * 驗(yàn)證工具
 */
export class NullValidator {
    private errors: string[] = [];

    constructor(
        private fieldName: string,
        private value: unknown,
        private config?: NullCheckConfig
    ) { }

    required(message = `${this.fieldName} is required`): this {
        if (isNull(this.value, this.config)) {
            this.errors.push(message);
        }
        return this;
    }

    optional(): this {
        // 可選的，不做驗(yàn)證
        return this;
    }

    validate(): string[] {
        return this.errors;
    }

    isValid(): boolean {
        return this.errors.length === 0;
    }

    throwIfInvalid(): void {
        if (!this.isValid()) {
            throw new Error(`Validation failed: ${this.errors.join(', ')}`);
        }
    }
}

/**
 * TypeScript 類型守衛(wèi)工具
 */
export function assertNotNull<T>(
    value: T,
    message?: string,
    config?: NullCheckConfig
): asserts value is NonNullable<T> {
    if (isNull(value, config)) {
        throw new Error(message || 'Value is null or empty');
    }
}

export function ensureNotNull<T>(
    value: T,
    defaultValue: NonNullable<T>,
    config?: NullCheckConfig
): NonNullable<T> {
    return isNull(value, config) ? defaultValue : (value as NonNullable<T>);
}

// 為快捷方法添加配置參數(shù)支持
export function isNull(value: unknown, config?: NullCheckConfig): boolean {
    return checkNull('isNull', value, config);
}

export function isNotNull<T>(value: T, config?: NullCheckConfig): value is NonNullable<T> {
    return checkNull('isNotNull', value, config) as value is NonNullable<T>;
}