using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using Newtonsoft.Json;
using Newtonsoft.Json.Linq;
using System.Reflection;

/// <summary>
/// 反射相关工具集
/// </summary>
public partial class Utils
{
    /// <summary>
    /// C#对象根据属性名获取值
    /// </summary>
    /// <param name="csObj"></param>
    /// <param name="property"></param>
    /// <returns></returns>
    public static object GetPropertyValue(object csObj, string property)
    {
        PropertyInfo pinfo = csObj.GetType().GetProperty(property);
        if (pinfo == null) return null;
        return pinfo.GetValue(csObj, null);
    }

    /// <summary>
    /// C#对象根据属性名赋值
    /// </summary>
    /// <param name="csObj"></param>
    /// <param name="property"></param>
    /// <param name="value"></param>
    public static void SetPropertyValue(object csObj, string property, object value)
    {
        if (value == null) return;
        PropertyInfo pinfo = csObj.GetType().GetProperty(property);
        if (pinfo != null)
        {
            if (pinfo.PropertyType == typeof(string))
            {
                pinfo.SetValue(csObj, value.ToString(), null);
            }
            else if (pinfo.PropertyType == typeof(float))
            {
                pinfo.SetValue(csObj, float.Parse(value.ToString()), null);
            }
            else if (pinfo.PropertyType == typeof(double))
            {
                pinfo.SetValue(csObj, double.Parse(value.ToString()), null);
            }
            else if (pinfo.PropertyType == typeof(int))
            {
                pinfo.SetValue(csObj, int.Parse(value.ToString()), null);
            }
            else if (pinfo.PropertyType == typeof(long))
            {
                pinfo.SetValue(csObj, long.Parse(value.ToString()), null);
            }
            else
            {
                csObj.GetType().GetProperty(property).SetValue(csObj, value, null);
            }
        }
    }

    /// <summary>
    /// C#获取对象全部属性名
    /// </summary>
    /// <param name="csObj"></param>
    /// <returns></returns>
    public static List<string> GetProperties(object csObj)
    {
        List<string> properties = new List<string>();
        foreach (PropertyInfo pinfo in csObj.GetType().GetProperties())
        {
            properties.Add(pinfo.Name);
        }
        return properties;
    }

    /// <summary>
    /// C#通过反射机制初始化特定类型对象
    /// </summary>
    /// <typeparam name="T"></typeparam>
    /// <param name="jObj"></param>
    /// <returns></returns>
    public static T LoadClass<T>(JObject jObj) where T : new()
    {
        return LoadObject(jObj, new T());
    }

    /// <summary>
    /// C#通过反射机制初始化特定类型对象
    /// </summary>
    /// <typeparam name="T"></typeparam>
    /// <param name="token"></param>
    /// <returns></returns>
    public static T LoadClass<T>(JToken token) where T : new()
    {
        return LoadObject(token, new T());
    }

    /// <summary>
    /// C#通过属性表反射原理从JObject加载实例对象
    /// </summary>
    /// <typeparam name="T"></typeparam>
    /// <param name="jObj"></param>
    /// <param name="csObj"></param>
    /// <returns></returns>
    public static T LoadObject<T>(JObject jObj, T csObj)
    {
        foreach (KeyValuePair<string, JToken> pair in jObj)
        {
            SetPropertyValue(csObj, pair.Key, pair.Value.ToString());
        }
        return csObj;
    }

    /// <summary>
    /// C#通过属性表反射原理从JToken加载实例对象
    /// </summary>
    /// <typeparam name="T"></typeparam>
    /// <param name="token"></param>
    /// <param name="csObj"></param>
    /// <returns></returns>
    public static T LoadObject<T>(JToken token, T csObj)
    {
        JObject jObj = JObject.Parse(token.ToString());
        return LoadObject(jObj, csObj);
    }

    /// <summary>
    /// C#通过属性表反射原理从JArry加载数组
    /// </summary>
    /// <typeparam name="T"></typeparam>
    /// <param name="array"></param>
    /// <returns></returns>
    public static List<T> LoadArray<T>(JArray array) where T : new()
    {
        List<T> ret = new List<T>();
        foreach (JToken token in array)
        {
            ret.Add(LoadClass<T>(token));
        }
        return ret;
    }

    /// <summary>
    /// C#通过属性表反射原理从JArry加载数组
    /// </summary>
    /// <typeparam name="T"></typeparam>
    /// <param name="token"></param>
    /// <returns></returns>
    public static List<T> LoadArray<T>(JToken token) where T : new()
    {
        return LoadArray<T>(JArray.Parse(token.ToString()));
    }

    /*
    /// <summary>
    /// C#原生对象克隆
    /// </summary>
    /// <typeparam name="T"></typeparam>
    /// <param name="obj"></param>
    /// <returns></returns>
    public static T CloneObject<T>(T obj) where T : new()
    {
        T desObj = new T();
        foreach (PropertyInfo pinfo in desObj.GetType().GetProperties())
        {
            SetPropertyValue(desObj, pinfo.Name, GetPropertyValue(obj, pinfo.Name));
        }
        return desObj;
    }
     * */

    /// <summary>
    /// C#原生对象属性表映射加载
    /// </summary>
    /// <param name="surObj">源对象</param>
    /// <param name="desObj">目标对象</param>
    public static void LoadObject(object surObj, object desObj)
    {
        foreach (PropertyInfo pinfo in desObj.GetType().GetProperties())
        {
            SetPropertyValue(desObj, pinfo.Name, GetPropertyValue(surObj, pinfo.Name));
        }
    }

    /// <summary>
    /// List随机其中一个元素
    /// </summary>
    /// <typeparam name="T"></typeparam>
    /// <param name="array"></param>
    /// <returns></returns>
    public static T ArrayRandom<T>(List<T> array)
    {
        int count = array.Count;
        int ran = UnityEngine.Random.Range(0, count);
        return array[ran];
    }
}