COM3D2.MeidoPhotoStudio/src/MeidoPhotoStudio.Plugin/Utility.cs

using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Text.RegularExpressions;
using Ionic.Zlib;
using UnityEngine;

namespace MeidoPhotoStudio.Plugin;

public static class Utility
{
    public enum ModKey { Control, Shift, Alt }

    private const BindingFlags bindingFlags = BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic
        | BindingFlags.Static;

    public static readonly BepInEx.Logging.ManualLogSource Logger =
        BepInEx.Logging.Logger.CreateLogSource(MeidoPhotoStudio.pluginName);

    public static string Timestamp =>
        $"{DateTime.Now:yyyyMMddHHmmss}";

    public static Vector3 MousePosition =>
        mousePosition.Position;

    internal static readonly byte[] pngHeader = { 137, 80, 78, 71, 13, 10, 26, 10 };
    internal static readonly byte[] pngEnd = System.Text.Encoding.ASCII.GetBytes("IEND");
    internal static readonly Regex guidRegEx = new(
        @"^[a-f0-9]{8}(\-[a-f0-9]{4}){3}\-[a-f0-9]{12}$", RegexOptions.IgnoreCase
    );
    internal static readonly GameObject mousePositionGo;
    internal static readonly MousePosition mousePosition;

    static Utility()
    {
        mousePositionGo = new();
        mousePosition = mousePositionGo.AddComponent<MousePosition>();
    }

    public static void LogInfo(object data) =>
        Logger.LogInfo(data);

    public static void LogMessage(object data) =>
        Logger.LogMessage(data);

    public static void LogWarning(object data) =>
        Logger.LogWarning(data);

    public static void LogError(object data) =>
        Logger.LogError(data);

    public static void LogDebug(object data) =>
        Logger.LogDebug(data);

    public static int Wrap(int value, int min, int max)
    {
        max--;

        return value < min ? max : value > max ? min : value;
    }

    public static int GetPix(int num) =>
        (int)((1f + (Screen.width / 1280f - 1f) * 0.6f) * num);

    public static float Bound(float value, float left, float right) =>
        left > (double)right ? Mathf.Clamp(value, right, left) : Mathf.Clamp(value, left, right);

    public static int Bound(int value, int left, int right) =>
        left > right ? Mathf.Clamp(value, right, left) : Mathf.Clamp(value, left, right);

    public static Texture2D MakeTex(int width, int height, Color color)
    {
        var colors = new Color32[width * height];

        for (var i = 0; i < colors.Length; i++)
            colors[i] = color;

        var texture2D = new Texture2D(width, height);

        texture2D.SetPixels32(colors);
        texture2D.Apply();

        return texture2D;
    }

    public static FieldInfo GetFieldInfo<T>(string field) =>
        typeof(T).GetField(field, bindingFlags);

    public static TValue GetFieldValue<TType, TValue>(TType instance, string field)
    {
        var fieldInfo = GetFieldInfo<TType>(field);

        return fieldInfo is null || !fieldInfo.IsStatic && instance == null
            ? default
            : (TValue)fieldInfo.GetValue(instance);
    }

    public static void SetFieldValue<TType, TValue>(TType instance, string name, TValue value) =>
        GetFieldInfo<TType>(name).SetValue(instance, value);

    public static PropertyInfo GetPropertyInfo<T>(string field) =>
        typeof(T).GetProperty(field, bindingFlags);

    public static TValue GetPropertyValue<TType, TValue>(TType instance, string property)
    {
        var propertyInfo = GetPropertyInfo<TType>(property);

        return propertyInfo is null
            ? default
            : (TValue)propertyInfo.GetValue(instance, null);
    }

    public static void SetPropertyValue<TType, TValue>(TType instance, string name, TValue value) =>
        GetPropertyInfo<TType>(name).SetValue(instance, value, null);

    public static bool AnyMouseDown() =>
        Input.GetMouseButtonDown(0) || Input.GetMouseButtonDown(1) || Input.GetMouseButtonDown(2);

    public static string ScreenshotFilename()
    {
        var screenShotDir = Path.Combine(
            GameMain.Instance.SerializeStorageManager.StoreDirectoryPath, "ScreenShot"
        );

        if (!Directory.Exists(screenShotDir))
            Directory.CreateDirectory(screenShotDir);

        return Path.Combine(screenShotDir, $"img{Timestamp}.png");
    }

    public static string TempScreenshotFilename() =>
        Path.Combine(Path.GetTempPath(), $"cm3d2_{Guid.NewGuid()}.png");

    public static void ShowMouseExposition(string text, float time = 2f)
    {
        var mouseExposition = MouseExposition.GetObject();

        mouseExposition.SetText(text, time);
    }

    public static bool IsGuidString(string guid) =>
        !string.IsNullOrEmpty(guid) && guid.Length is 36 && guidRegEx.IsMatch(guid);

    public static string HandItemToOdogu(string menu)
    {
        menu = menu.Substring(menu.IndexOf('_') + 1);
        menu = menu.Substring(0, menu.IndexOf("_i_.menu", StringComparison.OrdinalIgnoreCase));
        menu = $"odogu_{menu}";

        return menu;
    }

    public static void FixGameObjectScale(GameObject go)
    {
        var scale = go.transform.localScale;
        var largest = Mathf.Max(scale.x, Mathf.Max(scale.y, scale.z));

        go.transform.localScale = Vector3.one * (float)Math.Round(largest, 3);
    }

    public static string SanitizePathPortion(string path)
    {
        var invalid = Path.GetInvalidFileNameChars();

        path = path.Trim();
        path = string.Join("_", path.Split(invalid)).Replace(".", "").Trim('_');

        return path;
    }

    public static string GP01FbFaceHash(TMorph face, string hash)
    {
        if (face.bodyskin.PartsVersion >= 120 && hash is not "eyeclose3" && hash.StartsWith("eyeclose"))
        {
            if (hash is "eyeclose")
                hash += '1';

            hash += TMorph.crcFaceTypesStr[(int)face.GetFaceTypeGP01FB()];
        }

        return hash;
    }

    public static void ResizeToFit(Texture2D texture, int maxWidth, int maxHeight)
    {
        var width = texture.width;
        var height = texture.height;

        if (width == maxWidth && height == maxHeight)
            return;

        var scale = Mathf.Min(maxWidth / (float)width, maxHeight / (float)height);

        width = Mathf.RoundToInt(width * scale);
        height = Mathf.RoundToInt(height * scale);
        TextureScale.Bilinear(texture, width, height);
    }

    public static bool BytesEqual(byte[] buffer, byte[] other)
    {
        if (buffer.Length != other.Length)
            return false;

        for (var i = 0; i < buffer.Length; i++)
            if (buffer[i] != other[i])
                return false;

        return true;
    }

    public static bool IsPngFile(Stream stream)
    {
        var buffer = new byte[8];

        stream.Read(buffer, 0, 8);

        return BytesEqual(buffer, pngHeader);
    }

    public static bool SeekPngEnd(Stream stream)
    {
        var buffer = new byte[8];

        stream.Read(buffer, 0, 8);

        if (!BytesEqual(buffer, pngHeader))
            return false;

        buffer = new byte[4];

        do
        {
            stream.Read(buffer, 0, 4);

            if (BitConverter.IsLittleEndian)
                Array.Reverse(buffer);

            var length = BitConverter.ToUInt32(buffer, 0);

            stream.Read(buffer, 0, 4);
            stream.Seek(length + 4L, SeekOrigin.Current);
        } while (!BytesEqual(buffer, pngEnd));

        return true;
    }

    public static void WriteToFile(string name, IEnumerable<string> list)
    {
        if (Path.GetExtension(name) is not ".txt")
            name += ".txt";

        File.WriteAllLines(Path.Combine(Constants.configPath, name), list.ToArray());
    }

    public static void WriteToFile(string name, byte[] data) =>
        File.WriteAllBytes(Path.Combine(Constants.configPath, name), data);
}

public class MousePosition : MonoBehaviour
{
    public Vector3 Position =>
        mousePosition;

    private Vector3 mousePosition;

    private void Awake()
    {
        DontDestroyOnLoad(this);

        mousePosition = Input.mousePosition;
    }

    private void Update()
    {
        if (Input.GetMouseButton(0))
        {
            mousePosition.x += Input.GetAxis("Mouse X") * 20;
            mousePosition.y += Input.GetAxis("Mouse Y") * 20;
        }
        else
            mousePosition = Input.mousePosition;
    }
}

public static class KeyValuePairExtensions
{
    public static void Deconstruct<TKey, TValue>(this KeyValuePair<TKey, TValue> kvp, out TKey key, out TValue value)
    {
        key = kvp.Key;
        value = kvp.Value;
    }
}

public static class StreamExtensions
{
    public static void CopyTo(this Stream stream, Stream outStream)
    {
        var buf = new byte[1024 * 32];

        int length;

        while ((length = stream.Read(buf, 0, buf.Length)) > 0)
            outStream.Write(buf, 0, length);
    }

    public static MemoryStream Decompress(this MemoryStream stream)
    {
        var dataMemoryStream = new MemoryStream();

        using var compressionStream = new DeflateStream(stream, CompressionMode.Decompress, true);

        compressionStream.CopyTo(dataMemoryStream);
        compressionStream.Flush();

        dataMemoryStream.Position = 0L;

        return dataMemoryStream;
    }

    public static DeflateStream GetCompressionStream(this MemoryStream stream) =>
        new(stream, CompressionMode.Compress);
}

public static class CameraUtility
{
    public static CameraMain MainCamera =>
        GameMain.Instance.MainCamera;

    public static UltimateOrbitCamera UOCamera { get; } =
        GameMain.Instance.MainCamera.GetComponent<UltimateOrbitCamera>();

    public static void StopSpin()
    {
        Utility.SetFieldValue(UOCamera, "xVelocity", 0f);
        Utility.SetFieldValue(UOCamera, "yVelocity", 0f);
    }

    public static void StopMovement() =>
        MainCamera.SetTargetPos(MainCamera.GetTargetPos());

    public static void StopAll()
    {
        StopSpin();
        StopMovement();
    }

    public static void ForceCalcNearClip(this CameraMain camera)
    {
        camera.StopAllCoroutines();
        camera.m_bCalcNearClip = false;
        camera.camera.nearClipPlane = 0.01f;
    }

    public static void ResetCalcNearClip(this CameraMain camera)
    {
        if (camera.m_bCalcNearClip)
            return;

        camera.StopAllCoroutines();
        camera.m_bCalcNearClip = true;
        camera.Start();
    }
}

public static class BinaryExtensions
{
    public static string ReadNullableString(this BinaryReader binaryReader) =>
        binaryReader.ReadBoolean()
            ? binaryReader.ReadString()
            : null;

    public static void WriteNullableString(this BinaryWriter binaryWriter, string str)
    {
        binaryWriter.Write(str is not null);

        if (str is not null)
            binaryWriter.Write(str);
    }

    public static void Write(this BinaryWriter binaryWriter, Vector3 vector3)
    {
        binaryWriter.Write(vector3.x);
        binaryWriter.Write(vector3.y);
        binaryWriter.Write(vector3.z);
    }

    public static void WriteVector3(this BinaryWriter binaryWriter, Vector3 vector3)
    {
        binaryWriter.Write(vector3.x);
        binaryWriter.Write(vector3.y);
        binaryWriter.Write(vector3.z);
    }

    public static Vector2 ReadVector2(this BinaryReader binaryReader) =>
        new(binaryReader.ReadSingle(), binaryReader.ReadSingle());

    public static Vector3 ReadVector3(this BinaryReader binaryReader) =>
        new(binaryReader.ReadSingle(), binaryReader.ReadSingle(), binaryReader.ReadSingle());

    public static Vector4 ReadVector4(this BinaryReader binaryReader) =>
        new(binaryReader.ReadSingle(), binaryReader.ReadSingle(), binaryReader.ReadSingle(),
                binaryReader.ReadSingle()
           );

    public static void Write(this BinaryWriter binaryWriter, Quaternion quaternion)
    {
        binaryWriter.Write(quaternion.x);
        binaryWriter.Write(quaternion.y);
        binaryWriter.Write(quaternion.z);
        binaryWriter.Write(quaternion.w);
    }

    public static void WriteQuaternion(this BinaryWriter binaryWriter, Quaternion quaternion)
    {
        binaryWriter.Write(quaternion.x);
        binaryWriter.Write(quaternion.y);
        binaryWriter.Write(quaternion.z);
        binaryWriter.Write(quaternion.w);
    }

    public static Quaternion ReadQuaternion(this BinaryReader binaryReader) =>
        new(binaryReader.ReadSingle(), binaryReader.ReadSingle(), binaryReader.ReadSingle(), binaryReader.ReadSingle());

    public static void Write(this BinaryWriter binaryWriter, Color colour)
    {
        binaryWriter.Write(colour.r);
        binaryWriter.Write(colour.g);
        binaryWriter.Write(colour.b);
        binaryWriter.Write(colour.a);
    }

    public static void WriteColour(this BinaryWriter binaryWriter, Color colour)
    {
        binaryWriter.Write(colour.r);
        binaryWriter.Write(colour.g);
        binaryWriter.Write(colour.b);
        binaryWriter.Write(colour.a);
    }

    public static Color ReadColour(this BinaryReader binaryReader) =>
        new(binaryReader.ReadSingle(), binaryReader.ReadSingle(), binaryReader.ReadSingle(), binaryReader.ReadSingle());

    public static Matrix4x4 ReadMatrix4x4(this BinaryReader binaryReader)
    {
        Matrix4x4 matrix = default;

        for (var i = 0; i < 16; i++)
            matrix[i] = binaryReader.ReadSingle();

        return matrix;
    }
}