import * as MixedCheck from "./generic/mixed";

export enum PotentiallyUnsafeNumberErrorCode {
    NOT_NUMBER = "NOT_NUMBER",
}

export function checkPotentiallyUnsafeNumber (mixed : any) : undefined|PotentiallyUnsafeNumberErrorCode {
    if (typeof mixed === "number") {
        return undefined;
    } else {
        return PotentiallyUnsafeNumberErrorCode.NOT_NUMBER;
    }
}

export function checkPotentiallyUnsafeNumberPredicate<ErrorCodeT extends string> (mixed : any, predicate : (num : number) => undefined|ErrorCodeT) : undefined|PotentiallyUnsafeNumberErrorCode|ErrorCodeT {
    const error = checkPotentiallyUnsafeNumber(mixed);
    if (error !== undefined) {
        return error;
    }

    return predicate(mixed);
}

export enum FiniteNumberErrorCode {
    IS_NAN     = "IS_NAN",
    NOT_FINITE = "NOT_FINITE"
}

export function checkFiniteNumber (mixed : any) : undefined|PotentiallyUnsafeNumberErrorCode|FiniteNumberErrorCode {
    return checkPotentiallyUnsafeNumberPredicate(mixed, (num) => {
        if (isNaN(num)) {
            return FiniteNumberErrorCode.IS_NAN;
        }
        if (!isFinite(num)) {
            return FiniteNumberErrorCode.NOT_FINITE;
        }
        return undefined;
    });
}

export function checkFiniteNumberPredicate<ErrorCodeT extends string> (mixed : any, predicate : (num : number) => undefined|ErrorCodeT) : undefined|PotentiallyUnsafeNumberErrorCode|FiniteNumberErrorCode|ErrorCodeT {
    const error = checkFiniteNumber(mixed);
    if (error !== undefined) {
        return error;
    }

    return predicate(mixed);
}

export enum IntegerErrorCode {
    NOT_INTEGER = "NOT_INTEGER"
}

export type IntegerErrorCodeType = PotentiallyUnsafeNumberErrorCode|FiniteNumberErrorCode|IntegerErrorCode;

export function checkInteger (mixed : any) : undefined|IntegerErrorCodeType {
    return checkFiniteNumberPredicate(mixed, (num) => {
        if (Math.floor(num) !== num) {
            return IntegerErrorCode.NOT_INTEGER;
        }
        return undefined;
    });
}

export function checkIntegerPredicate<ErrorCodeT> (mixed : any, predicate : (num : number) => undefined|ErrorCodeT) : undefined|IntegerErrorCodeType|ErrorCodeT {
    const error = checkInteger(mixed);
    if (error !== undefined) {
        return error;
    }

    return predicate(mixed);
}

export enum GreaterThanErrorCode {
    LESS_THAN_OR_EQUAL = "LESS_THAN_OR_EQUAL"
}

export function checkGreaterThan (mixed : any, x : number) : undefined|PotentiallyUnsafeNumberErrorCode|FiniteNumberErrorCode|GreaterThanErrorCode {
    return checkFiniteNumberPredicate(mixed, (num) => {
        if (num > x) {
            return undefined;
        } else {
            return GreaterThanErrorCode.LESS_THAN_OR_EQUAL;
        }
    });
}

export enum GreaterThanOrEqualErrorCode {
    LESS_THAN = "LESS_THAN"
}

export function checkGreaterThanOrEqual (mixed : any, x : number) : undefined|PotentiallyUnsafeNumberErrorCode|FiniteNumberErrorCode|GreaterThanOrEqualErrorCode {
    return checkFiniteNumberPredicate(mixed, (num) => {
        if (num >= x) {
            return undefined;
        } else {
            return GreaterThanOrEqualErrorCode.LESS_THAN;
        }
    });
}

export enum LessThanErrorCode {
    GREATER_THAN_OR_EQUAL = "GREATER_THAN_OR_EQUAL"
}

export function checkLessThan (mixed : any, x : number) : undefined|PotentiallyUnsafeNumberErrorCode|FiniteNumberErrorCode|LessThanErrorCode {
    return checkFiniteNumberPredicate(mixed, (num) => {
        if (num < x) {
            return undefined;
        } else {
            return LessThanErrorCode.GREATER_THAN_OR_EQUAL;
        }
    });
}

export enum LessThanOrEqualErrorCode {
    GREATER_THAN = "GREATER_THAN"
}

export function checkLessThanOrEqual (mixed : any, x : number) : undefined|PotentiallyUnsafeNumberErrorCode|FiniteNumberErrorCode|LessThanOrEqualErrorCode {
    return checkFiniteNumberPredicate(mixed, (num) => {
        if (num <= x) {
            return undefined;
        } else {
            return LessThanOrEqualErrorCode.GREATER_THAN;
        }
    });
}

export type RangeErrorCodeType = {
    forcedArg : any,
    error : PotentiallyUnsafeNumberErrorCode|FiniteNumberErrorCode|GreaterThanOrEqualErrorCode|LessThanOrEqualErrorCode
};

export function checkRange (mixed : any, args : { min? : number, max? : number }) : undefined|RangeErrorCodeType {
    if (args.min != null) {
        const error = checkGreaterThanOrEqual(mixed, args.min);
        if (error !== undefined) {
            return {
                forcedArg : args.min,
                error : error
            };
        }
    }
    if (args.max != null) {
        const error = checkLessThanOrEqual(mixed, args.max);
        if (error !== undefined) {
            return {
                forcedArg : args.max,
                error : error
            };
        }
    }
    return undefined;
}

export enum PositiveErrorCode {
    ZERO = "ZERO",
    NEGATIVE = "NEGATIVE"
}

export function checkPositive (mixed : any) : undefined|PotentiallyUnsafeNumberErrorCode|FiniteNumberErrorCode|PositiveErrorCode {
    return checkFiniteNumberPredicate(mixed, (num) => {
        if (num === 0) {
            return PositiveErrorCode.ZERO;
        }
        if (num < 0) {
            return PositiveErrorCode.NEGATIVE;
        }
        return undefined;
    });
}

export enum NegativeErrorCode {
    ZERO = "ZERO",
    POSITIVE = "POSITIVE"
}

export function checkNegative (mixed : any) : undefined|PotentiallyUnsafeNumberErrorCode|FiniteNumberErrorCode|NegativeErrorCode {
    return checkFiniteNumberPredicate(mixed, (num) => {
        if (num === 0) {
            return NegativeErrorCode.ZERO;
        }
        if (num > 0) {
            return NegativeErrorCode.POSITIVE;
        }
        return undefined;
    });
}

export enum NonNegativeErrorCode {
    NEGATIVE = "NEGATIVE"
}

export type NonNegativeErrorCodeType = IntegerErrorCodeType|NonNegativeErrorCode;

export function checkNonNegative (mixed : any) : undefined|NonNegativeErrorCodeType {
    return checkFiniteNumberPredicate(mixed, (num) => {
        if (num < 0) {
            return NonNegativeErrorCode.NEGATIVE;
        }
        return undefined;
    });
}

export enum NaturalNumberErrorCode {
    NEGATIVE = "NEGATIVE"
}

export type NaturalNumberErrorCodeType = IntegerErrorCodeType|NaturalNumberErrorCode;

export function checkNaturalNumber (mixed : any) : undefined|NaturalNumberErrorCodeType {
    return checkIntegerPredicate(mixed, (num) => {
        if (num < 0) {
            return NaturalNumberErrorCode.NEGATIVE;
        }
        return undefined;
    });
}

export enum OddErrorCode {
    EVEN = "EVEN"
}

export function checkOdd (mixed : any) : undefined|IntegerErrorCodeType|OddErrorCode {
    return checkIntegerPredicate(mixed, (num) => {
        if ((num%2) == 0) {
            return OddErrorCode.EVEN;
        }
        return undefined;
    });
}

export enum EvenErrorCode {
    ODD = "ODD"
}

export function checkEven (mixed : any) : undefined|IntegerErrorCodeType|EvenErrorCode {
    return checkIntegerPredicate(mixed, (num) => {
        if ((num%2) != 0) {
            return EvenErrorCode.ODD;
        }
        return undefined;
    });
}

export type NotOneOfErrorCodeType = PotentiallyUnsafeNumberErrorCode|MixedCheck.NotOneOfErrorCode;
export function checkNotOneOf<T extends number> (mixed : any, arr : T[]) : undefined|NotOneOfErrorCodeType {
    return checkPotentiallyUnsafeNumberPredicate(mixed, (num) => {
        return MixedCheck.checkNotOneOf<number, T>(num, arr);
    });
}

export type LatitudeCodeErrorType = RangeErrorCodeType;
export function checkLatitude (mixed : any) : undefined|LatitudeCodeErrorType {
    return checkRange(mixed, {
        min : -90.0,
        max : +90.0
    });
}

export type LongitudeCodeErrorType = RangeErrorCodeType;
export function checkLongitude (mixed : any) : undefined|LongitudeCodeErrorType {
    return checkRange(mixed, {
        min : -180.0,
        max : +180.0
    });
}