/*!
 * jQuery areaOffset Plugin
 *
 * Copyright 2010, Peter Galiba
 * Dual licensed under the MIT or GPL Version 2 licenses.
 */
(function ($) {

    /**
   * Fetch the offset of an <area> in a <map> element.
   *
   * @param center {Boolean}
   *   Return the center offset of the area if set.
   * @returns {Object}
   *   Offset position in an object like: {top: 0, left: 0}.
   */
    $.fn.areaOffset = function (center) {
        var areas = this.filter('area'),
        area = areas.length && areas[0],
        coords = (area && $.map(area.coords.split(','), $.trim)) || [],
        cl = coords.length,
        offset = {
            left: 0, 
            top:  0
        },
        shape,
        xs, ys, xm, ym, i, A, xl, cx, cy, s,
        map, obj;

        if (cl > 2) {
            shape = areas.eq(0).attr('shape');
            shape = shape && shape.toLowerCase();
            // Different calculations are required by shape type.
            switch (shape) {
                case 'circle':
                    // By default circle returns center, so calculation is only needed,
                    // if upper left corner is required.
                    offset = {
                        left : +coords[0] - (center ? 0 : coords[2]),
                        top  : +coords[1] - (center ? 0 : coords[2])
                    };
                    break;

                case 'rect':
                case 'poly':
                    // Polygon needs to have at least 3 vectors.
                    if (cl >= 6 && cl % 2 === 0) {
                        xs = [];
                        ys = [];
                        for (i = 0; i < cl; i += 1) {
                            i % 2 ? ys.push(+coords[i]) : xs.push(+coords[i]);
                        }
                        xm = Math.min.apply(Math, xs);        // Minimum of all X coords
                        ym = Math.min.apply(Math, ys);        // Minimum of all Y coords

                        offset = {
                            left : xm,
                            top  : ym
                        };

                        // Caculate center position if needed.
                        if (center) {
                            xl = xs.length; // Real corners of the polygon
                            // Treat rectangles differently
                            if (shape === 'rect') {
                                offset = {
                                    left : xm + (Math.max.apply(Math, xs) - xm) / 2,
                                    top  : ym + (Math.max.apply(Math, ys) - ym) / 2
                                };
                            }
                            else {
                                // The starting and ending value vector should be the same
                                // according to W3C spec, or should be filled with the it.
                                if (xl === 3 || !(xs[xl - 1] === xs[0] && ys[xl - 1] === ys[0])) {
                                    xs[xl] = xs[0];
                                    ys[xl] = ys[0];
                                }
                                else {
                                    xl -= 1; // Polygon already closed, decrease the corners
                                }

                                // Calculate the centroid of the polygon
                                A = 0;   // Signed area
                                cx = 0;  // Center X coorinate
                                cy = 0;  // Center Y coordinate
                                for (i = 0; i < xl; i += 1) {
                                    s = xs[i] * ys[i + 1] - xs[i + 1] * ys[i]; // Partial signed area
                                    A += s;
                                    cx += (xs[i] + xs[i + 1]) * s;
                                    cy += (ys[i] + ys[i + 1]) * s;
                                }

                                // If we have a non 0 area, count the rest.
                                if (A !== 0) {
                                    A /= 2;
                                    cx /= 6 * A;
                                    cy /= 6 * A;

                                    offset = {
                                        left : cx,
                                        top  : cy
                                    };
                                }

                            }
                        }
                    }
                    break;

                default:
                    if (center) {
                        map = areas.eq(0).closest('map');
                        obj = map.length && $('[usemap=#' + map[0].name + ']');
                        if (obj.length) {
                            offset = {
                                left: obj.height() / 2,
                                top:  obj.width() / 2
                            };
                        }
                    }
                    break;
            }
        }
        return offset;
    };
}(jQuery));

jQuery(function ($) {
    var planetImage = $('#planetimage'),
    imageOffset = planetImage.position();

    $('#planetmap').children('area').each(function () {
        var menu = $(this.id.replace(/^map-/, '#menu-')),
        area = $(this),
        offset = $(this).areaOffset(true),
        
        menuOffset = {
            left : imageOffset.left + offset.left,
            top  : imageOffset.top + offset.top
        };

        if (menu.length) {
            menu.offset(menuOffset).bind('mouseleave', function () {
                $('.containerInfo').hide();
                
                menu.fadeOut();
            })
        }
        $.data(this, 'containerInfo', menu);
    }).bind('mouseenter', function (e) {
        
        var menu = $.data(this, 'containerInfo');

        if (menu) {
            $('.containerInfo').hide();
            menu.fadeIn();
        }

    });
});