using System.Diagnostics;
using System.IO.Pipes;
using System.Runtime.InteropServices;
using System.Text.Json;
using System.Text.RegularExpressions;
using Lskj.AgentPet.Host.Core.Configuration;
using Microsoft.Win32.SafeHandles;

namespace Lskj.AgentPet.Host.Core.ErpBridge;

public interface IErpBridgeClient
{
    Task<JsonDocument> SendAsync(JsonElement request, CancellationToken cancellationToken = default);
}

public sealed class ErpBridgeClient : IErpBridgeClient
{
    internal static readonly TimeSpan MaximumProcessStartDrift = TimeSpan.FromSeconds(1);
    private static readonly Regex SafePipe = new(
        "^lserp\\.agent\\.(?<pid>[0-9]{1,10})"
            + "\\.(?<instance>[a-f0-9]{32})$",
        RegexOptions.Compiled | RegexOptions.CultureInvariant);
    private static readonly Regex SafeCode = new(
        "^[A-Za-z0-9_.:-]{1,128}$",
        RegexOptions.Compiled | RegexOptions.CultureInvariant);
    private static readonly Regex SafeBridgeInstanceId = new(
        "^[a-f0-9]{32}$",
        RegexOptions.Compiled | RegexOptions.CultureInvariant);
    private static readonly Regex TimeZoneSuffix = new(
        "(?:Z|[+-][0-9]{2}:[0-9]{2})$",
        RegexOptions.Compiled | RegexOptions.CultureInvariant);
    private static readonly ISet<string> AllowedResponseProperties = new HashSet<string>(
        new[]
        {
            "protocolVersion",
            "requestId",
            "correlationId",
            "success",
            "code",
            "message",
            "data"
        },
        StringComparer.Ordinal);
    private static readonly ISet<string> AllowedErrorDataProperties = new HashSet<string>(
        new[] { "recovery" },
        StringComparer.Ordinal);
    private static readonly ISet<string> AllowedRecoveryProperties = new HashSet<string>(
        new[] { "action", "retryable", "planInvalidated", "message" },
        StringComparer.Ordinal);
    private static readonly ISet<string> AllowedRecoveryActions = new HashSet<string>(
        new[]
        {
            "review_and_retry",
            "reconcile_execution",
            "restart_erp_pet",
            "inspect_existing_record",
            "replan",
            "correct_request",
            "contact_administrator",
            "wait_and_retry",
            "contact_support"
        },
        StringComparer.Ordinal);
    private static readonly ISet<string> AllowedDiscoveryProperties = new HashSet<string>(
        new[]
        {
            "protocolVersion",
            "pipeName",
            "processId",
            "startedAtUtc",
            "bridgeInstanceId"
        },
        StringComparer.Ordinal);
    private readonly HostConfiguration _configuration;
    private readonly object _bridgeInstanceSync = new();
    private string? _boundBridgeInstanceId;

    public ErpBridgeClient(HostConfiguration configuration)
    {
        _configuration = configuration ?? throw new ArgumentNullException(nameof(configuration));
    }

    public async Task<JsonDocument> SendAsync(
        JsonElement request,
        CancellationToken cancellationToken = default)
    {
        if (!OperatingSystem.IsWindows())
            throw new HostError("windows_required", "ERP 命名管道只支持 Windows。");
        if (request.ValueKind != JsonValueKind.Object)
            throw new HostError("bridge_request_invalid", "ERP 桥请求必须是 JSON 对象。");
        string requestId = RequiredString(request, "requestId", 128);
        string correlationId = RequiredString(request, "correlationId", 128);
        byte[] body = JsonSerializer.SerializeToUtf8Bytes(request);
        if (body.Length > BridgeFrameCodec.MaxMessageBytes)
            throw new HostError("bridge_protocol_error", "ERP 桥请求超过 1 MB。");

        ErpBridgeDiscovery discovery = FindPipe();
        lock (_bridgeInstanceSync)
        {
            _boundBridgeInstanceId = RequireStableBridgeInstance(
                _boundBridgeInstanceId,
                discovery);
        }
        using CancellationTokenSource timeout = CancellationTokenSource.CreateLinkedTokenSource(cancellationToken);
        timeout.CancelAfter(_configuration.BridgeTimeout);
        await using NamedPipeClientStream pipe = new(
            ".",
            discovery.PipeName,
            PipeDirection.InOut,
            PipeOptions.Asynchronous);
        try
        {
            await pipe.ConnectAsync(timeout.Token).ConfigureAwait(false);
            VerifyConnectedServer(pipe, discovery);
            await BridgeFrameCodec.WriteAsync(pipe, body, timeout.Token).ConfigureAwait(false);
            byte[] responseBytes = await BridgeFrameCodec.ReadAsync(pipe, timeout.Token).ConfigureAwait(false);
            JsonDocument response = JsonDocument.Parse(responseBytes, new JsonDocumentOptions
            {
                AllowTrailingCommas = false,
                CommentHandling = JsonCommentHandling.Disallow,
                MaxDepth = 64
            });
            try
            {
                ValidateResponse(response.RootElement, requestId, correlationId);
            }
            catch
            {
                response.Dispose();
                throw;
            }
            return response;
        }
        catch (OperationCanceledException error) when (!cancellationToken.IsCancellationRequested)
        {
            throw new HostError("bridge_timeout", "连接或调用 ERP 命令桥超时。", error);
        }
        catch (JsonException error)
        {
            throw new HostError("bridge_protocol_error", "ERP 桥返回无效 JSON。", error);
        }
        catch (IOException error)
        {
            throw new HostError("bridge_unavailable", "ERP 命令桥连接失败。", error);
        }
    }

    private ErpBridgeDiscovery FindPipe()
    {
        DirectoryInfo directory = new(_configuration.BridgeDiscoveryDirectory);
        if (!directory.Exists)
            throw new HostError("erp_bridge_not_running", "未发现已登录 ERP 的命令桥。");
        List<ErpBridgeDiscovery> live = new();
        foreach (FileInfo file in directory.EnumerateFiles("agentbridge-*.json")
            .Where(item => (item.Attributes & FileAttributes.ReparsePoint) == 0)
            .OrderByDescending(item => item.LastWriteTimeUtc))
        {
            try
            {
                if (file.Length is <= 0 or > 64 * 1024) continue;
                using FileStream stream = new(
                    file.FullName,
                    FileMode.Open,
                    FileAccess.Read,
                    FileShare.ReadWrite | FileShare.Delete,
                    4096,
                    FileOptions.SequentialScan);
                using JsonDocument document = JsonDocument.Parse(stream, new JsonDocumentOptions
                {
                    AllowTrailingCommas = false,
                    CommentHandling = JsonCommentHandling.Disallow,
                    MaxDepth = 16
                });
                JsonElement root = document.RootElement;
                ErpBridgeDiscovery discovery = ValidateDiscovery(root);
                if (!string.Equals(
                        file.Name,
                        "agentbridge-" + discovery.ProcessId + ".json",
                        StringComparison.OrdinalIgnoreCase)
                    || !ProcessMatches(discovery)) continue;
                live.Add(discovery);
            }
            catch (Exception error) when (error is IOException
                or UnauthorizedAccessException
                or JsonException
                or InvalidOperationException
                or KeyNotFoundException
                or System.ComponentModel.Win32Exception
                or ArgumentException)
            {
                continue;
            }
        }
        return SelectDiscovery(
            live,
            _configuration.BridgeProcessId,
            _configuration.BridgeProcessStartedAtUnixSeconds);
    }

    private static void VerifyConnectedServer(
        NamedPipeClientStream pipe,
        ErpBridgeDiscovery discovery)
    {
        uint serverProcessId = 0;
        bool querySucceeded;
        try
        {
            querySucceeded = GetNamedPipeServerProcessId(
                pipe.SafePipeHandle,
                out serverProcessId);
        }
        catch (Exception error) when (error is DllNotFoundException
            or EntryPointNotFoundException
            or ObjectDisposedException
            or InvalidOperationException)
        {
            querySucceeded = false;
        }

        bool processStillMatches;
        try
        {
            processStillMatches = ProcessMatches(discovery);
        }
        catch (Exception error) when (error is ArgumentException
            or InvalidOperationException
            or System.ComponentModel.Win32Exception)
        {
            processStillMatches = false;
        }
        ValidateConnectedServerIdentity(
            discovery,
            querySucceeded,
            serverProcessId,
            processStillMatches);
    }

    internal static void ValidateConnectedServerIdentity(
        ErpBridgeDiscovery discovery,
        bool querySucceeded,
        uint serverProcessId,
        bool processStillMatches)
    {
        if (discovery is null
            || discovery.ProcessId <= 0
            || !querySucceeded
            || serverProcessId != (uint)discovery.ProcessId
            || !processStillMatches)
        {
            throw new HostError(
                "bridge_server_identity_mismatch",
                "ERP 命令桥服务进程身份不匹配，连接已关闭。");
        }
    }

    internal static string RequireStableBridgeInstance(
        string? expectedBridgeInstanceId,
        ErpBridgeDiscovery discovery)
    {
        if (discovery is null
            || !SafeBridgeInstanceId.IsMatch(discovery.BridgeInstanceId))
            throw ProtocolError();
        if (string.IsNullOrEmpty(expectedBridgeInstanceId))
            return discovery.BridgeInstanceId;
        if (!string.Equals(
                expectedBridgeInstanceId,
                discovery.BridgeInstanceId,
                StringComparison.Ordinal))
        {
            throw new HostError(
                "erp_bridge_instance_changed",
                "ERP 已重新登录或命令桥已经重建，请重新启动桌宠以建立新会话。");
        }
        return expectedBridgeInstanceId;
    }

    internal static ErpBridgeDiscovery SelectDiscovery(
        IReadOnlyList<ErpBridgeDiscovery> live,
        int? targetProcessId,
        long? targetStartedAtUnixSeconds)
    {
        if (targetStartedAtUnixSeconds.HasValue && !targetProcessId.HasValue)
            throw new HostError("bridge_process_binding_invalid", "ERP 进程启动时间缺少对应进程 ID。");
        if (targetProcessId.HasValue)
        {
            List<ErpBridgeDiscovery> selected = live.Where(
                item => item.ProcessId == targetProcessId.Value
                    && (!targetStartedAtUnixSeconds.HasValue
                        || item.StartedAtUtc.ToUnixTimeSeconds()
                            == targetStartedAtUnixSeconds.Value)).ToList();
            if (selected.Count != 1)
            {
                throw new HostError(
                    "erp_bridge_target_not_running",
                    "指定的 ERP 进程未运行命令桥，请重新从目标 ERP 启动桌宠。");
            }
            return selected[0];
        }
        if (live.Count == 0)
            throw new HostError("erp_bridge_not_running", "ERP 命令桥发现文件均已失效。");
        if (live.Count > 1)
        {
            throw new HostError(
                "erp_bridge_ambiguous",
                "检测到多个已登录 ERP，必须从目标 ERP 启动桌宠或显式指定进程。");
        }
        return live[0];
    }

    private static bool ProcessMatches(ErpBridgeDiscovery discovery)
    {
        using Process process = Process.GetProcessById(discovery.ProcessId);
        if (process.HasExited) return false;
        DateTimeOffset actualStart = process.StartTime.ToUniversalTime();
        return ProcessStartMatches(discovery, actualStart);
    }

    internal static bool ProcessStartMatches(
        ErpBridgeDiscovery discovery,
        DateTimeOffset actualStart)
    {
        return discovery is not null
            && Math.Abs((actualStart - discovery.StartedAtUtc).TotalSeconds)
                <= MaximumProcessStartDrift.TotalSeconds;
    }

    internal static void ValidateResponse(
        JsonElement response,
        string expectedRequestId,
        string expectedCorrelationId)
    {
        ValidateProperties(response, AllowedResponseProperties, "ERP 桥响应");
        string protocol = RequiredString(response, "protocolVersion", 16);
        string requestId = RequiredString(response, "requestId", 128);
        string correlationId = RequiredString(response, "correlationId", 128);
        string code = RequiredString(response, "code", 128);
        if (!string.Equals(protocol, "1.0", StringComparison.Ordinal)
            || !string.Equals(requestId, expectedRequestId, StringComparison.Ordinal)
            || !string.Equals(correlationId, expectedCorrelationId, StringComparison.Ordinal)
            || !SafeCode.IsMatch(code)
            || !response.TryGetProperty("success", out JsonElement success)
            || (success.ValueKind != JsonValueKind.True
                && success.ValueKind != JsonValueKind.False)
            || !response.TryGetProperty("data", out JsonElement data)
            || data.ValueKind != JsonValueKind.Object)
            throw ProtocolError();
        if (response.TryGetProperty("message", out JsonElement message)
            && message.ValueKind != JsonValueKind.Null)
        {
            if (message.ValueKind != JsonValueKind.String
                || (message.GetString()?.Length ?? 0) > 2000)
                throw ProtocolError();
        }
        if (success.ValueKind == JsonValueKind.False)
            ValidateErrorRecovery(data);
    }

    private static void ValidateErrorRecovery(JsonElement data)
    {
        ValidateProperties(data, AllowedErrorDataProperties, "ERP 桥错误 data");
        if (!data.TryGetProperty("recovery", out JsonElement recovery)
            || recovery.ValueKind != JsonValueKind.Object)
            throw ProtocolError();
        ValidateProperties(recovery, AllowedRecoveryProperties, "ERP 桥错误 recovery");
        string action = RequiredString(recovery, "action", 64);
        string message = RequiredString(recovery, "message", 300);
        if (!AllowedRecoveryActions.Contains(action)
            || message.Any(char.IsControl)
            || !recovery.TryGetProperty("retryable", out JsonElement retryable)
            || (retryable.ValueKind != JsonValueKind.True
                && retryable.ValueKind != JsonValueKind.False)
            || !recovery.TryGetProperty("planInvalidated", out JsonElement invalidated)
            || (invalidated.ValueKind != JsonValueKind.True
                && invalidated.ValueKind != JsonValueKind.False))
            throw ProtocolError();
    }

    internal static ErpBridgeDiscovery ValidateDiscovery(JsonElement discovery)
    {
        ValidateProperties(discovery, AllowedDiscoveryProperties, "ERP 桥发现文件");
        string protocol = RequiredString(discovery, "protocolVersion", 16);
        string pipeName = RequiredString(discovery, "pipeName", 64);
        string bridgeInstanceId = RequiredString(
            discovery,
            "bridgeInstanceId",
            32);
        if (!string.Equals(protocol, "1.0", StringComparison.Ordinal)
            || !discovery.TryGetProperty("processId", out JsonElement process)
            || process.ValueKind != JsonValueKind.Number
            || !process.TryGetInt32(out int processId)
            || processId <= 0
            || !discovery.TryGetProperty("startedAtUtc", out JsonElement started)
            || started.ValueKind != JsonValueKind.String
            || !TimeZoneSuffix.IsMatch(started.GetString() ?? string.Empty)
            || !started.TryGetDateTimeOffset(out DateTimeOffset startedAt))
            throw ProtocolError();
        if (!SafeBridgeInstanceId.IsMatch(bridgeInstanceId))
            throw ProtocolError();
        Match match = SafePipe.Match(pipeName);
        if (!match.Success
            || !int.TryParse(match.Groups["pid"].Value, out int pipeProcessId)
            || pipeProcessId != processId
            || !string.Equals(
                match.Groups["instance"].Value,
                bridgeInstanceId,
                StringComparison.Ordinal))
            throw ProtocolError();
        return new ErpBridgeDiscovery(
            pipeName,
            processId,
            startedAt.ToUniversalTime(),
            bridgeInstanceId);
    }

    private static void ValidateProperties(
        JsonElement source,
        ISet<string> allowed,
        string label)
    {
        if (source.ValueKind != JsonValueKind.Object) throw ProtocolError();
        ValidateUniqueProperties(source, label);
        foreach (JsonProperty property in source.EnumerateObject())
        {
            if (!allowed.Contains(property.Name))
                throw new HostError(
                    "bridge_protocol_error",
                    label + "包含未知字段。");
        }
    }

    private static void ValidateUniqueProperties(JsonElement source, string label)
    {
        if (source.ValueKind == JsonValueKind.Object)
        {
            HashSet<string> seen = new(StringComparer.Ordinal);
            foreach (JsonProperty property in source.EnumerateObject())
            {
                if (!seen.Add(property.Name))
                    throw new HostError(
                        "bridge_protocol_error",
                        label + "包含重复 JSON 字段。");
                ValidateUniqueProperties(property.Value, label);
            }
        }
        else if (source.ValueKind == JsonValueKind.Array)
        {
            foreach (JsonElement item in source.EnumerateArray())
                ValidateUniqueProperties(item, label);
        }
    }

    private static string RequiredString(JsonElement source, string name, int maximumLength)
    {
        if (!source.TryGetProperty(name, out JsonElement value)
            || value.ValueKind != JsonValueKind.String)
            throw new HostError("bridge_protocol_error", "ERP 桥消息缺少字段：" + name);
        string result = value.GetString() ?? string.Empty;
        if (string.IsNullOrWhiteSpace(result) || result.Length > maximumLength)
            throw new HostError("bridge_protocol_error", "ERP 桥消息字段格式无效：" + name);
        return result;
    }

    private static HostError ProtocolError() => new(
        "bridge_protocol_error",
        "ERP 桥返回了无效或不匹配的协议消息。");

    [DllImport("kernel32.dll", SetLastError = true)]
    [return: MarshalAs(UnmanagedType.Bool)]
    private static extern bool GetNamedPipeServerProcessId(
        SafePipeHandle pipe,
        out uint serverProcessId);
}

internal sealed class ErpBridgeDiscovery
{
    public ErpBridgeDiscovery(
        string pipeName,
        int processId,
        DateTimeOffset startedAtUtc,
        string bridgeInstanceId)
    {
        PipeName = pipeName;
        ProcessId = processId;
        StartedAtUtc = startedAtUtc;
        BridgeInstanceId = bridgeInstanceId;
    }

    public string PipeName { get; }
    public int ProcessId { get; }
    public DateTimeOffset StartedAtUtc { get; }
    public string BridgeInstanceId { get; }
}