import * as check from "../../../sync/check/number";
import {AssertError} from "../../../sync/error/AssertError";

export function assertPotentiallyUnsafeNumber (name : string, mixed : any) : (number)|never {
    const error = check.checkPotentiallyUnsafeNumber(mixed);
    if (error === undefined) {
        return mixed;
    } else {
        throw new AssertError(name, error, mixed);
    }
}


export function assertFiniteNumber (name : string, mixed : any) : (number)|never {
    const error = check.checkFiniteNumber(mixed);
    if (error === undefined) {
        return mixed;
    } else {
        throw new AssertError(name, error, mixed);
    }
}


export function assertInteger (name : string, mixed : any) : (number)|never {
    const error = check.checkInteger(mixed);
    if (error === undefined) {
        return mixed;
    } else {
        throw new AssertError(name, error, mixed);
    }
}


export function assertGreaterThan (name : string, mixed : any, x : number) : (number)|never {
    const error = check.checkGreaterThan(mixed, x);
    if (error === undefined) {
        return mixed;
    } else {
        throw new AssertError(name, error, mixed, x);
    }
}

export function assertGreaterThanHandler (x : number) : (name : string, mixed : any) => (number)|never {
    return (name : string, mixed : any) : (number)|never => {
        return assertGreaterThan(name, mixed, x);
    };
}


export function assertGreaterThanOrEqual (name : string, mixed : any, x : number) : (number)|never {
    const error = check.checkGreaterThanOrEqual(mixed, x);
    if (error === undefined) {
        return mixed;
    } else {
        throw new AssertError(name, error, mixed, x);
    }
}

export function assertGreaterThanOrEqualHandler (x : number) : (name : string, mixed : any) => (number)|never {
    return (name : string, mixed : any) : (number)|never => {
        return assertGreaterThanOrEqual(name, mixed, x);
    };
}


export function assertLessThan (name : string, mixed : any, x : number) : (number)|never {
    const error = check.checkLessThan(mixed, x);
    if (error === undefined) {
        return mixed;
    } else {
        throw new AssertError(name, error, mixed, x);
    }
}

export function assertLessThanHandler (x : number) : (name : string, mixed : any) => (number)|never {
    return (name : string, mixed : any) : (number)|never => {
        return assertLessThan(name, mixed, x);
    };
}


export function assertLessThanOrEqual (name : string, mixed : any, x : number) : (number)|never {
    const error = check.checkLessThanOrEqual(mixed, x);
    if (error === undefined) {
        return mixed;
    } else {
        throw new AssertError(name, error, mixed, x);
    }
}

export function assertLessThanOrEqualHandler (x : number) : (name : string, mixed : any) => (number)|never {
    return (name : string, mixed : any) : (number)|never => {
        return assertLessThanOrEqual(name, mixed, x);
    };
}


export function assertRange (name : string, mixed : any, args : { min? : number, max? : number }) : (number)|never {
    const error = check.checkRange(mixed, args);
    if (error === undefined) {
        return mixed;
    } else {
        throw new AssertError(name, error, mixed, args);
    }
}

export function assertRangeHandler (args : { min? : number, max? : number }) : (name : string, mixed : any) => (number)|never {
    return (name : string, mixed : any) : (number)|never => {
        return assertRange(name, mixed, args);
    };
}


export function assertPositive (name : string, mixed : any) : (number)|never {
    const error = check.checkPositive(mixed);
    if (error === undefined) {
        return mixed;
    } else {
        throw new AssertError(name, error, mixed);
    }
}


export function assertNegative (name : string, mixed : any) : (number)|never {
    const error = check.checkNegative(mixed);
    if (error === undefined) {
        return mixed;
    } else {
        throw new AssertError(name, error, mixed);
    }
}


export function assertNonNegative (name : string, mixed : any) : (number)|never {
    const error = check.checkNonNegative(mixed);
    if (error === undefined) {
        return mixed;
    } else {
        throw new AssertError(name, error, mixed);
    }
}


export function assertNaturalNumber (name : string, mixed : any) : (number)|never {
    const error = check.checkNaturalNumber(mixed);
    if (error === undefined) {
        return mixed;
    } else {
        throw new AssertError(name, error, mixed);
    }
}


export function assertOdd (name : string, mixed : any) : (number)|never {
    const error = check.checkOdd(mixed);
    if (error === undefined) {
        return mixed;
    } else {
        throw new AssertError(name, error, mixed);
    }
}


export function assertEven (name : string, mixed : any) : (number)|never {
    const error = check.checkEven(mixed);
    if (error === undefined) {
        return mixed;
    } else {
        throw new AssertError(name, error, mixed);
    }
}


export function assertNotOneOf<T extends number> (name : string, mixed : any, arr : T[]) : (number)|never {
    const error = check.checkNotOneOf(mixed, arr);
    if (error === undefined) {
        return mixed;
    } else {
        throw new AssertError(name, error, mixed, arr);
    }
}

export function assertNotOneOfHandler<T extends number> (arr : T[]) : (name : string, mixed : any) => (number)|never {
    return (name : string, mixed : any) : (number)|never => {
        return assertNotOneOf(name, mixed, arr);
    };
}


export function assertLatitude (name : string, mixed : any) : (number)|never {
    const error = check.checkLatitude(mixed);
    if (error === undefined) {
        return mixed;
    } else {
        throw new AssertError(name, error, mixed);
    }
}


export function assertLongitude (name : string, mixed : any) : (number)|never {
    const error = check.checkLongitude(mixed);
    if (error === undefined) {
        return mixed;
    } else {
        throw new AssertError(name, error, mixed);
    }
}