using System;
using System.Collections.Generic;

using System.Text;

namespace System.Linq
{
    /// <summary>
    /// 通用比较器
    /// </summary>
    /// <typeparam name="T"></typeparam>
    /// <typeparam name="V"></typeparam>
    public class CommonEqualityComparerHelper<T, V> : IEqualityComparer<T>
    {
        private Func<T, V> keySelector;

        public CommonEqualityComparerHelper(Func<T, V> keySelector)
        {
            this.keySelector = keySelector;
        }

        public bool Equals(T x, T y)
        {
            return EqualityComparer<V>.Default.Equals(keySelector(x), keySelector(y));
        }

        public int GetHashCode(T obj)
        {
            return EqualityComparer<V>.Default.GetHashCode(keySelector(obj));
        }
    }

    /// <summary>
    /// 去重扩展
    /// </summary>
    public static class DistinctExtensions
    {
        /// <summary>
        /// 去重
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <typeparam name="V"></typeparam>
        /// <param name="source"></param>
        /// <param name="keySelector"></param>
        /// <returns></returns>
        public static IEnumerable<T> Distinct<T, V>(this IEnumerable<T> source, Func<T, V> keySelector)
        {
            return source.Distinct(new CommonEqualityComparerHelper<T, V>(keySelector));
        }

        /// <summary>
        /// 交集
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <typeparam name="V"></typeparam>
        /// <param name="source"></param>
        /// <param name="target"></param>
        /// <param name="keySelector"></param>
        /// <returns></returns>
        public static IEnumerable<T> Intersect<T, V>(this IEnumerable<T> source, IEnumerable<T> target, Func<T, V> keySelector)
        {
            return source.Intersect(target, new CommonEqualityComparerHelper<T, V>(keySelector));
        }

        /// <summary>
        /// 差集
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <typeparam name="V"></typeparam>
        /// <param name="source"></param>
        /// <param name="target"></param>
        /// <param name="keySelector"></param>
        /// <returns></returns>
        public static IEnumerable<T> Except<T, V>(this IEnumerable<T> source, IEnumerable<T> target, Func<T, V> keySelector)
        {
            return source.Except(target, new CommonEqualityComparerHelper<T, V>(keySelector));
        }
    }

    /// <summary>
    /// 扩展
    /// </summary>
    public static class QueryableExtensions
    {
        /// <summary>
        /// 带条件的Where
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="query"></param>
        /// <param name="condition"></param>
        /// <param name="predicate"></param>
        /// <returns></returns>
        public static IEnumerable<T> WhereIf<T>(this IEnumerable<T> query, bool condition, Func<T, bool> predicate)
        {
            return condition ? query.Where(predicate) : query;
        }

        /// <summary>
        /// 使 string的Join 变得丝滑
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="query"></param>
        /// <param name="separator"></param>
        /// <returns></returns>
        public static string JoinAsString<T>(this IEnumerable<T> query, string separator)
        {
            return string.Join(separator, query);
        }
    }

    /// <summary>
    /// 
    /// </summary>
    public static class StringExtensions
    {
        /// <summary>
        /// 安全的字符串截取
        /// </summary>
        /// <param name="input"></param>
        /// <param name="startIndex"></param>
        /// <param name="length"></param>
        /// <returns></returns>
        public static string SafeSubstring(this string input, int startIndex, int? length = null)
        {
            if (input == null)
            {
                return string.Empty;
            }

            if (startIndex < 0)
            {
                return string.Empty;
            }

            if (startIndex >= input.Length)
            {
                return string.Empty; // 起始索引超出范围，返回空字符串  
            }

            int endIndex = length.HasValue ? Math.Min(startIndex + length.Value, input.Length) : input.Length;
            return input.Substring(startIndex, endIndex - startIndex);
        }
    }
}