using System;
using System.Collections.Generic;
using System.Linq;

namespace Shop.Domain
{
    /// <summary>
    /// Категория товара.
    /// </summary>
    public class Category : Entity
    {
        private IList<Category> childCategories = new List<Category>();
        private IList<Product> products = new List<Product>();
        private Category parentCategory;

        /// <summary>
        /// Наименование.
        /// </summary>
        public virtual string Name { get; set; }

        /// <summary>
        /// Родительская категория.
        /// </summary>
        /// <exception cref="ArgumentNullException">Параметр <paramref name="value"/> равен null.</exception>
        public virtual Category ParentCategory
        {
            get
            {
                return this.parentCategory;
            }

            set
            {
                if (value == null) throw new ArgumentNullException();

                if (this.parentCategory == value) return;

                var childCategories = this.GetChildCategories(this, true);
                if (childCategories.Contains(value))// Новым родителем назначается одна из нижележащих категорий.
                {
                    // У текущего родителя нового родителя удалить из списка дочерних нового родителя.
                    value.parentCategory.childCategories.Remove(value);
                    // Назначить новому родителю родителем родителя текущей категории.
                    value.parentCategory = this.parentCategory;
                    // Родителю текущей категории в дочерние добавить нового родителя.
                    if (this.parentCategory != null)// Возможно текущая категория это корневая категория.
                        this.parentCategory.childCategories.Add(value);
                }

                // У текущего родителя текущей категории удалить из списка дочерних текущую категорию.
                if (this.parentCategory != null)// Возможно текущая категория это корневая или новая категория.
                    //Удалим себя из дочерних категорий текущей родительской категории.
                    this.parentCategory.childCategories.Remove(this);
                // Назначить нового родителя.
                this.parentCategory = value;
                // Добавить текущую категорию в список дочерних категорий новой родительской категории.
                value.childCategories.Add(this);
            }
        }

        /// <summary>
        /// Дочерние категории.
        /// </summary>
        public virtual IEnumerable<Category> ChildCategories { get { return this.childCategories; } }

        /// <summary>
        /// Товары.
        /// </summary>
        public virtual IEnumerable<Product> Products { get { return this.products; } }

        /// <summary>
        /// Добавляет дочернюю категорию.
        /// </summary>
        /// <param name="category">Категория/</param>
        /// <exception cref="ArgumentNullException">Параметр <paramref name="category"/> равен null.</exception>
        /// <exception cref="ArgumentException">Параметр <paramref name="category"/> равен this.</exception>
        public virtual void AddChildCategory(Category category)
        {
            if (category == null) throw new ArgumentNullException("category");

            if (this.childCategories.Contains(category)) return;

            if (category == this) throw new ArgumentException("Нельзя добавлять себя в свои дочерние категории.");

            var parentCategories = this.GetParentCategories(this);
            if (parentCategories.Contains(category))// Указанная категория является вышестоящей.
            {// Нельзя образовывать кольцевые связи, когда к дочерней категории можно добраться по цепочке родителей.
                //Кроме того такое кольцо будет оторвано от основного дерева и не будет иметь корня.
                // У родителя текущей категории удалить из дочерних текущую.
                this.parentCategory.childCategories.Remove(this);
                // Родителем текущей категории сделать родителя добавляемой.
                this.parentCategory = category.parentCategory;
                // Новому родителю текущей категории добавить в дочерние текущую категорию.
                if (this.parentCategory != null)// Возможно текущая категория стала корневой.
                    this.parentCategory.childCategories.Add(this);
            }

            // У родителя добавляемой категории удалить добавляемую из дочерних категорий.
            if (category.parentCategory != null)// Возможно это корневая или новая категория.
                category.parentCategory.childCategories.Remove(category);
            // Добавляемой категории установить в качестве родителя текущую категорию.
            category.parentCategory = this;
            // Текущей категории добавить в дочерние добавляемую категорию.
            this.childCategories.Add(category);
        }

        /// <summary>
        /// Удаляет дочернюю категорию.
        /// </summary>
        /// <param name="category">Категория.</param>
        /// <exception cref="ArgumentNullException">Параметр <paramref name="category"/> равен null.</exception>
        public virtual void RemoveChildCategory(Category category)
        {
            if (category == null) throw new ArgumentNullException("category");

            var c = this.childCategories.SingleOrDefault(x => x == category);
            if (c != null)
            {
                c.parentCategory = null;
                this.childCategories.Remove(c);
            }
        }

        /// <summary>
        /// Добавляет товар.
        /// </summary>
        /// <param name="product">Товар.</param>
        /// <exception cref="ArgumentNullException">Параметр <paramref name="product"/> равен null.</exception>
        public virtual void AddProduct(Product product)
        {
            if (product == null) throw new ArgumentNullException("product");

            if (!this.products.Contains(product))
            {
                this.products.Add(product);
                product.AddCategory(this);
            }
        }

        /// <summary>
        /// Удаляет товар.
        /// </summary>
        /// <param name="product">Товар.</param>
        /// <exception cref="ArgumentNullException">Параметр <paramref name="product"/> равен null.</exception>
        public virtual void RemoveProduct(Product product)
        {
            if (product == null) throw new ArgumentNullException("product");

            if (this.products.Contains(product))
            {
                this.products.Remove(product);
                product.RemoveCategory(this);
            }
        }

        /// <summary>
        /// Возвращает дочерние категорий указанной категории в виде перечислителя.
        /// </summary>
        /// <param name="parent">Категория, перечислитель дочерних которой требуется получить.</param>
        /// <param name="includingChild">Значение, указывающее, необходимо ли включать в выборку
        /// категории из дочерних категорий указанной категории.</param>
        /// <returns>Перечислитель дочерних категорий.</returns>
        private IEnumerable<Category> GetChildCategories(Category parent, bool includingChild = false)
        {
            if (includingChild)
            {
                var childCategories = parent.childCategories.SelectMany(x => parent.GetChildCategories(x, true));
                return parent.childCategories.Union(childCategories);
            }
            else
                return parent.childCategories;
        }

        /// <summary>
        /// Возвращает перечислитель всех вышестоящих категорий.
        /// </summary>
        /// <param name="category">Категория, для которой нужно получить вышестоящие категории.</param>
        /// <returns>Перечислитель вышестоящих категорий.</returns>
        private IEnumerable<Category> GetParentCategories(Category category)
        {
            var list = new List<Category>();

            if (category.parentCategory != null)
            {
                list.Add(category.parentCategory);
                return list.Union(category.parentCategory.GetParentCategories(category.parentCategory));
            }

            return list;
        }
    }
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace Shop.Domain
{
    /// <summary>
    /// Товар.
    /// </summary>
    public class Product : Entity
    {
        private IList<Category> categories = new List<Category>();

        /// <summary>
        /// Наименование.
        /// </summary>
        public virtual string Name { get; set; }

        /// <summary>
        /// Цена.
        /// </summary>
        public virtual decimal Price { get; set; }

        /// <summary>
        /// Наличие скидки.
        /// </summary>
        public virtual bool Discounted { get; set; }

        /// <summary>
        /// Размер скидки в процентах.
        /// </summary>
        public virtual decimal Discount { get; set; }

        /// <summary>
        /// Категории, к которым относится товар.
        /// </summary>
        public virtual IEnumerable<Category> Categories { get { return this.categories; } }

        /// <summary>
        /// Добавляет категорию.
        /// </summary>
        /// <param name="category">Категория/</param>
        /// <exception cref="ArgumentNullException">Параметр <paramref name="category"/> равен null.</exception>
        public virtual void AddCategory(Category category)
        {
            if (category == null) throw new ArgumentNullException("category");

            if (!this.categories.Contains(category))
            {
                this.categories.Add(category);
                category.AddProduct(this);
            }
        }

        /// <summary>
        /// Удаляет категорию.
        /// </summary>
        /// <param name="category">Категория.</param>
        /// <exception cref="ArgumentNullException">Параметр <paramref name="category"/> равен null.</exception>
        public virtual void RemoveCategory(Category category)
        {
            if (category == null) throw new ArgumentNullException("category");

            if (this.categories.Contains(category))
            {
                this.categories.Remove(category);
                category.RemoveProduct(this);
            }
        }
    }
}

using FluentNHibernate.Mapping;
using Shop.Domain;

namespace NHInfrastructure.Mappings
{
    class CategoryMap : ClassMap<Category>
    {
        public CategoryMap()
        {
            Id(x => x.ID);
            Map(x => x.Name);
            References(x => x.ParentCategory)
                .Access.CamelCaseField()
                .Cascade.SaveUpdate();

            HasMany(x => x.ChildCategories)
                .Inverse()
                .Cascade.SaveUpdate();

            HasManyToMany(x => x.Products)
                .Inverse()
                .Cascade.SaveUpdate();
        }
    }
}

using FluentNHibernate.Mapping;
using Shop.Domain;

namespace NHInfrastructure.Mappings
{
    class ProductMap : ClassMap<Product>
    {
        public ProductMap()
        {
            Id(x => x.ID);
            Map(x => x.Name);
            Map(x => x.Price);
            Map(x => x.Discounted);
            Map(x => x.Discount);

            HasManyToMany(x => x.Categories)
                .Cascade.SaveUpdate();
        }
    }
}