CoreAISettingsAssetEditModeTests.cs

using System.Collections.Generic;
using CoreAI.Ai;
using CoreAI.Config;
using CoreAI.Infrastructure.Llm;
using NUnit.Framework;
using UnityEditor;
using UnityEditor.Presets;
using UnityEngine;

namespace CoreAI.Tests.EditMode
{
    /// <summary>
    /// EditMode coverage for <see cref="CoreAISettingsAsset"/> defaults and validation.
    /// </summary>
    public sealed class CoreAISettingsAssetEditModeTests
    {
        [Test]
        public void CreateAsset_WithDefaults_ShouldHaveCorrectValues()
        {
            CoreAISettingsAsset settings = ScriptableObject.CreateInstance<CoreAISettingsAsset>();

            Assert.AreEqual(LlmBackendType.Auto, settings.BackendType);
            Assert.AreEqual(LlmExecutionMode.Auto, settings.ExecutionMode);
            Assert.AreEqual(LlmAutoPriority.LlmUnityFirst, settings.AutoPriority);
            Assert.AreEqual("http://localhost:1234/v1", settings.ApiBaseUrl);
            Assert.AreEqual("", settings.ApiKey);
            Assert.AreEqual("gpt-4o-mini", settings.ModelName);
            Assert.AreEqual(0.1f, settings.Temperature);
            Assert.IsFalse(settings.OverrideTemperature);
            Assert.AreEqual(2048, settings.MaxTokens);
            Assert.AreEqual(120, settings.RequestTimeoutSeconds);
            Assert.AreEqual("", settings.LlmUnityAgentName);
            Assert.AreEqual("Qwen3.5-2B-Q4_K_M.gguf", settings.GgufModelPath);
            Assert.AreEqual(true, settings.LlmUnityDontDestroyOnLoad);
            Assert.AreEqual(120f, settings.LlmUnityStartupTimeoutSeconds);
            Assert.AreEqual(1f, settings.LlmUnityStartupDelaySeconds);
            Assert.AreEqual(false, settings.LlmUnityKeepAlive);
            Assert.AreEqual(1, settings.LlmUnityMaxConcurrentChats);
            Assert.AreEqual(3, settings.MaxLuaRepairRetries);
            Assert.AreEqual(3, settings.MaxToolCallRetries);
            Assert.AreEqual(1, settings.MaxLlmRequestRetries);
            Assert.AreEqual(8192, settings.ContextWindowTokens);
            Assert.AreEqual(false, settings.EnableMeaiDebugLogging);
            Assert.AreEqual(false, settings.EnableHttpDebugLogging);
            Assert.AreEqual(true, settings.EnableStreaming, "Стриминг включён по умолчанию");
            Assert.AreEqual(true, settings.WebGlNativeStreaming, "WebGL native SSE включён по умолчанию");
            Assert.AreEqual(false, settings.SameOriginCredentials);
            Assert.AreEqual(false, settings.OfflineUseCustomResponse);
            Assert.AreEqual("Offline mode: LLM unavailable", settings.OfflineCustomResponse);
            Assert.AreEqual("*", settings.OfflineCustomResponseRoles);
            Assert.AreEqual(0, settings.MaxClientLimitedRequestsPerSession);
            Assert.AreEqual(0, settings.MaxClientLimitedPromptChars);
            Assert.IsTrue(settings.EnableConversationHistorySummarization);
            Assert.AreEqual(0, settings.ConversationHistoryRecentTokenBudgetOverride);
            Assert.AreEqual(0, settings.ConversationRolledSummaryMaxTokens);

            Object.DestroyImmediate(settings);
        }

        [Test]
        public void SerializedObject_HasEnableStreaming_ForInspectorBinding()
        {
            CoreAISettingsAsset settings = ScriptableObject.CreateInstance<CoreAISettingsAsset>();
            SerializedObject so = new(settings);
            SerializedProperty prop = so.FindProperty("enableStreaming");
            Assert.IsNotNull(prop, "CoreAISettingsAssetEditor Essentials binds enableStreaming.");
            Assert.AreEqual(SerializedPropertyType.Boolean, prop.propertyType);
            Object.DestroyImmediate(settings);
        }

        [Test]
        public void EffectiveHttpRequestTimeoutSeconds_IsMinOfHttpAndOrchestratorCeiling()
        {
            CoreAISettingsAsset settings = ScriptableObject.CreateInstance<CoreAISettingsAsset>();
            settings.ConfigureHttpApi("https://api.test.com/v1", "sk", "m", 0.1f, 500, 2048);
            System.Reflection.FieldInfo f = typeof(CoreAISettingsAsset).GetField(
                "llmRequestTimeoutSeconds",
                System.Reflection.BindingFlags.Instance | System.Reflection.BindingFlags.NonPublic);
            Assert.NotNull(f);
            f.SetValue(settings, 45f);
            Assert.AreEqual(45, settings.EffectiveHttpRequestTimeoutSeconds);
            Object.DestroyImmediate(settings);
        }

        [Test]
        public void BackendProperties_ShouldReturnCorrectBooleans()
        {
            CoreAISettingsAsset settings = ScriptableObject.CreateInstance<CoreAISettingsAsset>();

            // По умолчанию Auto
            Assert.AreEqual(LlmBackendType.Auto, settings.BackendType);
            Assert.AreEqual(false, settings.UseHttpApi);
            Assert.AreEqual(true, settings.UseLlmUnity);
            Assert.AreEqual(false, settings.UseOffline);

            // Переключаем на HTTP
            settings.ConfigureHttpApi("https://api.openai.com/v1", "sk-test", "gpt-4");
            Assert.AreEqual(LlmBackendType.OpenAiHttp, settings.BackendType);
            Assert.AreEqual(LlmExecutionMode.ClientOwnedApi, settings.ExecutionMode);
            Assert.AreEqual(true, settings.UseHttpApi);
            Assert.AreEqual(true, settings.UseClientOwnedApi);
            Assert.AreEqual(false, settings.UseLlmUnity);
            Assert.AreEqual(false, settings.UseOffline);

            // Переключаем на Offline
            settings.ConfigureOffline();
            Assert.AreEqual(LlmBackendType.Offline, settings.BackendType);
            Assert.AreEqual(LlmExecutionMode.Offline, settings.ExecutionMode);
            Assert.AreEqual(false, settings.UseHttpApi);
            Assert.AreEqual(false, settings.UseLlmUnity);
            Assert.AreEqual(true, settings.UseOffline);

            // Переключаем на Auto
            settings.ConfigureAuto();
            Assert.AreEqual(LlmBackendType.Auto, settings.BackendType);
            Assert.AreEqual(LlmExecutionMode.Auto, settings.ExecutionMode);
            Assert.AreEqual(false, settings.UseHttpApi);
            Assert.AreEqual(true, settings.UseLlmUnity);
            Assert.AreEqual(false, settings.UseOffline);

            Object.DestroyImmediate(settings);
        }

        [Test]
        public void ConfigureHttpApi_ShouldSetAllValues()
        {
            CoreAISettingsAsset settings = ScriptableObject.CreateInstance<CoreAISettingsAsset>();
            settings.ConfigureHttpApi("https://api.test.com/v1", "sk-123", "test-model", 0.5f, 60, 2048);

            Assert.AreEqual(LlmBackendType.OpenAiHttp, settings.BackendType);
            Assert.AreEqual(LlmExecutionMode.ClientOwnedApi, settings.ExecutionMode);
            Assert.AreEqual("https://api.test.com/v1", settings.ApiBaseUrl);
            Assert.AreEqual("sk-123", settings.ApiKey);
            Assert.AreEqual("test-model", settings.ModelName);
            Assert.AreEqual(0.5f, settings.Temperature);
            Assert.IsTrue(settings.OverrideTemperature);
            Assert.AreEqual(60, settings.RequestTimeoutSeconds);
            Assert.AreEqual(2048, settings.MaxTokens);

            Object.DestroyImmediate(settings);
        }

        [Test]
        public void ConfigureClientLimited_ShouldSetModeAndLimits()
        {
            CoreAISettingsAsset settings = ScriptableObject.CreateInstance<CoreAISettingsAsset>();
            settings.ConfigureClientLimited("https://api.test.com/v1", "sk-123", "test-model", 3, 512);

            Assert.AreEqual(LlmExecutionMode.ClientLimited, settings.ExecutionMode);
            Assert.AreEqual(true, settings.UseHttpApi);
            Assert.AreEqual(true, settings.UseClientLimited);
            Assert.AreEqual(3, settings.MaxClientLimitedRequestsPerSession);
            Assert.AreEqual(512, settings.MaxClientLimitedPromptChars);

            Object.DestroyImmediate(settings);
        }

        [Test]
        public void ConfigureServerManagedApi_ShouldAllowEmptyProviderKey()
        {
            CoreAISettingsAsset settings = ScriptableObject.CreateInstance<CoreAISettingsAsset>();
            settings.ConfigureServerManagedApi("https://game.example.com/v1", "proxy-model");

            Assert.AreEqual(LlmExecutionMode.ServerManagedApi, settings.ExecutionMode);
            Assert.AreEqual(true, settings.UseHttpApi);
            Assert.AreEqual(true, settings.UseServerManagedApi);
            Assert.AreEqual("", settings.ApiKey);
            Assert.AreEqual("https://game.example.com/v1", settings.ApiBaseUrl);

            Object.DestroyImmediate(settings);
        }

        [Test]
        public void ConfigureLlmUnity_ShouldSetAllValues()
        {
            CoreAISettingsAsset settings = ScriptableObject.CreateInstance<CoreAISettingsAsset>();
            settings.ConfigureLlmUnity("MyAgent", "model.gguf", true, 60f, 2f, false);

            Assert.AreEqual(LlmBackendType.LlmUnity, settings.BackendType);
            Assert.AreEqual("MyAgent", settings.LlmUnityAgentName);
            Assert.AreEqual("model.gguf", settings.GgufModelPath);
            Assert.AreEqual(true, settings.LlmUnityKeepAlive);
            Assert.AreEqual(60f, settings.LlmUnityStartupTimeoutSeconds);
            Assert.AreEqual(2f, settings.LlmUnityStartupDelaySeconds);
            Assert.AreEqual(false, settings.LlmUnityDontDestroyOnLoad);

            Object.DestroyImmediate(settings);
        }

        [Test]
        public void OfflineCustomResponse_ShouldMatchRoles()
        {
            CoreAISettingsAsset settings = ScriptableObject.CreateInstance<CoreAISettingsAsset>();

            // По умолчанию — кастомный ответ выключен
            Assert.AreEqual(false, settings.ShouldUseOfflineCustomResponse("Creator"));

            // Включаем с wildcard
            settings.GetType()
                .GetField("offlineUseCustomResponse",
                    System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Instance)
                .SetValue(settings, true);
            Assert.AreEqual(true, settings.ShouldUseOfflineCustomResponse("Creator"));
            Assert.AreEqual(true, settings.ShouldUseOfflineCustomResponse("Programmer"));

            // Конкретные роли
            settings.GetType()
                .GetField("offlineCustomResponseRoles",
                    System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Instance)
                .SetValue(settings, "Creator,Programmer");
            Assert.AreEqual(true, settings.ShouldUseOfflineCustomResponse("Creator"));
            Assert.AreEqual(true, settings.ShouldUseOfflineCustomResponse("Programmer"));
            Assert.AreEqual(false, settings.ShouldUseOfflineCustomResponse("Merchant"));

            Object.DestroyImmediate(settings);
        }

        [Test]
        public void Singleton_ShouldLoadFromResources()
        {
            CoreAISettingsAsset.ResetInstance();

            CoreAISettingsAsset instance = CoreAISettingsAsset.Instance;

            Assert.IsNotNull(instance, "Expected Resources/CoreAISettings.asset to be loadable in tests.");
            Assert.AreEqual("CoreAISettings", instance.name);
            Assert.AreEqual(LlmBackendType.OpenAiHttp, instance.BackendType);
            Assert.AreEqual(LlmExecutionMode.ClientOwnedApi, instance.ExecutionMode);
            Assert.AreEqual("http://127.0.0.1:1234/v1", instance.ApiBaseUrl);
            Assert.AreEqual("qwen3.5-4b", instance.ModelName);
            Assert.AreEqual(240, instance.RequestTimeoutSeconds);
            Assert.AreEqual(512, instance.MaxTokens);
            Assert.AreEqual(2, instance.MaxLlmRequestRetries);
            Assert.AreEqual(50000, instance.ContextWindowTokens);
            Assert.IsFalse(string.IsNullOrWhiteSpace(instance.ApiKey));

            CoreAISettingsAsset.ResetInstance();
        }

        [TestCase("grok", "x-ai/grok-4.1-fast", true)]
        [TestCase("open", "nvidia/nemotron-3-super-120b-a12b:free", false)]
        [TestCase("minmaxFree", "minimax/minimax-m2.5:free", false)]
        public void Preset_ShouldApplyProviderOverrides(string presetFile, string expectedModel, bool expectedLlmContextCompaction)
        {
            Preset preset = LoadPreset(presetFile);

            CoreAISettingsAsset configured = ScriptableObject.CreateInstance<CoreAISettingsAsset>();
            preset.ApplyTo(configured);

            Assert.AreEqual(LlmBackendType.OpenAiHttp, configured.BackendType);
            Assert.AreEqual(LlmExecutionMode.ClientOwnedApi, configured.ExecutionMode);
            Assert.AreEqual("https://openrouter.ai/api/v1", configured.ApiBaseUrl);
            Assert.AreEqual(expectedModel, configured.ModelName);
            Assert.AreEqual(2048, configured.MaxTokens);
            Assert.AreEqual(120, configured.RequestTimeoutSeconds);
            Assert.AreEqual(2, configured.MaxLlmRequestRetries);
            Assert.AreEqual(50000, configured.ContextWindowTokens);
            Assert.AreEqual(expectedLlmContextCompaction, configured.EnableLlmContextCompaction);
            Assert.IsTrue(configured.EnableStreaming);
            Assert.IsTrue(configured.WebGlNativeStreaming);
            Assert.IsFalse(string.IsNullOrWhiteSpace(configured.ApiKey));

            Object.DestroyImmediate(configured);
        }

        private static Preset LoadPreset(string presetFile)
        {
            Preset preset = AssetDatabase.LoadAssetAtPath<Preset>($"Assets/Resources/{presetFile}.preset");
            Assert.IsNotNull(preset, $"Preset file '{presetFile}.preset' should be present at Assets/Resources.");
            return preset;
        }

        [Test]
        public void SetInstance_ShouldOverrideSingleton()
        {
            CoreAISettingsAsset settings = ScriptableObject.CreateInstance<CoreAISettingsAsset>();
            CoreAISettingsAsset.SetInstance(settings);

            Assert.AreSame(settings, CoreAISettingsAsset.Instance);

            CoreAISettingsAsset.ResetInstance();
            Object.DestroyImmediate(settings);
        }
    }
}