import type { IDtoVerify, IDtoMeta, IDtoFuncBase } from "./types"

function defineDtoBase<T, TMeta>(type: string, verify: IDtoVerify) {
    const dtoFunc = (meta: IDtoMeta) => {
        return {
            type,
            meta,
            __isDto__: true,
        }
    }
    const dtoVerify = {
        type,
        verify,
    }

    return {
        dtoFunc: <IDtoFuncBase<T, TMeta>>(<any>dtoFunc),
        dtoVerify,
    }
}

// ======== RegExp ============================================================

export const { dtoFunc: DtoRegExp, dtoVerify: DtoVerifyRegExp } = defineDtoBase<RegExp, {}>(
    "RegExp",
    (val, dto, meta) => {
        if (!(val instanceof RegExp)) return { isOk: false }
        return { isOk: true }
    }
)

// ======== Map ===============================================================

export const { dtoFunc: DtoMap, dtoVerify: DtoVerifyMap } = defineDtoBase<
    Map<any, any>,
    {
        /** 限制 Map 最大长度 */
        maxSize?: number
        /** 限制 Map 最小长度 */
        minSize?: number
    }
>("Map", (val, dto, meta) => {
    if (!(val instanceof Map)) return { isOk: false }
    if (meta?.maxSize !== undefined && val.size > meta.maxSize) {
        return { isOk: false, msg: `Map size out of range: ${val.size}>${meta.maxSize}.` }
    }
    if (meta?.minSize !== undefined && val.size < meta.minSize) {
        return { isOk: false, msg: `Map size out of range: ${val.size}<${meta.minSize}.` }
    }
    return { isOk: true }
})

// ======== Set ===============================================================

export const { dtoFunc: DtoSet, dtoVerify: DtoVerifySet } = defineDtoBase<
    Set<any>,
    {
        /** 限制 Set 最大长度 */
        maxSize?: number
        /** 限制 Set 最小长度 */
        minSize?: number
    }
>("Set", (val, dto, meta) => {
    if (!(val instanceof Set)) return { isOk: false }
    if (meta?.maxSize !== undefined && val.size > meta.maxSize) {
        return { isOk: false, msg: `Set size out of range: ${val.size}>${meta.maxSize}.` }
    }
    if (meta?.minSize !== undefined && val.size < meta.minSize) {
        return { isOk: false, msg: `Set size out of range: ${val.size}<${meta.minSize}.` }
    }
    return { isOk: true }
})

// ======== Blob ==============================================================

export const { dtoFunc: DtoBlob, dtoVerify: DtoVerifyBlob } = defineDtoBase<
    Blob,
    {
        /** 限制 Blob 最大字节数 */
        maxSize?: number
        /** 限制 Blob 最小字节数 */
        minSize?: number
        /** 限制 MIME 类型 */
        type?: string | string[]
    }
>("Blob", (val, dto, meta) => {
    if (!(val instanceof Blob)) return { isOk: false }
    if (meta?.maxSize !== undefined && val.size > meta.maxSize) {
        return { isOk: false, msg: `Blob size out of range: ${val.size}>${meta.maxSize}.` }
    }
    if (meta?.minSize !== undefined && val.size < meta.minSize) {
        return { isOk: false, msg: `Blob size out of range: ${val.size}<${meta.minSize}.` }
    }
    if (meta?.type !== undefined) {
        const types = Array.isArray(meta.type) ? meta.type : [meta.type]
        if (!types.includes(val.type)) {
            return { isOk: false, msg: `Blob type "${val.type}" not in [${types.join(", ")}].` }
        }
    }
    return { isOk: true }
})

// ======== File ==============================================================

export const { dtoFunc: DtoFile, dtoVerify: DtoVerifyFile } = defineDtoBase<
    File,
    {
        /** 限制 File 最大字节数 */
        maxSize?: number
        /** 限制 File 最小字节数 */
        minSize?: number
        /** 限制 MIME 类型 */
        type?: string | string[]
        /** 限制文件扩展名 */
        ext?: string | string[]
    }
>("File", (val, dto, meta) => {
    if (!(val instanceof File)) return { isOk: false }
    if (meta?.maxSize !== undefined && val.size > meta.maxSize) {
        return { isOk: false, msg: `File size out of range: ${val.size}>${meta.maxSize}.` }
    }
    if (meta?.minSize !== undefined && val.size < meta.minSize) {
        return { isOk: false, msg: `File size out of range: ${val.size}<meta.minSize}.` }
    }
    if (meta?.type !== undefined) {
        const types = Array.isArray(meta.type) ? meta.type : [meta.type]
        if (!types.includes(val.type)) {
            return { isOk: false, msg: `File type "${val.type}" not in [${types.join(", ")}].` }
        }
    }
    if (meta?.ext !== undefined) {
        const exts = Array.isArray(meta.ext) ? meta.ext : [meta.ext]
        const fileName = val.name
        const fileExt = fileName.includes(".") ? fileName.split(".").pop()?.toLowerCase() : ""
        if (!exts.map((e) => e.toLowerCase().replace(/^\./, "")).includes(fileExt || "")) {
            return { isOk: false, msg: `File extension "${fileExt}" not in [${exts.join(", ")}].` }
        }
    }
    return { isOk: true }
})

// ======== ArrayBuffer =======================================================

export const { dtoFunc: DtoArrayBuffer, dtoVerify: DtoVerifyArrayBuffer } = defineDtoBase<
    ArrayBuffer,
    {
        /** 限制 ArrayBuffer 最大字节数 */
        maxByteLength?: number
        /** 限制 ArrayBuffer 最小字节数 */
        minByteLength?: number
    }
>("ArrayBuffer", (val, dto, meta) => {
    if (!(val instanceof ArrayBuffer)) return { isOk: false }
    if (meta?.maxByteLength !== undefined && val.byteLength > meta.maxByteLength) {
        return { isOk: false, msg: `ArrayBuffer byteLength out of range: ${val.byteLength}>${meta.maxByteLength}.` }
    }
    if (meta?.minByteLength !== undefined && val.byteLength < meta.minByteLength) {
        return { isOk: false, msg: `ArrayBuffer byteLength out of range: ${val.byteLength}<${meta.minByteLength}.` }
    }
    return { isOk: true }
})

// ======== DataView ==========================================================

export const { dtoFunc: DtoDataView, dtoVerify: DtoVerifyDataView } = defineDtoBase<
    DataView,
    {
        /** 限制 DataView 最大字节数 */
        maxByteLength?: number
        /** 限制 DataView 最小字节数 */
        minByteLength?: number
    }
>("DataView", (val, dto, meta) => {
    if (!(val instanceof DataView)) return { isOk: false }
    if (meta?.maxByteLength !== undefined && val.byteLength > meta.maxByteLength) {
        return { isOk: false, msg: `DataView byteLength out of range: ${val.byteLength}>${meta.maxByteLength}.` }
    }
    if (meta?.minByteLength !== undefined && val.byteLength < meta.minByteLength) {
        return { isOk: false, msg: `DataView byteLength out of range: ${val.byteLength}<${meta.minByteLength}.` }
    }
    return { isOk: true }
})

// ======== TypedArray 基础定义 ================================================

type TypedArrayMeta = {
    /** 限制 TypedArray 最大长度 */
    maxLength?: number
    /** 限制 TypedArray 最小长度 */
    minLength?: number
}

function createTypedArrayVerify(TypedArrayClass: any, typeName: string) {
    return defineDtoBase<InstanceType<typeof TypedArrayClass>, TypedArrayMeta>(typeName, (val, dto, meta) => {
        if (!(val instanceof TypedArrayClass)) return { isOk: false }
        if (meta?.maxLength !== undefined && val.length > meta.maxLength) {
            return { isOk: false, msg: `${typeName} length out of range: ${val.length}>${meta.maxLength}.` }
        }
        if (meta?.minLength !== undefined && val.length < meta.minLength) {
            return { isOk: false, msg: `${typeName} length out of range: ${val.length}<${meta.minLength}.` }
        }
        return { isOk: true }
    })
}

// ======== Int8Array =========================================================

export const { dtoFunc: DtoInt8Array, dtoVerify: DtoVerifyInt8Array } = createTypedArrayVerify(Int8Array, "Int8Array")

// ======== Int16Array ========================================================

export const { dtoFunc: DtoInt16Array, dtoVerify: DtoVerifyInt16Array } = createTypedArrayVerify(
    Int16Array,
    "Int16Array"
)

// ======== Int32Array ========================================================

export const { dtoFunc: DtoInt32Array, dtoVerify: DtoVerifyInt32Array } = createTypedArrayVerify(
    Int32Array,
    "Int32Array"
)

// ======== Uint8Array ========================================================

export const { dtoFunc: DtoUint8Array, dtoVerify: DtoVerifyUint8Array } = createTypedArrayVerify(
    Uint8Array,
    "Uint8Array"
)

// ======== Uint8ClampedArray =================================================

export const { dtoFunc: DtoUint8ClampedArray, dtoVerify: DtoVerifyUint8ClampedArray } = createTypedArrayVerify(
    Uint8ClampedArray,
    "Uint8ClampedArray"
)

// ======== Uint16Array =======================================================

export const { dtoFunc: DtoUint16Array, dtoVerify: DtoVerifyUint16Array } = createTypedArrayVerify(
    Uint16Array,
    "Uint16Array"
)

// ======== Uint32Array =======================================================

export const { dtoFunc: DtoUint32Array, dtoVerify: DtoVerifyUint32Array } = createTypedArrayVerify(
    Uint32Array,
    "Uint32Array"
)

// ======== Float32Array ======================================================

export const { dtoFunc: DtoFloat32Array, dtoVerify: DtoVerifyFloat32Array } = createTypedArrayVerify(
    Float32Array,
    "Float32Array"
)

// ======== Float64Array ======================================================

export const { dtoFunc: DtoFloat64Array, dtoVerify: DtoVerifyFloat64Array } = createTypedArrayVerify(
    Float64Array,
    "Float64Array"
)

// ======== BigInt64Array =====================================================

export const { dtoFunc: DtoBigInt64Array, dtoVerify: DtoVerifyBigInt64Array } = createTypedArrayVerify(
    BigInt64Array,
    "BigInt64Array"
)

// ======== BigUint64Array ====================================================

export const { dtoFunc: DtoBigUint64Array, dtoVerify: DtoVerifyBigUint64Array } = createTypedArrayVerify(
    BigUint64Array,
    "BigUint64Array"
)