var Util = require('findhit-util');

// Everyday use

    Util.uniqId()
    Util.uuid()

    Util.extend()
    Util.clone()
    Util.filter()
    Util.slice()
    Util.splice()

    // Dynamic methods (that calls inner ones)

        Util.each() <- Util.forEach()
            * Util.Array.each() <- Util.Array.forEach()
            * Util.Object.each() <- Util.Object.forEach()
        Util.map()
            * Util.Array.map()
            * Util.Object.map()

    Util.log() // same as console.log()

// IsIsnt - Type validation

    // Is

        Util.is.instanceof( Promise, variable );

        // Default registered Classes

        Util.is.Function( variable );
        Util.is.Object( variable );
        Util.is.Array( variable );
        Util.is.String( variable );
        Util.is.Error( variable );
        Util.is.Number( variable );
        Util.is.Json( variable );

        Util.is.true( variable );
        Util.is.false( variable );
        Util.is.undefined( variable );
        Util.is.null( variable );


    // Isnt

        Util.isnt.instanceof( Promise, promise );

        // Default registered Classes

        Util.isnt.Function( variable );
        Util.isnt.Object( variable );
        Util.isnt.Array( variable );
        Util.isnt.String( variable );
        Util.isnt.Error( variable );
        Util.isnt.Number( variable );
        Util.isnt.Json( variable );

        Util.isnt.true( variable );
        Util.isnt.false( variable );
        Util.isnt.undefined( variable );
        Util.isnt.null( variable );

    // Custom registers
    // This is great, not just to use on your app, but to be used also by who uses your app

        // We use on `findhit-promise` this lib, and we have registered it on IsIsnt like this:
        Util.isisnt.register( Promise, [ 'Promise', 'promise' ] );

        // Now, if someone uses `findhit-promise` and also `findhit-util` can check without
        // having to register it again!! :)

        Util.is.Promise( myAwesomePromiseInstance )

        // We have added also a custom register that accepts one or two functions for evaluation

            // Util.isisnt.registerCustom( keys, isFn, [ isntFn ] );

            // You could bind it to one key
            Util.isisnt.registerCustom( 'even', function ( variable ) {
                return Util.is.Number( variable ) && num % 2;
            });

            // or bind it to multiple
            Util.isisnt.registerCustom( [ 'Odd', 'odd' ], function ( variable ) {
                return Util.is.Number( variable ) && ! num % 2;
            });

                // This would make available:
                Util.is.even( 2 ) // true
                Util.isnt.even( 2 ) // false
                Util.is.even( 3 ) // false
                Util.isnt.even( 3 ) // true

                Util.is.odd( 2 ) // false
                Util.isnt.odd( 2 ) // true
                Util.is.Odd( 3 ) // true
                Util.isnt.Odd( 3 ) // false

            // if isnt evaluation is different than is, you could supply isnt function
            Util.isisnt.registerCustom(
                'coolest',
                function ( variable ) {
                    return variable === 'cuss';
                },
                function ( variable ) {
                    return variable === 'cuss' ? 'how do you dare?' : false; // should return bool, this is just for POC
                }
            );

// By Type

    // Array utils
        // Util.array OR Util.Array

        // is / isnt binds
        Util.Array.is( variable )
        Util.Array.isnt( variable )

        Util.Array.each() <- Util.Array.forEach()
        Util.Array.map()
        Util.Array.empty()

    // String utils
        // Util.string OR Util.String

        // is / isnt binds
        Util.String.is( variable )
        Util.String.isnt( variable )

        Util.String.trim( variable )
        Util.String.splitWords( variable )
        Util.String.capitalize( 'heyyo' ) // Heyyo
        Util.String.decapitalize( 'Heyyo' ) // heyyo

        // Case conversions

            // from CamelCase to ...
            Util.String.fromCamelToUnderscore( 'HeyYo' ) // 'hey_yo'
            Util.String.fromCamelToDash( 'HeyYo' ) // 'hey-yo'
            Util.String.fromCamelToSpaced( 'HeyYo' ) // 'Hey Yo'

            // from underscore_case to ...
            Util.String.fromUnderscoreToCamel( 'hey_yo' ) // 'HeyYo'
            Util.String.fromUnderscoreToDash( 'hey_yo' ) // 'hey-yo'
            Util.String.fromUnderscoreToSpaced( 'hey_yo' ) // 'Hey Yo'

            // from dash-case to ...
            Util.String.fromDashToCamel( 'hey-yo' ) // 'HeyYo'
            Util.String.fromDashToUnderscore( 'hey-yo' ) // 'hey_yo'
            Util.String.fromDashToSpaced( 'hey-yo' ) // 'Hey Yo'

    // Function utils
        // Util.function OR Util.Function

        // is / isnt binds
        Util.Function.is( variable )
        Util.Function.isnt( variable )

        // Analysis
        Util.Function.debug( 'hello', 'petit', 'de', 'moiselle' ) // logs all arguments into console.log;

        // Return returners
        Util.Function.return( value ) // Returns a function that returns the value on each execution

        Util.Function.falsify() // false
        Util.Function.truthify() // true
        Util.Function.nullify() // null
        Util.Function.undefinify() // undefined

        // get function parameter names
        Util.Function.getParamNames('function ( a, b, c )') // [ 'a', 'b', 'c' ]
        Util.Function.getParamNames( function ( a, b, c ) {}) // [ 'a', 'b', 'c' ]
        Util.Function.getParamNames('function ( a, /* b, */ c )') // [ 'a', 'c' ]
        Util.Function.getParamNames( function ( a, /* b, */ c ) {}) // [ 'a', 'c' ]

    // Object utils
        // Util.object OR Util.Object

        // is / isnt binds
        Util.Object.is( variable )
        Util.Object.isnt( variable )

        Util.Object.each() <- Util.Object.forEach()
        Util.Object.map()

    // RegExp utils
        // Util.RegExp OR Util.regexp OR Util.Regexp

        Util.RegExp.builder( [ 'alpha', 'numeric', 'spaced' ]) // Return a regex to match alphanumeric-spaced strings

        Util.RegExp.test( 'as876asdf6 sdf as69876', [ 'alpha', 'numeric', 'spaced' ]) // true
        Util.RegExp.test( 'as876asdf###df as69876', [ 'alpha', 'numeric', 'spaced' ]) // false

        Util.RegExp.match( 'as876asdf6 sdf as69876', [ 'alpha', 'numeric', 'spaced' ]) // Array with matches
        Util.RegExp.match( 'as876asdf###df as69876', [ 'alpha', 'numeric', 'spaced' ]) // false

        // Now, the most exciting thing arround RegExp, the querifier!!
        // Imagine that you need, on a clever way to filter strings
        // Here is the solution: Util.RegExp.querifier()

        var regexp = Util.RegExp.querifier( 'john doe' ); // magical regexp

        Util.RegExp.filter( regexp, [
            'José Moreira',
            'John Something Doe',
            'João Alto',
        ]); // [ 'John Something Doe' ]