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

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


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


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

export function assertBeforeHandler (x : Date) : (name : string, mixed : any) => (Date)|never {
    return (name : string, mixed : any) : (Date)|never => {
        return assertBefore(name, mixed, x);
    };
}


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

export function assertAfterHandler (x : Date) : (name : string, mixed : any) => (Date)|never {
    return (name : string, mixed : any) : (Date)|never => {
        return assertAfter(name, mixed, x);
    };
}


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

export function assertBeforeOrAtHandler (x : Date) : (name : string, mixed : any) => (Date)|never {
    return (name : string, mixed : any) : (Date)|never => {
        return assertBeforeOrAt(name, mixed, x);
    };
}


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

export function assertAfterOrAtHandler (x : Date) : (name : string, mixed : any) => (Date)|never {
    return (name : string, mixed : any) : (Date)|never => {
        return assertAfterOrAt(name, mixed, x);
    };
}


export function assertRange (name : string, mixed : any, args : { min? : Date, max? : Date }) : (Date)|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? : Date, max? : Date }) : (name : string, mixed : any) => (Date)|never {
    return (name : string, mixed : any) : (Date)|never => {
        return assertRange(name, mixed, args);
    };
}