using System;
using System.IO;
using System.Security.Cryptography;
using System.Text;
using UnityEngine;

public static class StoreOwnershipStorage
{
    private const string SecretSeed = "ban_total.store_ownership.v1";
    private const string VaultDirectoryName = ".cache_bridge";
    private const string MainFileName = ".own.dat";
    private const string BackupFileName = ".own.bak";
    private const string TempFileName = ".own.tmp";

    private static string VaultDirectoryPath
    {
        get { return Path.Combine(Application.persistentDataPath, VaultDirectoryName); }
    }

    private static string MainFilePath
    {
        get { return Path.Combine(VaultDirectoryPath, MainFileName); }
    }

    private static string BackupFilePath
    {
        get { return Path.Combine(VaultDirectoryPath, BackupFileName); }
    }

    private static string TempFilePath
    {
        get { return Path.Combine(VaultDirectoryPath, TempFileName); }
    }

    public static bool TryLoad(out StoreOwnershipPayload payload)
    {
        payload = CreateDefaultPayload();

        if (TryReadPayload(MainFilePath, out payload))
        {
            return true;
        }

        if (TryReadPayload(BackupFilePath, out payload))
        {
            TrySave(payload);
            return true;
        }

        return false;
    }

    public static bool TrySave(StoreOwnershipPayload payload)
    {
        try
        {
            Directory.CreateDirectory(VaultDirectoryPath);
            TryHidePath(VaultDirectoryPath);

            var envelopeJson = BuildEnvelopeJson(payload);
            File.WriteAllText(TempFilePath, envelopeJson, Encoding.UTF8);
            TryHidePath(TempFilePath);

            if (File.Exists(MainFilePath))
            {
                File.Copy(MainFilePath, BackupFilePath, true);
                TryHidePath(BackupFilePath);
            }

            File.Copy(TempFilePath, MainFilePath, true);
            TryHidePath(MainFilePath);
            File.Delete(TempFilePath);
            return true;
        }
        catch (Exception ex)
        {
            Debug.LogWarning($"[StoreOwnershipStorage] Save failed: {ex.Message}");
            return false;
        }
    }

    public static StoreOwnershipPayload CreateDefaultPayload()
    {
        return new StoreOwnershipPayload
        {
            version = 1,
            lastUpdatedUtcTicks = DateTime.UtcNow.Ticks,
            entries = new System.Collections.Generic.List<StoreOwnershipEntry>()
        };
    }

    private static bool TryReadPayload(string path, out StoreOwnershipPayload payload)
    {
        payload = CreateDefaultPayload();
        if (!File.Exists(path))
        {
            return false;
        }

        try
        {
            var envelopeJson = File.ReadAllText(path, Encoding.UTF8);
            var envelope = JsonUtility.FromJson<StoreOwnershipEnvelope>(envelopeJson);
            if (envelope == null || string.IsNullOrEmpty(envelope.payload) || string.IsNullOrEmpty(envelope.signature))
            {
                return false;
            }

            var expectedSignature = ComputeSignature(envelope.payload);
            if (!string.Equals(expectedSignature, envelope.signature, StringComparison.Ordinal))
            {
                Debug.LogWarning("[StoreOwnershipStorage] Save signature mismatch. Possible tampering detected.");
                return false;
            }

            var encryptedBytes = Convert.FromBase64String(envelope.payload);
            var plainBytes = XorTransform(encryptedBytes, BuildKeyBytes());
            var payloadJson = Encoding.UTF8.GetString(plainBytes);
            var loadedPayload = JsonUtility.FromJson<StoreOwnershipPayload>(payloadJson);
            if (loadedPayload == null)
            {
                return false;
            }

            payload = loadedPayload;
            return true;
        }
        catch (Exception ex)
        {
            Debug.LogWarning($"[StoreOwnershipStorage] Load failed from '{path}': {ex.Message}");
            return false;
        }
    }

    private static string BuildEnvelopeJson(StoreOwnershipPayload payload)
    {
        payload.lastUpdatedUtcTicks = DateTime.UtcNow.Ticks;
        var payloadJson = JsonUtility.ToJson(payload, false);
        var plainBytes = Encoding.UTF8.GetBytes(payloadJson);
        var encryptedBytes = XorTransform(plainBytes, BuildKeyBytes());
        var payloadBase64 = Convert.ToBase64String(encryptedBytes);

        var envelope = new StoreOwnershipEnvelope
        {
            payload = payloadBase64,
            signature = ComputeSignature(payloadBase64)
        };

        return JsonUtility.ToJson(envelope, false);
    }

    private static string ComputeSignature(string payloadBase64)
    {
        var signText = payloadBase64 + "|" + Application.identifier + "|" + SecretSeed + "|" + SystemInfo.deviceUniqueIdentifier;
        using (var sha = SHA256.Create())
        {
            var bytes = Encoding.UTF8.GetBytes(signText);
            var hash = sha.ComputeHash(bytes);
            return Convert.ToBase64String(hash);
        }
    }

    private static byte[] BuildKeyBytes()
    {
        using (var sha = SHA256.Create())
        {
            var seed = Application.identifier + "|" + SystemInfo.deviceUniqueIdentifier + "|" + SecretSeed;
            return sha.ComputeHash(Encoding.UTF8.GetBytes(seed));
        }
    }

    private static byte[] XorTransform(byte[] source, byte[] key)
    {
        var result = new byte[source.Length];
        for (int i = 0; i < source.Length; i++)
        {
            result[i] = (byte)(source[i] ^ key[i % key.Length]);
        }

        return result;
    }

    private static void TryHidePath(string path)
    {
        try
        {
            if (Application.platform != RuntimePlatform.WindowsEditor && Application.platform != RuntimePlatform.WindowsPlayer)
            {
                return;
            }

            var attributes = File.GetAttributes(path);
            if ((attributes & FileAttributes.Hidden) == 0)
            {
                File.SetAttributes(path, attributes | FileAttributes.Hidden);
            }
        }
        catch
        {
        }
    }
}