import { isEmpty, isObject } from '../utils/validator'
import { superEach, superEachAsync } from '../utils'
import { TypeSource, IBananaItem } from './type'

export async function validateAsyncCore (source: TypeSource) {
    await superEachAsync<IBananaItem>(source, async (item) => {
        let { value, children, rules, hidden } = item
        if (children) {
            await validateAsyncCore(children)
        }
        if (typeof hidden === 'function') {
            hidden = hidden(value, item, source)
        }
        if (hidden || !rules || !rules.length) return
        for (let i = 0, len = rules.length; i < len; i++) {
            const { required, validator, message } = rules[i]
            if (required && isEmpty(value)) {
                throw message
            }
            if (typeof validator === 'function' && await validator(value) === false) {
                throw message
            }
            if (validator instanceof RegExp && !validator.test(value)) {
                throw message
            }
        }
    })
}

export function validateCore (source: TypeSource) {
    superEach<IBananaItem>(source, (item) => {
        let { value, children, rules, hidden } = item
        if (children) {
            validateCore(children)
        }
        if (typeof hidden === "function") {
            hidden = hidden(value, item, source);
        }
        if (hidden || !rules || !rules.length) return
        for (let i = 0, len = rules.length; i < len; i++) {
            const { required, validator, message } = rules[i]
            if (required && isEmpty(value)) {
                throw message
            }
            if (typeof validator === 'function' && validator(value) === false) {
                throw message
            }
            if (validator instanceof RegExp && !validator.test(value)) {
                throw message
            }
        }
    })
}

export async function extractAsyncCore (source: TypeSource) {
    const result = {}
    await superEachAsync<IBananaItem>(source, async (item, i) => {
        let { get, value, key, hidden, children } = item
        if (children) {
            Object.assign(result, await extractAsyncCore(children))
        }
        if (typeof hidden === "function") {
            hidden = hidden(value, item, source);
        }
        if (value === undefined || hidden) return
        const k = key ?? i
        if (typeof get === 'function') {
            const data = await get(value, item, source)
            if (isObject(data)) {
                Object.assign(result, data)
            } else {
                result[k] = data
            }
        } else {
            result[k] = value
        }
    })
    return result
}

export function extractCore (source: TypeSource) {
    const result = {}
    superEach<IBananaItem>(source, (item, i) => {
        let { get, value, key, hidden, children } = item
        if (children) {
            Object.assign(result, extractCore(children))
        }
        if (typeof hidden === "function") {
            hidden = hidden(value, item, source);
        }
        if (value === undefined || hidden) return
        const k = key ?? i
        if (typeof get === 'function') {
            const data = get(value, item, source)
            if (isObject(data)) {
                Object.assign(result, data)
            } else {
                result[k] = data
            }
        } else {
            result[k] = value
        }
    })
    return result
}

export async function assignmentAsyncCore (data: {}, source: TypeSource) {
    await superEachAsync<IBananaItem>(source, async (item, i) => {
        const { set, value, key, children } = item
        if (children) {
            await assignmentAsyncCore(data, children)
        }
        if (value === undefined) return
        const k = key ?? i
        const v = data[k]
        if (typeof set === 'function') {
            await set(data, item)
        } else if (![undefined, null].includes(v)) {
            item.value = v
        }
    })
}

export function assignmentCore (data: {}, source: TypeSource) {
    superEach<IBananaItem>(source, (item, i) => {
        const { set, value, key, children } = item
        if (children) {
            assignmentCore(data, children)
        }
        if (value === undefined) return
        const k = key ?? i
        const v = data[k]
        if (typeof set === 'function') {
            set(data, item)
        } else if (![undefined, null].includes(v)) {
        // } else if (![undefined].includes(v)) {
            item.value = v
        }
    })
}