using Agent.App.Cli;
using Agent.App.Configuration;
using Agent.App;
using Agent.Core.Localization;
using Agent.Core.Skills;
using Agent.App.Sandbox;
using Agent.Windows.Security;

namespace Agent.Core.Tests;

public sealed class ConfigurationTests
{
    [Fact]
    public void ValidYamlLoadsTypedConfiguration()
    {
        using var directory = new TestDirectory();
        string config = CreateValidConfiguration(directory);
        AgentConfiguration result = ConfigurationLoader.Load(config);
        Assert.Equal(1, result.SchemaVersion);
        Assert.Equal("model", result.Ollama.Model);
        Assert.Equal("none", result.Sandbox.Network.Access);
    }

    [Fact]
    public void UnknownYamlPropertyIsFatal()
    {
        using var directory = new TestDirectory();
        string config = CreateValidConfiguration(directory);
        System.IO.File.AppendAllText(config, "unknown_root: true\n");
        Assert.Throws<ConfigurationException>(() => ConfigurationLoader.Load(config));
    }

    [Fact]
    public void InvalidSchemaIsFatal()
    {
        using var directory = new TestDirectory();
        string config = CreateValidConfiguration(directory);
        System.IO.File.WriteAllText(config, System.IO.File.ReadAllText(config).Replace("schema_version: 1", "schema_version: 2", StringComparison.Ordinal));
        Assert.Throws<ConfigurationException>(() => ConfigurationLoader.Load(config));
    }

    [Theory]
    [InlineData("true")]
    [InlineData("false")]
    [InlineData("low")]
    [InlineData("medium")]
    [InlineData("high")]
    [InlineData("max")]
    public void Ollama_think_accepts_native_boolean_and_level_values(string value)
    {
        using var directory = new TestDirectory();
        string config = CreateValidConfiguration(directory);
        System.IO.File.WriteAllText(config, System.IO.File.ReadAllText(config).Replace("  model: model", $"  model: model\n  think: {value}", StringComparison.Ordinal));

        AgentConfiguration result = ConfigurationLoader.Load(config);

        Assert.Equal(value is "true" or "false" ? bool.Parse(value) : value, result.Ollama.Think);
    }

    [Fact]
    public void Ollama_think_rejects_unknown_level()
    {
        using var directory = new TestDirectory();
        string config = CreateValidConfiguration(directory);
        System.IO.File.WriteAllText(config, System.IO.File.ReadAllText(config).Replace("  model: model", "  model: model\n  think: extreme", StringComparison.Ordinal));

        ConfigurationException error = Assert.Throws<ConfigurationException>(() => ConfigurationLoader.Load(config));

        Assert.Contains("ollama.think", error.Message, StringComparison.Ordinal);
    }

    [Fact]
    public void CommandLineLanguageOverrideIsCaptured()
    {
        CommandLine result = CommandLine.Parse(["serve", "--lang", "ja", "--transport", "http"]);
        Assert.Equal("ja", result.Language);
        Assert.Equal("http", result.Transport);
    }

    [Fact]
    public void CommandLine_defaults_to_serve_when_command_is_omitted()
    {
        Assert.Equal(AppCommand.Serve, CommandLine.Parse([]).Command);
        CommandLine withOption = CommandLine.Parse(["--lang", "ja"]);
        Assert.Equal(AppCommand.Serve, withOption.Command);
        Assert.Equal("ja", withOption.Language);
    }

    [Fact]
    public void Local_configuration_recursively_merges_maps_and_replaces_sequences()
    {
        using var directory = new TestDirectory();
        string config = CreateValidConfiguration(directory);
        directory.File("agent.local.yaml", """
            application:
              language: ja
            sandbox:
              workspaces: [C:/local-only]
            """);

        AgentConfiguration result = ConfigurationLoader.Load(config);

        Assert.Equal("ja", result.Application.Language);
        Assert.Equal(["C:/local-only"], result.Sandbox.Workspaces);
        Assert.Equal("model", result.Ollama.Model);
    }

    [Fact]
    public void Unknown_local_configuration_property_is_fatal()
    {
        using var directory = new TestDirectory();
        string config = CreateValidConfiguration(directory);
        directory.File("agent.local.yaml", "unknown_local: true\n");

        Assert.Throws<ConfigurationException>(() => ConfigurationLoader.Load(config));
    }

    [Fact]
    public void Legacy_filesystem_and_process_schema_is_rejected_with_migration_diagnostic()
    {
        using var directory = new TestDirectory();
        string config = CreateValidConfiguration(directory);
        directory.File("agent.local.yaml", $$"""
            sandbox:
              filesystem:
                execute: [C:/legacy/tool.exe]
              process:
                approvals: []
            """);

        ConfigurationException error = Assert.Throws<ConfigurationException>(() => ConfigurationLoader.Load(config));
        Assert.Contains("Legacy sandbox.filesystem/sandbox.process", error.Message, StringComparison.Ordinal);
        Assert.Contains("sandbox resolve", error.Message, StringComparison.Ordinal);
    }

    [Fact]
    public void Semantic_sandbox_rejects_readonly_write_mount_and_conflicting_network_endpoints()
    {
        using var directory = new TestDirectory();
        string config = CreateValidConfiguration(directory);
        directory.File("agent.local.yaml", """
            sandbox:
              profile: readonly
              mounts:
                - path: C:/data
                  access: read_write
              network:
                access: none
                local_endpoints:
                  - port: 11434
            """);

        ConfigurationException error = Assert.Throws<ConfigurationException>(() => ConfigurationLoader.Load(config));
        Assert.Contains("readonly", error.Message, StringComparison.OrdinalIgnoreCase);
    }

    [Fact]
    public void Management_commands_require_config_and_capture_options()
    {
        Assert.Throws<CommandLineException>(() => CommandLine.Parse(["sandbox", "resolve"]));
        CommandLine approve = CommandLine.Parse(["executable", "approve", "python", "--path", "C:/python.exe", "--no-runtime", "--yes", "--config", "agent.yaml"]);
        Assert.Equal(AppCommand.ExecutableApprove, approve.Command);
        Assert.Equal("python", approve.Alias);
        Assert.True(approve.NoRuntime);
        Assert.True(approve.Yes);
    }

    [Fact]
    public void Executable_alias_ambiguity_is_reported_without_automatic_selection()
    {
        using var directory = new TestDirectory();
        string first = Path.Combine(directory.Path, "first");
        string second = Path.Combine(directory.Path, "second");
        Directory.CreateDirectory(first);
        Directory.CreateDirectory(second);
        File.WriteAllText(Path.Combine(first, "fixture.exe"), "first");
        File.WriteAllText(Path.Combine(second, "fixture.exe"), "second");
        string? original = Environment.GetEnvironmentVariable("PATH");
        try
        {
            Environment.SetEnvironmentVariable("PATH", string.Join(Path.PathSeparator, first, second));

            IReadOnlyList<string> candidates = ExecutableResolver.ResolveCandidates("fixture", null);

            Assert.Equal(2, candidates.Count);
            Assert.Contains(candidates, item => item.Equals(Path.Combine(first, "fixture.exe"), StringComparison.OrdinalIgnoreCase));
            Assert.Contains(candidates, item => item.Equals(Path.Combine(second, "fixture.exe"), StringComparison.OrdinalIgnoreCase));
        }
        finally { Environment.SetEnvironmentVariable("PATH", original); }
    }

    [Fact]
    public void Shell_classification_accepts_only_the_documented_command_interpreters()
    {
        Assert.True(ExecutableResolver.IsSupportedShell("C:/Windows/System32/cmd.exe"));
        Assert.True(ExecutableResolver.IsSupportedShell("C:/Program Files/PowerShell/7/pwsh.exe"));
        Assert.False(ExecutableResolver.IsSupportedShell("C:/tools/python.exe"));
    }

    [Fact]
    public void Resolution_confirmation_is_invalidated_by_config_fingerprint_change()
    {
        using var directory = new TestDirectory();
        string configPath = directory.File("agent.yaml", "schema_version: 1");
        string workspace = Path.Combine(directory.Path, "workspace");
        Directory.CreateDirectory(workspace);
        string stores = Path.Combine(directory.Path, "stores");
        var configuration = new AgentConfiguration
        {
            Sandbox = new SandboxOptions { Profile = "development", Workspaces = [workspace] }
        };
        var resolutionStore = new SandboxResolutionStore(configPath, stores, protectDirectory: false);
        var approvalStore = new ExecutableApprovalStore(Path.Combine(stores, "approvals.json"), protectDirectory: false);
        var resolver = new SandboxEnvironmentResolver(configPath, configuration, resolutionStore, approvalStore);
        _ = resolver.Confirm();
        _ = resolver.Compile(Path.Combine(directory.Path, "journals"), Path.Combine(directory.Path, "backups"));

        configuration.Sandbox.Resources.Profile = "extended";
        ConfigurationException error = Assert.Throws<ConfigurationException>(() =>
            resolver.Compile(Path.Combine(directory.Path, "journals"), Path.Combine(directory.Path, "backups")));
        Assert.Contains("changed after confirmation", error.Message, StringComparison.Ordinal);
    }

    [Fact]
    public void Approval_store_never_refreshes_a_changed_executable_identity()
    {
        using var directory = new TestDirectory();
        string configPath = directory.File("agent.yaml", "schema_version: 1");
        string executable = directory.File("fixture.exe", "first");
        string stores = Path.Combine(directory.Path, "stores");
        var configuration = new AgentConfiguration();
        configuration.Sandbox.Execution.Executables.Add("fixture");
        var resolutionStore = new SandboxResolutionStore(configPath, stores, protectDirectory: false);
        var approvalStore = new ExecutableApprovalStore(Path.Combine(stores, "approvals.json"), protectDirectory: false);
        approvalStore.Approve(new("fixture", "executable", executable, ResolvedPath.Resolve(executable),
            EntryExecutablePolicy.ComputeSha256(executable), null, DateTimeOffset.UtcNow));
        var resolver = new SandboxEnvironmentResolver(configPath, configuration, resolutionStore, approvalStore);
        _ = resolver.Confirm();
        File.WriteAllText(executable, "second");

        ConfigurationException error = Assert.Throws<ConfigurationException>(() =>
            resolver.Compile(Path.Combine(directory.Path, "journals"), Path.Combine(directory.Path, "backups")));
        Assert.Contains("SHA-256 changed", error.Message, StringComparison.Ordinal);
        Assert.Single(approvalStore.List());
        Assert.True(approvalStore.Revoke("fixture"));
        Assert.Empty(approvalStore.List());
        Assert.Empty(Directory.EnumerateFiles(stores, "*.tmp"));
    }

    [Fact]
    public void Approval_store_rejects_malformed_identity_records()
    {
        using var directory = new TestDirectory();
        string storePath = directory.File("stores/approvals.json", """
            {
              "schemaVersion": 1,
              "approvals": [{
                "alias": "Python With Spaces",
                "classification": "unknown",
                "logicalPath": "python.exe",
                "resolvedPath": "relative/python.exe",
                "sha256": "not-a-hash",
                "runtimeRoot": null,
                "approvedAt": "2026-08-12T00:00:00Z"
              }]
            }
            """);
        var store = new ExecutableApprovalStore(storePath, protectDirectory: false);

        Assert.Throws<ConfigurationException>(() => store.List());
    }

    [Fact]
    public void Narrow_nested_mount_is_rejected_instead_of_silently_widened()
    {
        using var directory = new TestDirectory();
        string configPath = directory.File("agent.yaml", "schema_version: 1");
        string workspace = Path.Combine(directory.Path, "workspace");
        string nested = Path.Combine(workspace, "read-only-data");
        Directory.CreateDirectory(nested);
        string stores = Path.Combine(directory.Path, "stores");
        var configuration = new AgentConfiguration
        {
            Sandbox = new SandboxOptions
            {
                Profile = "development",
                Workspaces = [workspace],
                Mounts = [new MountOptions { Path = nested, Access = "read_only" }]
            }
        };
        var resolver = new SandboxEnvironmentResolver(configPath, configuration,
            new SandboxResolutionStore(configPath, stores, protectDirectory: false),
            new ExecutableApprovalStore(Path.Combine(stores, "approvals.json"), protectDirectory: false));
        _ = resolver.Confirm();

        ConfigurationException error = Assert.Throws<ConfigurationException>(() =>
            resolver.Compile(Path.Combine(directory.Path, "journals"), Path.Combine(directory.Path, "backups")));
        Assert.Contains("cannot be enforced", error.Message, StringComparison.Ordinal);
    }

    [Fact]
    public void Profile_network_and_resource_configuration_compile_to_effective_policy()
    {
        using var directory = new TestDirectory();
        string configPath = directory.File("agent.yaml", "schema_version: 1");
        string workspace = Path.Combine(directory.Path, "workspace");
        Directory.CreateDirectory(workspace);
        string stores = Path.Combine(directory.Path, "stores");
        var configuration = new AgentConfiguration
        {
            Sandbox = new SandboxOptions
            {
                Profile = "development",
                Workspaces = [workspace],
                Network = new NetworkOptions { Access = "local", LocalEndpoints = [new LocalEndpointOptions { Port = 11434 }] },
                Resources = new ResourceOptions { Profile = "constrained", ProcessLimit = 6, ExecutionTimeoutSeconds = 450 }
            }
        };
        var resolver = new SandboxEnvironmentResolver(configPath, configuration,
            new SandboxResolutionStore(configPath, stores, protectDirectory: false),
            new ExecutableApprovalStore(Path.Combine(stores, "approvals.json"), protectDirectory: false));
        _ = resolver.Confirm();

        Agent.Windows.Tools.EffectiveSandboxPolicy policy = resolver.Compile(
            Path.Combine(directory.Path, "journals"), Path.Combine(directory.Path, "backups"));

        Assert.Contains(workspace, policy.ArtifactRoots, StringComparer.OrdinalIgnoreCase);
        Assert.Contains(policy.Files, item => item.Path.Equals(workspace, StringComparison.OrdinalIgnoreCase) &&
            item.Capabilities == (FileCapability.Read | FileCapability.Write | FileCapability.Delete | FileCapability.Execute));
        Assert.Equal(6u, policy.JobLimits.MaxProcesses);
        Assert.Equal(1024UL * 1024 * 1024, policy.JobLimits.MaxJobMemoryBytes);
        Assert.Equal(450, policy.ProcessTimeoutSeconds);
        Assert.Contains(policy.NetworkAllowances, item => item.Host == "127.0.0.1" && item.Ports.SequenceEqual([11434]));
        Assert.Contains(policy.NetworkAllowances, item => item.Host == "::1" && item.Ports.SequenceEqual([11434]));
    }

    [Fact]
    public void Readonly_profile_never_creates_an_artifact_root_or_execute_capability()
    {
        using var directory = new TestDirectory();
        string configPath = directory.File("agent.yaml", "schema_version: 1");
        string workspace = Path.Combine(directory.Path, "workspace");
        Directory.CreateDirectory(workspace);
        string stores = Path.Combine(directory.Path, "stores");
        var configuration = new AgentConfiguration { Sandbox = new SandboxOptions { Profile = "readonly", Workspaces = [workspace] } };
        var resolver = new SandboxEnvironmentResolver(configPath, configuration,
            new SandboxResolutionStore(configPath, stores, protectDirectory: false),
            new ExecutableApprovalStore(Path.Combine(stores, "approvals.json"), protectDirectory: false));
        _ = resolver.Confirm();

        Agent.Windows.Tools.EffectiveSandboxPolicy policy = resolver.Compile(
            Path.Combine(directory.Path, "journals"), Path.Combine(directory.Path, "backups"));

        Assert.Empty(policy.ArtifactRoots);
        Assert.Contains(policy.Files, item => item.Path.Equals(workspace, StringComparison.OrdinalIgnoreCase) && item.Capabilities == FileCapability.Read);
    }

    [Fact]
    public void Runtime_configuration_values_are_propagated()
    {
        var configuration = new AgentConfiguration
        {
            Agent = new RuntimeOptions { MaxIterations = 41, SameFailureLimit = 4 },
            Planner = new PlannerOptions { MaxTasks = 17 },
            Ollama = new OllamaConfiguration { Model = "model-x", Options = new OllamaGenerationOptions { NumCtx = 12345 } },
            Limits = new LimitOptions { ContextSummaryRatio = 0.65 }
        };
        LocaleCatalog locale = LocaleCatalog.Load(Path.GetFullPath("config/locales"), "ja");

        Agent.Core.Runtime.AgentRuntimeSettings settings = Program.CreateRuntimeSettings(configuration, "prompt", "ja", [], locale);

        Assert.Equal(41, settings.MaxIterations);
        Assert.Equal(4, settings.SameFailureLimit);
        Assert.Equal(17, settings.MaxTasks);
        Assert.Equal(12345, settings.NumCtx);
        Assert.Equal(0.65, settings.ContextSummaryThreshold);
        Assert.Equal("model-x", settings.Model);
    }

    [Fact]
    public void Startup_errors_follow_the_cli_locale()
    {
        string message = Program.FormatStartupError(["--lang", "ja"], new CommandLineException("bad option"));
        Assert.Contains("コマンドラインが不正です", message, StringComparison.Ordinal);
        Assert.Contains("bad option", message, StringComparison.Ordinal);

        string sandbox = Program.FormatStartupError(["--lang", "ja"], new ConfigurationException(
            "internal", code: "executable.hash_changed", category: "sandbox", target: "C:/Python/python.exe",
            resolution: "internal resolution"));
        Assert.Contains("SHA-256が変更されました", sandbox, StringComparison.Ordinal);
        Assert.Contains("明示的に再承認", sandbox, StringComparison.Ordinal);
        Assert.DoesNotContain("internal resolution", sandbox, StringComparison.Ordinal);
    }

    [Fact]
    public void SkillLoader_loads_standard_skill_directories_only()
    {
        using var directory = new TestDirectory();
        // Legacy single markdown — should be ignored (not loaded).
        directory.File("skills/legacy.md", "legacy skill");
        // Standard skill directory with frontmatter.
        directory.File("skills/python/SKILL.md", "---\nname: python\ndescription: Python execution skill.\n---\n# Python\nInstructions here.");
        // Non-SKILL.md files in skill directory should not be loaded as skills.
        directory.File("skills/python/reference.md", "must not be loaded as a skill");

        var skills = SkillLoader.Load(Path.Combine(directory.Path, "skills"));

        Assert.Single(skills);
        Assert.Equal("python", skills[0].Name);
        Assert.Equal("Python execution skill.", skills[0].Description);
        Assert.Contains("Instructions here.", skills[0].Instructions);
    }

    [Fact]
    public void SkillLoader_rejects_missing_frontmatter()
    {
        using var directory = new TestDirectory();
        directory.File("skills/no-frontmatter/SKILL.md", "# No frontmatter\nJust body.");

        Assert.Throws<SkillLoadException>(() => SkillLoader.Load(Path.Combine(directory.Path, "skills")));
    }

    [Fact]
    public void SkillLoader_rejects_name_mismatch()
    {
        using var directory = new TestDirectory();
        directory.File("skills/wrong-name/SKILL.md", "---\nname: different-name\ndescription: A skill.\n---\nBody.");

        Assert.Throws<SkillLoadException>(() => SkillLoader.Load(Path.Combine(directory.Path, "skills")));
    }

    [Fact]
    public void SkillLoader_rejects_duplicate_names()
    {
        using var directory = new TestDirectory();
        directory.File("skills/dup-skill/SKILL.md", "---\nname: dup-skill\ndescription: First.\n---\nBody1.");
        // Create a second directory with the same skill name (via symlink or junction is not needed;
        // just create another dir that also has name: dup-skill in frontmatter).
        directory.File("skills/dup-skill-copy/SKILL.md", "---\nname: dup-skill\ndescription: Second.\n---\nBody2.");

        Assert.Throws<SkillLoadException>(() => SkillLoader.Load(Path.Combine(directory.Path, "skills")));
    }

    private static string CreateValidConfiguration(TestDirectory directory)
    {
        directory.File("prompts/user-system.md", string.Empty);
        Directory.CreateDirectory(System.IO.Path.Combine(directory.Path, "config/locales"));
        Directory.CreateDirectory(System.IO.Path.Combine(directory.Path, "skills"));
        return directory.File("agent.yaml", """
            schema_version: 1
            application:
              language: en
            agent:
              user_system_prompt: prompts/user-system.md
            ollama:
              endpoint: http://127.0.0.1:11434
              model: model
            localization:
              directory: config/locales
              fallback: en
            skills:
              directory: skills
            """);
    }
}