// Copyright (C) Stichting Deltares 2023. All rights reserved.
// 
// This file is part of the Dam Engine.
// 
// The Dam Engine is free software: you can redistribute it and/or modify
// it under the terms of the GNU Affero General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// 
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU Affero General Public License for more details.
// 
// You should have received a copy of the GNU Affero General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
// 
// All names, logos, and references to "Deltares" are registered trademarks of
// Stichting Deltares and remain full property of Stichting Deltares at all times.
// All rights reserved.

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

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

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

            Add(item.PropertyName, item);
        }

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

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

            AddOrUpdate(propName,
                        new DtoPropertyAttributeMapping
                        {
                            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="DtoPropertyAttributeMapping"/> item to add</param>
        public void AddOrUpdate(DtoPropertyAttributeMapping item)
        {
            if (item == null)
            {
                throw new ArgumentNullException("item");
            }

            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, DtoPropertyAttributeMapping item)
        {
            if (item == null)
            {
                throw new ArgumentNullException("item");
            }

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

            if (!dict.ContainsKey(propName))
            {
                Add(item.PropertyName, item);
            }
            else
            {
                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<DtoPropertyAttributeMapping> coll)
        {
            foreach (DtoPropertyAttributeMapping item in coll)
            {
                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 DtoPropertyAttributeMapping GetByPropertyName(string name)
        {
            return 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 DtoPropertyAttributeMapping GetByPropertyName(string name, StringComparison comparisonType)
        {
            IEnumerable<DtoPropertyAttributeMapping> q = from x in 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 DtoPropertyAttributeMapping GetByAttributeName(string name)
        {
            return 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 DtoPropertyAttributeMapping GetByAttributeName(string name, StringComparison comparisonType)
        {
            IEnumerable<DtoPropertyAttributeMapping> q = from x in dict.Values
                                                         where x.AttributeName.Equals(name, comparisonType)
                                                         select x;

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

            return null;
        }

        #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, DtoPropertyAttributeMapping 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)");
            }

            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 dict.ContainsKey(propName);
        }

        /// <summary>
        /// Gets the containing keys
        /// </summary>
        public ICollection<string> Keys
        {
            get
            {
                return 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 dict.Remove(propName);
        }

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

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

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

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

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

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

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

        /// <summary>
        /// 
        /// </summary>
        public int Count => dict.Count;

        /// <summary>
        /// 
        /// </summary>
        public bool IsReadOnly => false;

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

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

        /// <summary>
        /// 
        /// </summary>
        /// <returns></returns>
        IEnumerator IEnumerable.GetEnumerator()
        {
            return dict.GetEnumerator();
        }

        #endregion
    }
}