Pattern = require './Pattern'

# A bunch of utility methods
#
class Utils

    @REGEX_LEFT_TRIM_BY_CHAR:   {}
    @REGEX_RIGHT_TRIM_BY_CHAR:  {}
    @REGEX_SPACES:              /\s+/g
    @REGEX_DIGITS:              /^\d+$/
    @REGEX_OCTAL:               /[^0-7]/gi
    @REGEX_HEXADECIMAL:         /[^a-f0-9]/gi

    # Precompiled date pattern
    @PATTERN_DATE:              new Pattern '^'+
            '(?<year>[0-9][0-9][0-9][0-9])'+
            '-(?<month>[0-9][0-9]?)'+
            '-(?<day>[0-9][0-9]?)'+
            '(?:(?:[Tt]|[ \t]+)'+
            '(?<hour>[0-9][0-9]?)'+
            ':(?<minute>[0-9][0-9])'+
            ':(?<second>[0-9][0-9])'+
            '(?:\.(?<fraction>[0-9]*))?'+
            '(?:[ \t]*(?<tz>Z|(?<tz_sign>[-+])(?<tz_hour>[0-9][0-9]?)'+
            '(?::(?<tz_minute>[0-9][0-9]))?))?)?'+
            '$', 'i'

    # Local timezone offset in ms
    @LOCAL_TIMEZONE_OFFSET:     new Date().getTimezoneOffset() * 60 * 1000

    # Trims the given string on both sides
    #
    # @param [String] str The string to trim
    # @param [String] _char The character to use for trimming (default: '\\s')
    #
    # @return [String] A trimmed string
    #
    @trim: (str, _char = '\\s') ->
        regexLeft = @REGEX_LEFT_TRIM_BY_CHAR[_char]
        unless regexLeft?
            @REGEX_LEFT_TRIM_BY_CHAR[_char] = regexLeft = new RegExp '^'+_char+''+_char+'*'
        regexLeft.lastIndex = 0
        regexRight = @REGEX_RIGHT_TRIM_BY_CHAR[_char]
        unless regexRight?
            @REGEX_RIGHT_TRIM_BY_CHAR[_char] = regexRight = new RegExp _char+''+_char+'*$'
        regexRight.lastIndex = 0
        return str.replace(regexLeft, '').replace(regexRight, '')


    # Trims the given string on the left side
    #
    # @param [String] str The string to trim
    # @param [String] _char The character to use for trimming (default: '\\s')
    #
    # @return [String] A trimmed string
    #
    @ltrim: (str, _char = '\\s') ->
        regexLeft = @REGEX_LEFT_TRIM_BY_CHAR[_char]
        unless regexLeft?
            @REGEX_LEFT_TRIM_BY_CHAR[_char] = regexLeft = new RegExp '^'+_char+''+_char+'*'
        regexLeft.lastIndex = 0
        return str.replace(regexLeft, '')


    # Trims the given string on the right side
    #
    # @param [String] str The string to trim
    # @param [String] _char The character to use for trimming (default: '\\s')
    #
    # @return [String] A trimmed string
    #
    @rtrim: (str, _char = '\\s') ->
        regexRight = @REGEX_RIGHT_TRIM_BY_CHAR[_char]
        unless regexRight?
            @REGEX_RIGHT_TRIM_BY_CHAR[_char] = regexRight = new RegExp _char+''+_char+'*$'
        regexRight.lastIndex = 0
        return str.replace(regexRight, '')


    # Checks if the given value is empty (null, undefined, empty string, string '0', empty Array, empty Object)
    #
    # @param [Object] value The value to check
    #
    # @return [Boolean] true if the value is empty
    #
    @isEmpty: (value) ->
        return not(value) or value is '' or value is '0' or (value instanceof Array and value.length is 0) or @isEmptyObject(value)

    # Checks if the given value is an empty object
    #
    # @param [Object] value The value to check
    #
    # @return [Boolean] true if the value is empty and is an object
    #
    @isEmptyObject: (value) ->
        return value instanceof Object and (k for own k of value).length is 0

    # Counts the number of occurences of subString inside string
    #
    # @param [String] string The string where to count occurences
    # @param [String] subString The subString to count
    # @param [Integer] start The start index
    # @param [Integer] length The string length until where to count
    #
    # @return [Integer] The number of occurences
    #
    @subStrCount: (string, subString, start, length) ->
        c = 0

        string = '' + string
        subString = '' + subString

        if start?
            string = string[start..]
        if length?
            string = string[0...length]

        len = string.length
        sublen = subString.length
        for i in [0...len]
            if subString is string[i...sublen]
                c++
                i += sublen - 1

        return c


    # Returns true if input is only composed of digits
    #
    # @param [Object] input The value to test
    #
    # @return [Boolean] true if input is only composed of digits
    #
    @isDigits: (input) ->
        @REGEX_DIGITS.lastIndex = 0
        return @REGEX_DIGITS.test input


    # Decode octal value
    #
    # @param [String] input The value to decode
    #
    # @return [Integer] The decoded value
    #
    @octDec: (input) ->
        @REGEX_OCTAL.lastIndex = 0
        return parseInt((input+'').replace(@REGEX_OCTAL, ''), 8)


    # Decode hexadecimal value
    #
    # @param [String] input The value to decode
    #
    # @return [Integer] The decoded value
    #
    @hexDec: (input) ->
        @REGEX_HEXADECIMAL.lastIndex = 0
        input = @trim(input)
        if (input+'')[0...2] is '0x' then input = (input+'')[2..]
        return parseInt((input+'').replace(@REGEX_HEXADECIMAL, ''), 16)


    # Get the UTF-8 character for the given code point.
    #
    # @param [Integer] c The unicode code point
    #
    # @return [String] The corresponding UTF-8 character
    #
    @utf8chr: (c) ->
        ch = String.fromCharCode
        if 0x80 > (c %= 0x200000)
            return ch(c)
        if 0x800 > c
            return ch(0xC0 | c>>6) + ch(0x80 | c & 0x3F)
        if 0x10000 > c
            return ch(0xE0 | c>>12) + ch(0x80 | c>>6 & 0x3F) + ch(0x80 | c & 0x3F)

        return ch(0xF0 | c>>18) + ch(0x80 | c>>12 & 0x3F) + ch(0x80 | c>>6 & 0x3F) + ch(0x80 | c & 0x3F)


    # Returns the boolean value equivalent to the given input
    #
    # @param [String|Object]    input       The input value
    # @param [Boolean]          strict      If set to false, accept 'yes' and 'no' as boolean values
    #
    # @return [Boolean]         the boolean value
    #
    @parseBoolean: (input, strict = true) ->
        if typeof(input) is 'string'
            lowerInput = input.toLowerCase()
            if not strict
                if lowerInput is 'no' then return false
            if lowerInput is '0' then return false
            if lowerInput is 'false' then return false
            if lowerInput is '' then return false
            return true
        return !!input



    # Returns true if input is numeric
    #
    # @param [Object] input The value to test
    #
    # @return [Boolean] true if input is numeric
    #
    @isNumeric: (input) ->
        @REGEX_SPACES.lastIndex = 0
        return typeof(input) is 'number' or typeof(input) is 'string' and !isNaN(input) and input.replace(@REGEX_SPACES, '') isnt ''


    # Returns a parsed date from the given string
    #
    # @param [String] str The date string to parse
    #
    # @return [Date] The parsed date or null if parsing failed
    #
    @stringToDate: (str) ->
        unless str?.length
            return null

        # Perform regular expression pattern
        info = @PATTERN_DATE.exec str
        unless info
            return null

        # Extract year, month, day
        year = parseInt info.year, 10
        month = parseInt(info.month, 10) - 1 # In javascript, january is 0, february 1, etc...
        day = parseInt info.day, 10

        # If no hour is given, return a date with day precision
        unless info.hour?
            date = new Date Date.UTC(year, month, day)
            return date

        # Extract hour, minute, second
        hour = parseInt info.hour, 10
        minute = parseInt info.minute, 10
        second = parseInt info.second, 10

        # Extract fraction, if given
        if info.fraction?
            fraction = info.fraction[0...3]
            while fraction.length < 3
                fraction += '0'
            fraction = parseInt fraction, 10
        else
            fraction = 0

        # Compute timezone offset if given
        if info.tz?
            tz_hour = parseInt info.tz_hour, 10
            if info.tz_minute?
                tz_minute = parseInt info.tz_minute, 10
            else
                tz_minute = 0

            # Compute timezone delta in ms
            tz_offset = (tz_hour * 60 + tz_minute) * 60000
            if '-' is info.tz_sign
                tz_offset *= -1

        # Compute date
        date = new Date Date.UTC(year, month, day, hour, minute, second, fraction)
        if tz_offset
            date.setTime date.getTime() - tz_offset

        return date


    # Repeats the given string a number of times
    #
    # @param [String]   str     The string to repeat
    # @param [Integer]  number  The number of times to repeat the string
    #
    # @return [String]  The repeated string
    #
    @strRepeat: (str, number) ->
        res = ''
        i = 0
        while i < number
            res += str
            i++
        return res


    # Reads the data from the given file path and returns the result as string
    #
    # @param [String]   path        The path to the file
    # @param [Function] callback    A callback to read file asynchronously (optional)
    #
    # @return [String]  The resulting data as string
    #
    @getStringFromFile: (path, callback = null) ->
        xhr = null
        if window?
            if window.XMLHttpRequest
                xhr = new XMLHttpRequest()
            else if window.ActiveXObject
                for name in ["Msxml2.XMLHTTP.6.0", "Msxml2.XMLHTTP.3.0", "Msxml2.XMLHTTP", "Microsoft.XMLHTTP"]
                    try
                        xhr = new ActiveXObject(name)

        if xhr?
            # Browser
            if callback?
                # Async
                xhr.onreadystatechange = ->
                    if xhr.readyState is 4
                        if xhr.status is 200 or xhr.status is 0
                            callback(xhr.responseText)
                        else
                            callback(null)
                xhr.open 'GET', path, true
                xhr.send null

            else
                # Sync
                xhr.open 'GET', path, false
                xhr.send null

                if xhr.status is 200 or xhr.status == 0
                    return xhr.responseText

                return null
        else
            # Node.js-like
            req = require
            fs = req('fs') # Prevent browserify from trying to load 'fs' module
            if callback?
                # Async
                fs.readFile path, (err, data) ->
                    if err
                        callback null
                    else
                        callback String(data)

            else
                # Sync
                data = fs.readFileSync path
                if data?
                    return String(data)
                return null



module.exports = Utils