import * as check from "../../../../generated/sync/check/string-format/date";
import {AssertError} from "../../../../sync/error/AssertError";

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


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


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

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


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

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


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

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


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

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


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

export function assertRangeStringHandler (args : { min? : Date, max? : Date }) : (name : string, mixed : any) => (string)|never {
    return (name : string, mixed : any) : (string)|never => {
        return assertRangeString(name, mixed, args);
    };
}