import {ValidationResult, ValidatorFunction} from "./types";

export namespace Num {
    /**
     * Builds a validator function that requires the input value to be greater than some value.
     * @param value
     */
    export function greaterThan(value: number): ValidatorFunction {
        return function greaterThan(fieldName: string, inputValue: any): ValidationResult {
            if ( inputValue > value ) {
                return { valid: true }
            }

            return {
                valid: false,
                message: `must be greater than ${value}`
            }
        }
    }

    /**
     * Builds a validator function that requires the input value to be at least some value.
     * @param value
     */
    export function atLeast(value: number): ValidatorFunction {
        return function atLeast(fieldName: string, inputValue: any): ValidationResult {
            if ( inputValue >= value ) {
                return { valid: true }
            }

            return {
                valid: false,
                message: `must be at least ${value}`
            }
        }
    }

    /**
     * Builds a validator function that requires the input value to be less than some value.
     * @param value
     */
    export function lessThan(value: number): ValidatorFunction {
        return function lessThan(fieldName: string, inputValue: any): ValidationResult {
            if ( inputValue < value ) {
                return { valid: true }
            }

            return {
                valid: false,
                message: `must be less than ${value}`
            }
        }
    }

    /**
     * Builds a validator function that requires the input value to be at most some value.
     * @param value
     */
    export function atMost(value: number): ValidatorFunction {
        return function atMost(fieldName: string, inputValue: any): ValidationResult {
            if ( inputValue <= value ) {
                return { valid: true }
            }

            return {
                valid: false,
                message: `must be at most ${value}`
            }
        }
    }

    /**
     * Builds a validator function that requires the input value to have exactly `num` many digits.
     * @param num
     */
    export function digits(num: number): ValidatorFunction {
        return function digits(fieldName: string, inputValue: any): ValidationResult {
            if ( String(inputValue).replace('.', '').length === num ) {
                return { valid: true }
            }

            return {
                valid: false,
                message: `must have exactly ${num} digits`
            }
        }
    }

    /**
     * Builds a validator function that requires the input value to have at least `num` many digits.
     * @param num
     */
    export function digitsMin(num: number): ValidatorFunction {
        return function digitsMin(fieldName: string, inputValue: any): ValidationResult {
            if ( String(inputValue).replace('.', '').length >= num ) {
                return { valid: true }
            }

            return {
                valid: false,
                message: `must have at least ${num} digits`
            }
        }
    }

    /**
     * Builds a validator function that requires the input value to have at most `num` many digits.
     * @param num
     */
    export function digitsMax(num: number): ValidatorFunction {
        return function digitsMax(fieldName: string, inputValue: any): ValidationResult {
            if ( String(inputValue).replace('.', '').length <= num ) {
                return { valid: true }
            }

            return {
                valid: false,
                message: `must have at most ${num} digits`
            }
        }
    }

    /**
     * Builds a validator function that requires the input value to end with the given number sequence.
     * @param num
     */
    export function ends(num: number): ValidatorFunction {
        return function ends(fieldName: string, inputValue: any): ValidationResult {
            if ( String(inputValue).endsWith(String(num)) ) {
                return { valid: true }
            }

            return {
                valid: false,
                message: `must end with "${num}"`
            }
        }
    }

    /**
     * Builds a validator function that requires the input value to begin with the given number sequence.
     * @param num
     */
    export function begins(num: number): ValidatorFunction {
        return function begins(fieldName: string, inputValue: any): ValidationResult {
            if ( String(inputValue).startsWith(String(num)) ) {
                return { valid: true }
            }

            return {
                valid: false,
                message: `must begin with "${num}"`
            }
        }
    }

    /**
     * Builds a validator function that requires the input value to be a multiple of the given number.
     * @param num
     */
    export function multipleOf(num: number): ValidatorFunction {
        return function multipleOf(fieldName: string, inputValue: any): ValidationResult {
            if ( inputValue % num === 0 ) {
                return { valid: true }
            }

            return {
                valid: false,
                message: `must be a multiple of ${num}`
            }
        }
    }

    /** Requires the input value to be even. */
    export function even(fieldName: string, inputValue: any): ValidationResult {
        if ( inputValue % 2 === 0 ) {
            return { valid: true }
        }

        return {
            valid: false,
            message: 'must be even',
        }
    }

    /** Requires the input value to be odd. */
    export function odd(fieldName: string, inputValue: any): ValidationResult {
        if ( inputValue % 2 === 0 ) {
            return { valid: true }
        }

        return {
            valid: false,
            message: 'must be odd',
        }
    }
}