Axbus.Store = {}

Axbus.Store.Menu = {
    showImage: function(img) {
        Avalon.Ajax.Image.load(img.href || img.src);
        return false;
    },

    select: function(tab) {
        var tabs = document.getElementsByClassName(
                     'cart-menu-items-sort-toggle',
                     'store_menu_sort_container');

        for (var i = 0; i < tabs.length; i++)
            tabs[i].removeClassName('selected');

        var element = (typeof tab == 'string') ?
                            $(
                                'cart_menu_items_sort_toggle_' +
                                tab.replace(/\./g, '_')
                            ) :
                            tab;

        if (element)
            element.addClassName('selected');
    },

    onTabChange: function(tab) {
        var options = tab.getParams();
        this.select(options.sort);
    },

    sort: function(active_elem, sort) {
        var tab_container = ContainerTabbedAjaxCollection.getContainer(
                    'categories');

        if (!this.hooks_set) {
            tab_container.updateOptions(
                {'onselect': this.onTabChange.bind(this)}
            );
            this.hooks_set = true;
        }

        var tab = tab_container.getCurrentTab();
        var params = tab.getParams();

        this.select(active_elem);

        tab_container.reloadCurrentTab(
            {
                "sort" : sort,
                "sort_dir" : (params.sort_dir == 'ASC') ? 'DESC' : 'ASC'
            });

        return false;
    },

    hooks_set: false
}

Axbus.Store.Cart = {
    addItem: function(formobj) {
        var item_id = formobj.item_id.value;
        var item_count = formobj.item_quantity.value;

        if (isNaN(item_count) || item_count <= 0) {
            new Avalon.Ajax.MessageBox(
                    'Please specify a valid item quantity',
                    'Store', ['OK'],
                    {"OK": function(){
                        formobj.item_quantity.value = '';
                        formobj.item_quantity.focus();
                    }});
            return false;
        }

        var responder = function(transport, result) {
            Avalon.Ajax.Renderer.updateElement(
                    'store_cart_content', 'store/cart/content', {}
            );

            Element.toggle('store_item_adding_button_' + item_id);
            Element.toggle('store_item_add_button_' + item_id);
        }

        RPC.store.cartAddItem_async(
            responder, item_id, item_count
        );

        Element.toggle('store_item_adding_button_' + item_id);
        Element.toggle('store_item_add_button_' + item_id);
        formobj.item_quantity.value = '1';

        return false;
    },

    removeItem: function(formobj) {
        var item_id = formobj.item_id.value;

        Avalon.Ajax.Renderer.updateElement(
                    'store_cart_content', 'store/cart/content', {},
                    {"waitfor":
                        RPC.store.cartRemoveItem_async.bindAsRPCMethod(
                            RPC.store, item_id)
                    });

        return false;
    },

    empty: function() {
        Avalon.Ajax.Renderer.updateElement(
                    'store_cart_content', 'store/cart/content', {},
                    {"waitfor":
                        RPC.store.cartEmpty_async.bindAsRPCMethod(RPC.store)
                    });
        return false;
    }
}

Axbus.Store.Checkout = {
    removeItem: function(obj) {
        var item_id = obj.id.substr("shopping_cart_item_delete_".length, obj.id.length);

        if ($('checkout_item_count').value == 1) {
            new Avalon.Ajax.MessageBox(
                    'You cannot delete the last item. '
                        + ' Please go back to the store and change your selection',
                    'Checkout',
                    ['OK']);
            return false;
        }

        Avalon.Ajax.Renderer.updateElement(
                    'store_checkout_items_content', 'store/checkout/items', {},
                    {"waitfor":
                        RPC.store.cartRemoveItem_async.bindAsRPCMethod(
                            RPC.store, item_id),
                     "oncomplete": this.updateTotals.bind(this)
                    });

        return false;
    },

    updateTotals: function() {
        Avalon.Ajax.Renderer.updateElement(
                'store_checkout_totals',
                'store/checkout/totals',
                {"shipping_address" : $("checkout_address_selector_shipping").value});
        return false;
    },

    recalculate: function() {

        var quantities = Form.serialize('checkout_items_form');

        var handler = function(etype, message) {
            Avalon.Ajax.Renderer.updateElement(
                    'store_checkout_items_content', 'store/checkout/items', {}
            );
            new Avalon.Ajax.MessageBox(
                    $MSG('large_order'),
                    'Checkout', ['OK']);
            Avalon.Ajax.Exception.removeHandler('AxbusException_NonShippableOrder', handler);
        };

        Avalon.Ajax.Exception.addHandler('AxbusException_NonShippableOrder', handler);

        Avalon.Ajax.Renderer.updateElement(
                    'store_checkout_items_content', 'store/checkout/items', {},
                    {"waitfor":
                        RPC.store.cartUpdateQuantities_async.bindAsRPCMethod(
                            RPC.store, quantities),
                     "oncomplete": this.updateTotals.bind(this)
                    });

        return false;
    },

    addAddress: function(container) {
        Avalon.Ajax.Renderer.updateElement(
                container, 'store/checkout/address/content', {"edit": true});
        return false;
    },

    editAddress: function(id, container) {
        var item_id = id.substr("checkout_address_edit_".length, id.length);
        Avalon.Ajax.Renderer.updateElement(
                container, 'store/checkout/address/content',
                {"edit": true, "id": item_id });
        return false;
    },

    reloadAddress: function (obj) {
        var addr_type = obj.id.substr("checkout_address_selector_".length, obj.id.length);
        var container = "checkout_address_data_" + addr_type;
        var addr_id = obj.value;
        var addforms = document.getElementsByClassName('checkout-address-form');

        Avalon.Ajax.Renderer.updateElement(
            container,
            'store/checkout/address/content',
            {"edit": addforms.length > 0, "id": addr_id });

        if (addr_type == 'shipping') {
            this.updateTotals();
        }
        return false;
    },


    saveAddress: function(formobj) {

        var address_id = formobj.id.substr("checkout_address_form_".length,
                                        formobj.id.length);

        var inputs = Form.getInputs(formobj, 'image', 'checkout_address_cancel_' + address_id);

        if (inputs && inputs[0].value == 'Cancel') {

            var addr_type = formobj.parentNode.id.substr(
                                    "checkout_address_data_".length,
                                    formobj.parentNode.id.length);

            if (!address_id || address_id == "0") {
                address_id = $("checkout_address_selector_" + addr_type).value;
            }
            Avalon.Ajax.Renderer.updateElement(
                    formobj.parentNode, 'store/checkout/address/content',
                    {"edit": false, "id": address_id });
        } else {
            var updater = this.updateTotals.bind(this);
            Avalon.Ajax.Renderer.updateElement(
                'checkout_address_billing',
                'store/checkout/address',
                {
                    "type": 'billing',
                    "current": $("checkout_address_selector_billing").value
                },
                {
                    "waitfor":
                        RPC.customer.customerAddressUpdate_async.bindAsRPCMethod(
                            RPC.customer, address_id, Form.serialize(formobj)),
                    "oncomplete":
                        function(){Avalon.Ajax.Renderer.updateElement(
                            'checkout_address_shipping',
                            'store/checkout/address',
                            {
                                "type": 'shipping',
                                "current": $("checkout_address_selector_shipping").value
                            },
                            {
                                "oncomplete": updater
                            }
                        );
                    }
                }
            );
        }

        return false;
    },

    placeOrder: function() {
        var elements = Form.getInputs('checkout_payment_form');

        if (!($('checkout_ccname').value)) {
            new Avalon.Ajax.MessageBox(
                    'Please specify the Name on Credit Card',
                    'Checkout', ['OK']);
            return false;
        }

        if (!($('checkout_ccnumber').value)) {
            new Avalon.Ajax.MessageBox(
                    'Please specify the Credit Card Number',
                    'Checkout', ['OK']);
            return false;
        }

        if (!($('checkout_receiver_age').checked)) {
            new Avalon.Ajax.MessageBox(
                    "Please confirm the receiver's age",
                    'Checkout', ['OK']);
            return false;
        }

        var overlay = new Avalon.Ajax.Overlay(document.body);

        var responder = function(transport, result) {
            document.location.href = $('checkout_order_summary_link').href;
            overlay.remove();
        }

        var handler = function(etype, message) {
            new Avalon.Ajax.MessageBox(
                    'The Credit Card Number you specified is '
                    + 'invalid or has expired',
                    'Checkout', ['OK']);
            overlay.remove();
            Avalon.Ajax.Exception.removeHandler('AxbusException_OrderBadCard', handler);
            Avalon.Ajax.Exception.removeHandler('AxbusException_NonShippableOrder', non_ship_handler);
        };

        var non_ship_handler = function(etype, message) {
            Avalon.Ajax.Renderer.updateElement(
                    'store_checkout_items_content', 'store/checkout/items', {}
            );
            new Avalon.Ajax.MessageBox(
                    $MSG('unshippable_order'),
                    'Checkout', ['OK']);
            overlay.remove();
            Avalon.Ajax.Exception.removeHandler('AxbusException_OrderBadCard', handler);
            Avalon.Ajax.Exception.removeHandler('AxbusException_NonShippableOrder', non_ship_handler);
        };

        Avalon.Ajax.Exception.addHandler('AxbusException_NonShippableOrder', non_ship_handler);
        Avalon.Ajax.Exception.addHandler('AxbusException_OrderBadCard', handler);

        overlay.show();
        RPC.store.placeOrder_async(
                responder,
                $('checkout_payment').value,
                {   'name'          : $('checkout_ccname').value,
                    'number'        : $('checkout_ccnumber').value,
                    'expire_month'  : $('checkout_ccmonth').value,
                    'expire_year'   : $('checkout_ccyear').value
                },
                $('checkout_address_selector_shipping').value,
                $('checkout_address_selector_billing').value,
                $('checkout_special_instructions').value
        );

        return false;
    }
}