function decodeCoordinate(coordinate, encodeOffset) {
    var result = []
    var cx, cy
    var offset = encodeOffset.slice()

    for (var i = 0, L = coordinate.length; i < L; i += 2) {
        cx = coordinate.charCodeAt(i) - 64
        cy = coordinate.charCodeAt(i + 1) - 64
        cx = ((cx >> 1) ^ (-(cx & 1))) + offset[0]
        cy = ((cy >> 1) ^ (-(cy & 1))) + offset[1]
        offset[0] = cx
        offset[1] = cy
        result.push([cx / 1024, cy / 1024])
    }

    return result
}

function decodeGeoJSON(geoJSON) {
    var decoder = {
        MultiPolygon: function (coordinates, encodeOffset) {
            return coordinates.map(function (coordinate, index) {
                return decodeCoordinate(coordinate, encodeOffset[index])
            })
        },
        Polygon: decodeCoordinate
    }
    var features = []

    if (typeof geoJSON === 'string') {
        geoJSON = JSON.parse(geoJSON)
    }
    features = geoJSON.features
    // If is unminified json format, do nothing
    if (!geoJSON.UTF8Encoding) {
        return geoJSON
    }

    for (var i = 0, M = features.length; i < M; i++) {
        var geometry = features[i].geometry
        var coordinates = geometry.coordinates
        var encodeOffsets = geometry.encodeOffsets

        coordinates.forEach(function (coordinate, index) {
            coordinates[index] = decoder[geometry.type](
                coordinate,
                encodeOffsets[index]
            )
        })
    }
    geoJSON.UTF8Encoding = false

    return geoJSON
}

function Region(name, contours, center) {
    this.name = name
    this.contours = contours

    if (!center) {
        var boundingRect = this.getBoundingRect()

        center = [
            (boundingRect.xMin + boundingRect.xMax) / 2,
            (boundingRect.yMin + boundingRect.yMax) / 2
        ]
    }
    this.center = center
}

Region.prototype.getBoundingRect = function () {
    var LIMIT = Number.MAX_VALUE
    var getBoundingRect = function (contour) {
        var min = [LIMIT, LIMIT], max = [-LIMIT, -LIMIT]

        contour.forEach(function (coordinate) {
            min[0] = Math.min(min[0], coordinate[0])
            max[0] = Math.max(max[0], coordinate[0])
            min[1] = Math.min(min[1], coordinate[1])
            max[1] = Math.max(max[1], coordinate[1])
        })

        return { xMin: min[0], yMin: min[1], xMax: max[0], yMax: max[1] }
    }
    var result = { xMin: LIMIT, yMin: LIMIT, xMax: -LIMIT, yMax: -LIMIT }

    this.contours.forEach(function (contour) {
        contour.forEach(function (coordinates) {
            var boundingRect = getBoundingRect(coordinates)

            result.xMin = Math.min(result.xMin, boundingRect.xMin)
            result.xMax = Math.max(result.xMax, boundingRect.xMax)
            result.yMin = Math.min(result.yMin, boundingRect.yMin)
            result.yMax = Math.max(result.yMax, boundingRect.yMax)
        })
    })

    return result
}

var geoJSONParser = function (geoJSON) {
    var decodedGeoJSON = decodeGeoJSON(geoJSON)
    var features = decodedGeoJSON.features.filter(function (feature) {
        return (
            feature.properties
            && feature.geometry
            && feature.geometry.coordinates.length > 0
        )
    })

    return features.map(function (feature) {
        var geometry = feature.geometry
        var coordinates = geometry.coordinates

        if (geometry.type === 'Polygon') {
            coordinates = coordinates.map(function (coordinate) {
                return [coordinate]
            })
        }

        return new Region(
            feature.properties.name,
            coordinates,
            feature.properties.cp
        )
    })
}
geoJSONParser.Region = Region;
geoJSONParser.decodeCoordinate = decodeCoordinate;
geoJSONParser.decodeGeoJSON = decodeGeoJSON;
if (typeof module === "undefined") {
    this.geoJSONParser = geoJSONParser;
} else {
    module.exports = geoJSONParser;
}
if (typeof define === "function") {
    define(function () { return geoJSONParser; });
}