//-----------------------------------------------------------------------
// <copyright file="DtoPropertyAttributeMap.cs" company="Deltares">
//  Copyright (c) 2009 Deltares. All rights reserved.
// </copyright>
// <author>B. Faassen</author>
// <email>barry.faassen@deltares.nl</email>
// <date>9-2-2009</date>
// <summary>
//  Defines a type safe collection of DtoPropertyAttributeMapping items
// </summary>
//-----------------------------------------------------------------------
using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;

namespace Deltares.DamEngine.Calculators.KernelWrappers.DamMacroStability.Assemblers
{
    /// <summary>
    /// The property bag defines a dynamic property collection (dictionary)
    /// </summary>
    public class DtoPropertyAttributeMap : IDictionary<string, DtoPropertyAttriubteMapping>
    {
        /// <summary>
        /// Holds the property dictionary
        /// </summary>
        private readonly IDictionary<string, DtoPropertyAttriubteMapping> dict = new Dictionary<string, DtoPropertyAttriubteMapping>();

        #region IDictionary<string,DtoPropertyAttriubteMapping> Members

        /// <summary>
        /// Adds a property attribute mapping to the dictionary
        /// </summary>
        /// <param name="propName">The name of the property</param>
        /// <param name="value">The value</param>
        public void Add(string propName, DtoPropertyAttriubteMapping item)
        {
            if (item == null)
                throw new DtoPropertyMapException("Cannot add an empty or null item to the map");

            if (!item.PropertyName.HasValidStringValue() || propName != item.PropertyName)
                throw new DtoPropertyMapException("Property name is empty or doesn't match dictionary property name (key)");

            this.dict.Add(propName, item);
        }

        /// <summary>
        /// Determinses wheter the dictionary contains the specified key
        /// </summary>
        /// <param name="propName">The name of the property</param>
        /// <returns></returns>
        public bool ContainsKey(string propName)
        {
            return this.dict.ContainsKey(propName);
        }

        /// <summary>
        /// Gets the containing keys
        /// </summary>
        public ICollection<string> Keys
        {
            get { return this.dict.Keys; }
        }

        /// <summary>
        /// Removes a key from the dictionary
        /// </summary>
        /// <param name="propName">The key or property name </param>
        /// <returns>Booleand value indicating when the item is successfuly removed</returns>
        public bool Remove(string propName)
        {
            return this.dict.Remove(propName);
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="propName"></param>
        /// <param name="value"></param>
        /// <returns></returns>
        public bool TryGetValue(string propName, out DtoPropertyAttriubteMapping value)
        {
            return this.dict.TryGetValue(propName, out value);
        }

        /// <summary>
        /// 
        /// </summary>
        public ICollection<DtoPropertyAttriubteMapping> Values
        {
            get { return this.dict.Values; }
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="propName"></param>
        /// <returns></returns>
        public DtoPropertyAttriubteMapping this[string propName]
        {
            get { return this.dict[propName]; }
            set { this.dict[propName] = value; }
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="item"></param>
        public void Add(KeyValuePair<string, DtoPropertyAttriubteMapping> item)
        {
            this.dict.Add(item.Key, item.Value);
        }

        /// <summary>
        /// 
        /// </summary>
        public void Clear()
        {
            this.dict.Clear();
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="item"></param>
        /// <returns></returns>
        public bool Contains(KeyValuePair<string, DtoPropertyAttriubteMapping> item)
        {
            return ((IDictionary<string, DtoPropertyAttriubteMapping>) this.dict).Contains(item);
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="array"></param>
        /// <param name="arrayIndex"></param>
        public void CopyTo(KeyValuePair<string, DtoPropertyAttriubteMapping>[] array, int arrayIndex)
        {
            ((IDictionary<string, DtoPropertyAttriubteMapping>) this.dict).CopyTo(array, arrayIndex);
        }

        /// <summary>
        /// 
        /// </summary>
        public int Count
        {
            get { return this.dict.Count; }
        }

        /// <summary>
        /// 
        /// </summary>
        public bool IsReadOnly
        {
            get { return false; }
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="item"></param>
        /// <returns></returns>
        public bool Remove(KeyValuePair<string, DtoPropertyAttriubteMapping> item)
        {
            return this.dict.Remove(item.Key);
        }

        /// <summary>
        /// 
        /// </summary>
        /// <returns></returns>
        public IEnumerator<KeyValuePair<string, DtoPropertyAttriubteMapping>> GetEnumerator()
        {
            return this.dict.GetEnumerator();
        }

        /// <summary>
        /// 
        /// </summary>
        /// <returns></returns>
        IEnumerator IEnumerable.GetEnumerator()
        {
            return (IEnumerator) ((IDictionary<string, DtoPropertyAttriubteMapping>) this.dict).GetEnumerator();
        }

        #endregion

        /// <summary>
        /// Adds a property attribute mapping to the dictionary
        /// </summary>
        /// <param name="item">The <see cref="DtoPropertyAttriubteMapping"/> item to add</param>
        public void Add(DtoPropertyAttriubteMapping item)
        {
            if (item == null)
                throw new ArgumentNullException("item");

            this.Add(item.PropertyName, item);
        }

        /// <summary>
        /// Adds a or updtes a property attribute mapping to the dictionary
        /// </summary>
        /// <param name="item">The <see cref="DtoPropertyAttriubteMapping"/> item to add</param>
        public void AddOrUpdate(string propName, string attrName)
        {
            this.AddOrUpdate(propName, attrName, DtoPropertyImportance.Optional);
        }

        /// <summary>
        /// Adds a or updtes a property attribute mapping to the dictionary
        /// </summary>
        /// <param name="item">The <see cref="DtoPropertyAttriubteMapping"/> item to add</param>
        public void AddOrUpdate(string propName, string attrName, DtoPropertyImportance importance)
        {
            if (!attrName.HasValidStringValue())
                throw new DtoPropertyMapException("attrName");

            this.AddOrUpdate(propName,
                             new DtoPropertyAttriubteMapping()
                                 {
                                     PropertyName = propName,
                                     AttributeName = attrName,
                                     Importance = importance
                                 });
        }


        /// <summary>
        /// Adds a or updtes a property attribute mapping to the dictionary
        /// </summary>
        /// <param name="item">The <see cref="DtoPropertyAttriubteMapping"/> item to add</param>
        public void AddOrUpdate(DtoPropertyAttriubteMapping item)
        {
            if (item == null)
                throw new ArgumentNullException("item");

            this.AddOrUpdate(item.PropertyName, item);
        }


        /// <summary>
        /// Adds or updates new items in the dictionary
        /// </summary>
        /// <param name="propName">The name of the property</param>
        /// <param name="value">The value</param>
        public void AddOrUpdate(string propName, DtoPropertyAttriubteMapping item)
        {
            if (item == null)
                throw new ArgumentNullException("item");

            if (!propName.HasValidStringValue())
                throw new DtoPropertyMapException("Property name (or key) is empty");

            if (!this.dict.ContainsKey(propName))
            {
                this.Add(item.PropertyName, item);
            }
            else
            {
                this.dict[propName] = item;
            }
        }

        /// <summary>
        /// Adds or updates new items in the dictionary
        /// </summary>
        /// <param name="coll">The key value pair collection to handle</param>
        public void AddOrUpdateRange(IEnumerable<DtoPropertyAttriubteMapping> coll)
        {
            foreach (DtoPropertyAttriubteMapping item in coll)
            {
                this.AddOrUpdate(item);
            }
        }

        /// <summary>
        /// Gets an item by property name
        /// </summary>
        /// <param name="name">The name of the property to look for</param>
        /// <returns>The item if found null otherwise</returns>
        public DtoPropertyAttriubteMapping GetByPropertyName(string name)
        {
            return this.GetByPropertyName(name, StringComparison.InvariantCultureIgnoreCase);
        }

        /// <summary>
        /// Gets an item by property name
        /// </summary>
        /// <param name="name">The name of the property to look for</param>        
        /// <param name="comparisonType">The string <see cref="StringComparison"/> type</param>
        /// <returns>The item if found null otherwise</returns>
        public DtoPropertyAttriubteMapping GetByPropertyName(string name, StringComparison comparisonType)
        {
            IEnumerable<DtoPropertyAttriubteMapping> q = from x in this.dict.Values
                                                         where x.PropertyName.Equals(name, comparisonType)
                                                         select x;

            if (q.Any())
                return q.Single();

            return null;
        }

        /// <summary>
        /// Gets an item by attribute name
        /// </summary>
        /// <param name="name">The name of the property to look for</param>
        /// <returns>The item if found null otherwise</returns>
        public DtoPropertyAttriubteMapping GetByAttributeName(string name)
        {
            return this.GetByAttributeName(name, StringComparison.InvariantCultureIgnoreCase);
        }

        /// <summary>
        /// Gets an item by attribute name
        /// </summary>
        /// <param name="name">The name of the property to look for</param>
        /// <param name="comparisonType">The string <see cref="StringComparison"/> type</param>
        /// <returns>The item if found null otherwise</returns>
        public DtoPropertyAttriubteMapping GetByAttributeName(string name, StringComparison comparisonType)
        {
            IEnumerable<DtoPropertyAttriubteMapping> q = from x in this.dict.Values
                                                         where x.AttributeName.Equals(name, comparisonType)
                                                         select x;

            if (q.Any())
                return q.Single();

            return null;
        }
    }
}