using UnityEngine;

/// <summary>
/// 继承自这个类的单例同样也是MonoBehaviour，可以挂载到物体上，并且会将该物体放置DontDestroyOnLoad内
/// 如果项目本身就使用多场景控制物件，可以不用调用DontDestroyOnLoad方法
/// </summary>
/// <typeparam name="T"></typeparam>
public class MonoSingleton<T> : MonoBehaviour where T : Component
{
    private static T _instance = null;

    public static T Instance
    {
        get
        {
            if (_instance == null)
            {
                _instance = FindObjectOfType<T>();
                if (_instance == null)
                {
                    GameObject obj = new GameObject(typeof(T).Name, new[] {typeof(T)});
                    DontDestroyOnLoad(obj);
                    _instance = obj.GetComponent<T>();
                    (_instance as IInitable)?.Init();
                }
                else
                {
                    Debug.LogWarning("Instance is already exist!");
                }
            }

            return _instance;
        }
    }

    /// <summary>
    /// 继承Mono单例的类如果写了Awake方法，需要在Awake方法最开始的地方调用一次base.Awake()，来给_instance赋值
    /// </summary>
    protected void Awake()
    {
        _instance = this as T;
        DontDestroyOnLoad(this.transform.root);
    }
}

/// <summary>
/// 继承自这个类的单例不是MonoBehaviour，无法怪载到物体上
/// </summary>
/// <typeparam name="T"></typeparam>
public class Singleton<T> where T : new()
{
    private static T _instance;

    public static T Instance
    {
        get
        {
            if (_instance == null)
            {
                _instance = new T();
                (_instance as IInitable)?.Init();
            }

            return _instance;
        }
    }
}

int[] numbers = { 5, 2, 8, 3, 1 };
Array.Sort(numbers); // 排序后：{1, 2, 3, 5, 8}

string[] names = { "Alice", "Bob", "Charlie" };
Array.Sort(names, (x, y) => y.Length.CompareTo(x.Length)); // 按字符串长度降序

class Person
{
    public string Name { get; set; }
    public int Age { get; set; }
}

var people = new List<Person>
{
    new Person { Name = "Alice", Age = 30 },
    new Person { Name = "Bob", Age = 25 },
    new Person { Name = "Charlie", Age = 25 }
};

// 按年龄升序，再按姓名升序
people.Sort((x, y) =>
{
    int ageComparison = x.Age.CompareTo(y.Age);
    return ageComparison == 0 ? x.Name.CompareTo(y.Name) : ageComparison;
});

List<int> numbers = new List<int> { 10, 9, 8, 7, 6, 5, 4, 3, 2, 1 };
// 仅对索引 2 到 6 进行排序
numbers.Sort(2, 5, Comparer<int>.Default); // {10, 9, 3, 4, 5, 6, 8, 7, 2, 1}

public class Item{}
public class ItemA : Item{}
public class ItemB : Item{}

public class Test : MonoBehaviour
{
    private Test<Item> test = new();
    private void Awake()
    {
        Debug.Log($"{nameof(Item)}  {nameof(ItemA)}  {nameof(ItemB)}");		// Item  ItemA  ItemB
        Debug.Log($"{typeof(Item).Name}  {typeof(ItemA).Name}  {typeof(ItemB).Name}");	// 同上
        test.FuncTO<Item>();		// TO Item
        test.FuncTO<ItemA>();		// TO ItemA
        test.FuncTO<ItemB>();		// TO ItemB
        test.FuncT(new Item());		// T Item Item
        test.FuncT(new ItemA());	// T Item ItemA
        test.FuncT(new ItemB());	// T Item ItemB
    }
}

public class Test<T>
{
    public Test()
    {
        Debug.Log($"构造函数: {nameof(T)} {typeof(T).Name}");	// T Item
    }
    
    public void FuncTO<TO>()
    {
        Debug.Log($"FuncTO: {nameof(TO)} {typeof(TO).Name}");
    }

    public void FuncT(T item)
    {
        Debug.Log($"FuncT: {nameof(T)} {typeof(T).Name} {item.GetType().Name}");
    }
}

public class ChainedClass
{
    public string name;
    public int age;

    public ChainedClass(string name)		// 通过构造函数赋值
    {
        this.name = name;
    }

    public ChainedClass SetAge(int age)		// 通过链式方法赋值
    {
        this.age = age;
        return this;
    }
}

ChainedClass cc = new ChainedClass("coffee")		// 构造函数
    .SetAge(10);									// 链式方法
Console.WriteLine(cc.Age);		// 输出10
cc.SetAge(20);										// 再次使用链式方法
Console.WriteLine(cc.Age);		// 输出20

public static class DotsExtensions
{
    public static float3 V2ToF3(this Vector2 v2) => new float3(v2.x, v2.y, 0);
}

public struct CustomStruct		// 结构体或类都可以
{
    public float X, Y, Z;

    public static CustomStruct operator +(CustomStruct a, CustomStruct b)
    {
        return new CustomStruct { X = a.X + b.X, Y = a.Y + b.Y, Z = a.Z + b.Z };
    }

    public override string ToString()
    {
        return $"({X}, {Y}, {Z})";
    }
}

CustomStruct cs1 = new CustomStruct() { X = 1, Y = 2, Z = 3 };
CustomStruct cs2 = new CustomStruct() { X = 4, Y = 5, Z = 6 };

Console.WriteLine($"cs1 + cs2 = {cs1 + cs2}");		// 运算时自动调用`operator +`方法

public struct PlayerMoveInput
{
    public float Value;

    public static implicit operator PlayerMoveInput(float value)
    {
        return new PlayerMoveInput() { Value = value };
    }

    public static implicit operator float(PlayerMoveInput input)
    {
        return input.Value;
    }
}

var input = new PlayerMoveInput();

input = 1;			// 隐式转换 float -> PlayerMoveInput

// 需要注意我们这里并没有重写ToString，但是依然输出了1，一般是输出`PlayerMoveInput`
Console.WriteLine(input);   // 隐式转换 PlayerMoveInput -> float

public class PlayerMoveInput
{
    public float Value;

    public static explicit operator PlayerMoveInput(float value)
    {
        return new PlayerMoveInput() { Value = value };
    }

    public static explicit operator float(PlayerMoveInput input)
    {
        return input.Value;
    }
}

var input = new PlayerMoveInput();

input = (PlayerMoveInput)1;      // 显示转换 float -> PlayerMoveInput

Console.WriteLine((float)input);   // 输出1 显式转换 PlayerMoveInput -> float

class Manager
{
    public static Manager Instance = new Manager();		// 单例类
    private Manager() { }								// 私有化构造函数
}

public interface IInterface
{
    void Add();
    void Remove();
    int Get();
}

class ReadOnlyClass : IInterface						// 创建一个只能读取，不能更改内容的类
{
    void IInterface.Add()													// 显示接口实现，外界无法访问
    {
        throw new NotSupportedException("Readonly Not Supported Add");		// 就算访问了，也会抛异常
    }

    void IInterface.Remove()												// 显示接口实现，外界无法访问
    {
        throw new NotSupportedException("Readonly Not Supported Remove");	// 就算访问了，也会抛异常
    }

    public int Get()					// 正常访问Get()方法
    {
        return 1;
    }
}

class Manager
{
    private Dictionary<string, string> _uiStack;
    public ReadOnlyDictionary<string, string> UIStack { get; }		// 注意这里没有使用set，完全杜绝了修改的可能
    public Manager()
    {
        UIStack = new ReadOnlyDictionary<string, string>(_uiStack);
    }
}

public interface IAnimal
{
    public int age { get; set; }
    public string name { get; set; }
}
public class Human : IAnimal
{
    public int age { get; set; }
    public string name { get; set; }

    public Human(int age, string name)
    {
        this.age = age;
        this.name = name;
    }
}

public class ReverseComparer<T> : IComparer<T>
{
    public static readonly ReverseComparer<T> Instance = new ReverseComparer<T>();	// 饿汉单例
    private ReverseComparer() { }				// 私有构造函数，不需要用户创建实例
    public int Compare(T x, T y) => Comparer<T>.Default.Compare(y, x);	// 实现接口，定义比较方法，注意参数换位置了
}			// 如果想要从小到大排列，再换回来就好了

public class HumanSelector : SortedList<int, IAnimal>		// 继承`SortedList<int, IAnimal>`基类
{
   public HumanSelector() : base(ReverseComparer<int>.Instance) {}	// 构造函数，并将参数传递给基类的构造函数
   public void Add<T>(T man)					// 定义了一个泛型方法
       where T : IAnimal						// 这个泛型类必须是来自IAnimal接口的
       => Add(man.age, man);					// 调用了基类的Add方法
}

Human A = new Human(20, "A");
Human B = new Human(25, "B");
Human C = new Human(30, "C");
HumanSelector humanSelector = new HumanSelector();		// 实例化排序列表
humanSelector.Add(C);
humanSelector.Add(A);
humanSelector.Add(B);
humanSelector.ToList().ForEach(man => { Console.WriteLine($"{man.Key}, {man.Value.name}"); });

// 30, C
// 25, B
// 20, A

List<int> list = new List<int>(){ 1, 2, 3, 4, 5 };
for (int i = list.Count - 1; i >= 0; i--)
{
    if (list[i] >= 4)
    {
        list.RemoveAt(i);
    }
}

private int _count;							// 字段：内部使用
public int Count							// 属性：外部可读可写
{
    get => _count;
    set => _count = value / 2;				// 可自定义读写需求
}

private int _length;
public int Length => _length;					// 属性：公共只读

public static int TotalCount { get; set; }		// 属性：可读可写，这种方式实际上也隐式的创建了一个字段，如下图

[SerializeField]
private bool _run;							// 内部使用
public ref bool Run => ref _run;		// 外部使用，这里实际上是直接访问的_run这个字段

public string this[int index]
{
    get => _items[index];
    set => _items[index] = value;
}

public class CustomizeDict
{
    private Dictionary<string, string> _data = new Dictionary<string, string>();
    public object this[string key]
    {
        get => _data[key];
        set
        {
            if (_data.ContainsKey(key))
                _data[key] = value.ToString();
            else
                _data.Add(key, value.ToString());
            UpdateContent();
        }
    }
}

CustomizeDict["speed"] = 500;

int number = defaule;   // 默认值为0
double amount = default；   // 默认值为0
bool flag = default;    // 默认值为false

string text = default;		// 默认值为null
List<int> numbers = defalut;   // 默认值为null

var str = @"HelloWorld";

Console.WriteLine(str[1..5]);			// "ello"

Console.WriteLine(str[^1]);				// "d"
Console.WriteLine(str[..^0]);			// "HelloWorld"

Console.WriteLine(str[6..^2]);			// "or"
Console.WriteLine(str[^5..^1]);			// "Worl"
Console.WriteLine(str[^7..8]);			// "loWor"

var ran = new Random();
int i = ran.Next(20);	// 在0-20之间随机选一个数

if (i is < 10 and > 0)
    Console.WriteLine("i介于0和10之间");

var list = new List<int>() { 5, 2, 7, 1, 9, 4 };		// 定义一个int列表
IEnumerable<int> temp = list.Where(i => i > 3);			// 获取这个列表中大于3的元素的IEnumerable<int>枚举
list = temp.ToList();									// 将IEnumerable<int>枚举转换成列表
list.ForEach(Console.WriteLine);						// 使用方法组的方式逐个打印结果

var list = new List<int>() { 5, 2, 7, 1, 9, 4 };
foreach (var j in list.Where(i => i > 3))		// 提一嘴，里的i和j其实是分隔开的，并不会相互影响，j可以写成i
{
    Console.WriteLine(j);
}

int count = 100;
Console.WriteLine("我今天吃了{0}顿", count)
Console.WriteLine($"我今天吃了{count}顿")

double i = 32.53728012341241562;

Console.WriteLine($"我的资产为{i, 10:F4}为所欲为");		// "我的资产为   32.5373为所欲为"

float value = 546.5198;
string str = $"{value:0.##}";	// 保留两位小数，当小数不足时不显示（如，1.2 => 1.2 而不是1.20）

DateTime date = DateTime.Now;
Console.WriteLine($"{date:yyyy年mm月dd日 hh:mm:ss tt zzz}");

TimeSpan timeSpan = endTime - DateTime.Now;
timeSpan.ToString(@"d\天hh\时mm\分");			// '\'必不可少，表示后面一位是普通字符
timeSpan.ToString(@"d\:h\:mm);

// 1天03时15分
// 1:3:15分

private void Update()
{
    Profiler.BeginSample("Invoke Action");
    for (int i = 0; i < 1000000; i++)
    {
        actionA?.Invoke();
    }
    Profiler.EndSample();

    Profiler.BeginSample("Invoke default Action");
    for (int i = 0; i < 1000000; i++)
    {
        actionB.Invoke();
    }
    Profiler.EndSample();
}

private DOGetter<float> _radiusGetter;	// 其实就是一个获取数值的委托
private DOSetter<float> _radiusSetter;	// 其实就是一个设置数值的委托

private void Awake()
{
    _radiusGetter = () => _light.pointLightOuterRadius;		// 定义委托
    _radiusSetter = newValue => _light.pointLightOuterRadius = newValue;	// 定义委托

    InputReader.Instance.AmplifyPressedEvent += AmplifyLight;	// 设置触发事件
}

private void AmplifyLight()
{
    DOTween.To(_radiusGetter, _radiusSetter, newValue, duration);// 执行DOTween动画——改变_radiusGetter获取的值
}

// 可以让 m_tmp999 的文字从 currentView 在1.2秒内平滑的变成 realCoin
// 从断点来看，第一个委托只有在第一次获取初始值时才会执行一次就不会再执行了；第二个委托每帧都会执行一次，value的值会慢慢接近 realCoin
// realCoin 与 currentView 的大小没有影响，如果 realCoin 大，那么就是从小到大的变化；如果 realCoin 小，那么就是从大到小的变化
var realCoin = LevelManager.Instance.LevelDataCollection.Coin;
var currentView = int.Parse(m_tmp999.text);
DOTween.To(() => currentView,
           value =>
           {
               m_tmp999.text = value.ToString();
           }, realCoin, 1.2f);

private Sequence bounceSequence;

bounceSequence = DOTween.Sequence()
    // 添加一个向下移动的Tweener
    .Append(rect.DOAnchorPosY(rect.anchoredPosition.y - 150f, .1f).SetEase(Ease.OutQuad))
    // 添加一个还原的Tweener
    .Append(rect.DOAnchorPosY(rect.anchoredPosition.y, .2f).SetEase(Ease.OutQuad))
    .Pause()
    .SetAutoKill(false);

public void OnPointerClick(PointerEventData eventData)
{
    bounceSequence.Restart();	// 使用Restart()，表示这是一个可重复触发的动画
}

private Tweener amplifyTween;

amplifyTween = rect.DOScale(1.2f, 0.2f).SetAutoKill(false).Pause();

public void OnPointerEnter(PointerEventData eventData)
{
    amplifyTween.PlayForward();		// 鼠标进入时，放大图片
}

public void OnPointerExit(PointerEventData eventData)
{
    amplifyTween.PlayBackwards();		// 鼠标离开时，倒放动画，即还原
}

transform.DOKill();
transform.RectTransform().DOKill();

tween.SetUpdate(true);

// 绝对位置，若当前坐标（1,0,0），即从5运动到1
transform.DOMoveX(5, 1).From();
transform.DOMoveX(5, 1).From(false);
 
// 相对位置，若当前坐标（1,0,0），即从6运动到1（6-1=5，相对位移5）
transform.DOMoveX(5, 1).From(true);

#if UNITY_EDITOR
using Sirenix.OdinInspector.Editor.Validation;

[assembly: RegisterValidator(typeof(CameraValidator))]

public class CameraValidator : ValueValidator<PlayerCamera>		// 我们需要检验所有的PlayerCamera脚本
{
    protected override void Validate(ValidationResult result)
    {
        if (Value.player == null)								// 判断PlayerCamera.player是否为空
            result.AddError("Camera need player");
    }
}
#endif
    
public class PlayerCamera : MonoBeahaviour
{
	public Transform player;
}

public Action Action_A;
public event Action Action_B;

public class ClassA : MonoBehaviour		// 这里需要引用UniTask插件，为了简洁我就不写了引用了
{
    public int intA;
    private Action ActionA;

    private void Start()
    {
        ActionA += FuncA;     // 注册事件，并不会执行FuncA方法，只有在A.ActionA被Invoke的时候才会执行FuncA
        UpdateNumber().Forget();
    }

    private async UniTask UpdateNumber()
    {
        while (true)
        {
            await UniTask.Delay(TimeSpan.FromSeconds(.5f), ignoreTimeScale: false);
            // 当第一个实参大于等于11时，返回0；当第一个实参小于0时返回11；其他则返回第一个实参。
            // 这里--在前面，所以是先自减，再将结果当做Repeat的第一个实参
            intA = (int)Mathf.Repeat(--intA, 11);

            if (intA == 0)		//第一个实参为0时也返回0，所以intA是能等于0的
                ActionA?.Invoke();
        }
    }

    private void FuncA()
    {
        Debug.Log($"当前值为: {intA}");
    }
}

public class ClassA : MonoBehaviour
{
	public int intA;
	public Action ActionA;

	private void Start()
	{
		UpdateNumber().Forget();
	}

	private async UniTask UpdateNumber()
	{
		while (true)
		{
			await UniTask.Delay(TimeSpan.FromSeconds(.5f), ignoreTimeScale: false);
			intA = (int)Mathf.Repeat(--intA, 11);
			
			if (intA == 0)
				ActionA?.Invoke();
		}
	}
}

public class ClassB : MonoBehaviour
{
    private string strB = "I am private";    // B内部使用的参数，“我不能暴露出去哦”
    public ClassA A;            // 在Inspector窗口中引用实例

    private void Start()
    {
        A.ActionA += FuncB;     // 注册事件，并不会执行FuncA方法，只有在A.ActionA被Invoke的时候才会执行FuncA
    }

    private void FuncB()
    {
        Debug.Log(strB);
    }
}

public class ClassA : MonoBehaviour
{
    public int intA;
    public Action ActionA;

    private void Start()
    {
        UpdateNumber().Forget();
    }

    private async UniTask UpdateNumber()
    {
        while (true)
        {
            await UniTask.Delay(TimeSpan.FromSeconds(.5f), ignoreTimeScale: false);
            intA = (int)Mathf.Repeat(--intA, 11);

            if (intA == 0)
                ActionA?.Invoke();
        }
    }

    public void FuncA()
    {
        Debug.Log("我只有在intA等于0且B处于激活状态的时候执行");
    }
}

public class ClassB : MonoBehaviour
{
    public ClassA A;

    private void OnEnable()
    {
        A.ActionA += A.FuncA;
    }

    private void OnDisable()
    {
        A.ActionA -= A.FuncA;
    }
}