function ProductFilter(settings) {
    var guid = "";

    function Initialize() {
        $(settings.GetItems()).each(function() { FilterClick(this); });
    }

    function DisableItems(items) {
        $(items).each(function() {
            var item = this;
            $(item).unbind("click");
            $(item).attr("class", settings.DisabledCss);
            $(item).click(function() { return false; });
        });
    }

    function FilterClick(item) {
        var actualRequest = function(myguid, href) {
            var qstring = "";
            if (href.indexOf('?') >= 0) {
                qstring = href.substring(href.indexOf('?') + 1, href.length);
            }
            if (settings.FilterPage && qstring.length > 0) {
                href = settings.FilterPage + "?" + qstring;
            } else if (settings.FilterPage && qstring.length == 0) {
                href = settings.FilterPage;
            } else if (qstring.length == 0) {
                href = window.location.pathname;
            }

            if (settings.Mode) {
                href = href.replace("&mode=" + settings.Mode, "");
                href = href.replace("?mode=" + settings.Mode, "?");
            }
            if (settings.EnableSelectionOnLoad) {
            } else {
                DisableItems(settings.GetItems());
            }
            $.ajax({
                url: href,
                data: { mode: settings.Mode },
                success: function(htmldata) {
                    if (myguid == guid) {
                        var productHtml = $(htmldata).find("#" + settings.ResultContainer).html();
                        var filterHtml = $(htmldata).find("#" + settings.FilterContainer).html();
                        $("#" + settings.ResultContainer).html(productHtml);
                        $("#" + settings.FilterContainer).html(filterHtml);
                        Initialize();
                        if (settings.GetBusyLoader != undefined) {
                            $(settings.GetBusyLoader()).fadeOut("fast");
                        }
                    }
                },
                error: function() {
                    if (myguid == guid) {
                        if (settings.GetBusyLoader != undefined) {
                            $(settings.GetBusyLoader()).fadeOut("fast");
                        }
                    }
                }
            });
        };
        $(item).unbind('click');
        $(item).click(function() {
            var href = $(item).attr('href');
            if (href != undefined) {
                guid = CreateGuid();
                if (settings.GetBusyLoader != undefined) {
                    $(settings.GetBusyLoader()).fadeIn("fast", function() { actualRequest(guid, href); });
                } else {
                    actualRequest(guid, href);
                }
            }
            return false;
        });
    }

    $(document).ready(function() {
        Initialize();
    });

    this.ChangeFilterPage = function(newPage) {
        settings.FilterPage = newPage;
    }

    this.ChangeMode = function(newMode) {
        settings.Mode = newMode;
    }

    this.Reinitialize = function() {
        Initialize();
    }
}

function ProductAttributeHandler(settings) {
    this.IdProductDetail = 0;
    this.InStock = true;
    var lastSelectedProductDetail = 0;
    var dict = new Dictionary();
    var hoverDict = new Dictionary();

    function SyncDictionaries() {
        for (var i = 0; i < dict.Count(); i++) {
            var key = dict.KeyAt(i);
            var value = dict.Get(key);
            hoverDict.Set(key, value);
        }
    }

    function ActualSelect(sender, IdAttributeValue, dictionary) {
        for (var x = 0; x < settings.Matrix.length; x++) {
            var variant = settings.Matrix[x];
            for (var y = 0; y < variant.IdAttributeValues.length; y++) {
                if (variant.IdAttributeValues[y].Value == IdAttributeValue) {
                    dictionary.Set(variant.IdAttributeValues[y].Attribute, variant.IdAttributeValues[y].Value);
                    break;
                }
            }
        }
        return SelectVariant(sender, dictionary);
    }

    function SelectVariant(sender, dictionary) {
        var inStock = false;
        if (dictionary.Count() > 0) {
            var foundcount = 0;

            for (var x = 0; x < settings.Matrix.length; x++) {
                var variant = settings.Matrix[x];
                var tempCount = 0;
                for (var i = 0; i < dictionary.Count(); i++) {
                    var value = dictionary.Get(dictionary.KeyAt(i));
                    for (var y = 0; y < variant.IdAttributeValues.length; y++) {
                        if (variant.IdAttributeValues[y].Value == value) {
                            tempCount++;
                            break;
                        }
                    }
                }
                if (tempCount == dictionary.Count()) {
                    idProductDetail = variant.VariantID;
                    foundcount++;
                }
            }
            if (foundcount == 1) {
                for (var x = 0; x < settings.Matrix.length; x++) {
                    var variant = settings.Matrix[x];
                    if (variant.VariantID == idProductDetail) {
                        inStock = variant.InStock;
                        break;
                    }
                }
            }
        } else {
            idProductDetail = 0;
        }
        return { VariantID: idProductDetail, InStock: inStock };
    }

    this.ShowRelatedNotInStockItems = function(dictionary, notInStockAction) {
        var notInStockVariants = new Array();
        for (var x = 0; x < settings.Matrix.length; x++) {
            var v = settings.Matrix[x];
            if (v.InStock == false) {
                notInStockVariants.push(v);
            }
        }

        for (var x = 0; x < dictionary.Count(); x++) {
            var IdAttribute = dictionary.KeyAt(x);
            var IdValue = dictionary.Get(IdAttribute);
            for (var y = 0; y < notInStockVariants.length; y++) {
                var list = notInStockVariants[y].IdAttributeValues;
                var affectedValues = new Array();
                var isValid = false;
                for (var z = 0; z < list.length; z++) {
                    if (list[z].Value == IdValue) {
                        isValid = true;
                    }
                    if (list[z].Attribute != IdAttribute) {
                        affectedValues.push(list[z].Value);
                    }
                }
                if (isValid == true) {
                    for (var z = 0; z < affectedValues.length; z++) {
                        notInStockAction(affectedValues[z]);
                    }
                }
            }
        }
    }

    this.SelectedDictionary = function() {
        return dict;
    }

    this.SelectAttributeValue = function(sender, IdAttributeValue) {
        var result = ActualSelect(sender, IdAttributeValue, dict);
        this.IdProductDetail = result.VariantID;
        this.InStock = result.InStock;
        if (this.IdProductDetail > 0) {
            lastSelectedProductDetail = this.IdProductDetail;
        } else {
            this.IdProductDetail = lastSelectedProductDetail;
        }
        SyncDictionaries();
        $(this).trigger("OnSelectionFinished", [sender, IdAttributeValue]);
    }

    this.HoverIn = function(sender, IdAttribute, IdAttributeValue) {
        var result = ActualSelect(sender, IdAttributeValue, hoverDict);
        var selected = result.VariantID;
        var inStock = result.InStock;
        $(this).trigger("OnHoverIn",
        [sender, {
            SelectedProductAttribute: IdAttribute,
            SelectedProductAttributeValue: IdAttributeValue,
            VariantID: selected,
            Dictionary: hoverDict,
            InStock: inStock
        }
        ]);
    }

    this.HoverOut = function(sender, IdAttribute, IdAttributeValue) {
        SyncDictionaries();
        $(this).trigger("OnHoverOut", [sender, IdAttributeValue]);
    }

    this.ShowAvailability = function(value, data, notfoundAction) {
        var temp = new Dictionary();
        var IdAttribute = 0;
        for (var x = 0; x < data.Count(); x++) {
            var key = data.KeyAt(x);
            if (data.Get(key) == value) {
                IdAttribute = key;
                break;
            }
        }
        var affectedVariants = new Array();
        for (var x = 0; x < settings.Matrix.length; x++) {
            var variant = settings.Matrix[x];
            for (var y = 0; y < variant.IdAttributeValues.length; y++) {
                if (variant.IdAttributeValues[y].Value == value) {
                    affectedVariants.push(variant);
                }
            }
        }
        for (var x = 0; x < affectedVariants.length; x++) {
            var variant = affectedVariants[x];
            for (var y = 0; y < variant.IdAttributeValues.length; y++) {
                if (variant.IdAttributeValues[y].Attribute != IdAttribute && variant.InStock == false) {
                    notfoundAction(variant.IdAttributeValues[y].Value);
                }
            }
        }
    }

    this.ToDebugString = function() {
        return this.IdProductDetail + "::" + dict.ToDebugString() + "::" + hoverDict.ToDebugString();
    }

    var _instance = $(this);
    function Initialize() {
        var defaultId = 0;
        if (settings.Matrix.length > 0) {
            var variant = settings.Matrix[0];
            defaultId = variant.VariantID;
            for (var y = 0; y < variant.IdAttributeValues.length; y++) {
                dict.Set(variant.IdAttributeValues[y].Attribute, variant.IdAttributeValues[y].Value);
                hoverDict.Set(variant.IdAttributeValues[y].Attribute, variant.IdAttributeValues[y].Value);
            }
        }
        _instance.IdProductDetail = SelectVariant(undefined, dict);
        $(_instance).trigger("OnInitialized", [{ AttributeDictionary: dict, DefaultVariantID: defaultId}]);
    }

    $(document).ready(Initialize);
}