using System.Net.Http.Headers;
using System.Net.Http.Json;
using System.Text.Json;
using System.Text.Json.Nodes;
using Nexus.Api.Models;

namespace Nexus.Api.Services;

public sealed class OpenClawGatewayClient(HttpClient httpClient, IConfiguration configuration)
{
    private static readonly JsonSerializerOptions JsonOptions = new()
    {
        PropertyNameCaseInsensitive = true,
        PropertyNamingPolicy = JsonNamingPolicy.CamelCase
    };

    private string? GetPassword()
    {
        var password = configuration["Integrations:OpenClaw:Password"];
        if (string.IsNullOrWhiteSpace(password))
            password = configuration["Integrations:OpenClaw:Token"];
        return string.IsNullOrWhiteSpace(password) ? null : password;
    }

    private void ApplyAuth(HttpRequestMessage request)
    {
        var password = GetPassword();
        if (password is not null)
            request.Headers.Authorization = new AuthenticationHeaderValue("Bearer", password);
    }

    public async Task<JsonNode?> InvokeToolAsync(string tool, object? args = null)
    {
        try
        {
            using var request = new HttpRequestMessage(HttpMethod.Post, "/tools/invoke");
            ApplyAuth(request);

            var body = new Dictionary<string, object?> { ["tool"] = tool };
            if (args is not null)
                body["args"] = args;

            request.Content = JsonContent.Create(body);

            using var response = await httpClient.SendAsync(request);
            if (!response.IsSuccessStatusCode)
                return null;

            var json = await response.Content.ReadAsStringAsync();
            if (string.IsNullOrWhiteSpace(json))
                return null;

            var node = JsonNode.Parse(json);
            if (node?["ok"]?.GetValue<bool>() == true && node["result"] is not null)
                return node["result"];
            return node;
        }
        catch
        {
            return null;
        }
    }

    /// <summary>
    /// Reads the agent session status from the Gateway via session_status tool.
    /// Returns fields like model, provider, status, lastActivity, isActive, currentTask.
    /// Returns null if the session is unreachable.
    /// </summary>
    private async Task<JsonNode?> TryGetAgentStatusAsync(string agentId)
    {
        try
        {
            return await InvokeToolAsync("session_status", new { sessionKey = "agent:" + agentId + ":main" });
        }
        catch
        {
            return null;
        }
    }

    public async Task<List<DashboardAgentInfo>> GetAgentsAsync()
    {
        // Fallback hardcoded descriptions and tags known for each agent
        var knownInfo = new Dictionary<string, (string Name, string Description, string[] Tags)>
        {
            ["iris"] = (
                "Iris",
                "Zentrale operative Führungsinstanz. Strukturiert Aufgaben, bewertet Risiken, steuert spezialisierte Agenten und eskaliert kritische Entscheidungen.",
                new[] { "Orchestration", "Delegation", "Approval", "Risk Management" }
            ),
            ["programmer"] = (
                "Full-Stack Developer",
                "Primärer Entwicklungsagent. Implementiert Features, behebt Bugs und schreibt Code im gesamten Stack — autonom im Rahmen seines Scopes.",
                new[] { "Full-Stack", "TypeScript", "C#", "Vue", ".NET", "Builds" }
            ),
            ["reviewer"] = (
                "Code Quality Assurance",
                "Code-Qualitätskontrolle. Prüft Diffs auf Bugs, Regressionen, Sicherheitslücken und Wartbarkeit. Berichtet Findings strukturiert und knapp.",
                new[] { "Code Review", "Testing", "Security", "Quality" }
            ),
            ["architekt"] = (
                "Infrastructure Architect",
                "Verwaltet die gesamte Server-Infrastruktur. Deployt Services, konfiguriert Docker, Nginx und Firewall. Stellt sicher, dass die Produktivumgebung stabil und sicher läuft.",
                new[] { "Docker", "Nginx", "CI/CD", "Firewall", "VPS" }
            ),
            ["executor"] = (
                "Host Executor",
                "Einziger Agent mit Host-Exec-Rechten. Führt Docker- und Shell-Befehle auf dem VPS aus — ausschließlich im Auftrag von Iris. Handelt niemals eigeninitiativ.",
                new[] { "Docker", "Shell", "Host", "Deployment" }
            ),
            ["researcher"] = (
                "Research & Analysis",
                "Spezialisierter Recherche-Agent. Sucht online, prüft Quellen, analysiert Inhalte (inkl. YouTube-Videos) und übergibt strukturierte Erkenntnisse. Ausschließlich Lese- und Analyse-Rechte.",
                new[] { "Research", "Quellenprüfung", "Analyse", "Docs" }
            )
        };

        // Load agent IDs from openclaw.json config
        var agentIds = LoadAgentIdsFromConfig();

        var agents = new List<DashboardAgentInfo>();
        foreach (var id in agentIds)
        {
            // Skip the "main" agent (it's the default assistant, not a sub-agent)
            if (string.Equals(id, "main", StringComparison.OrdinalIgnoreCase))
                continue;

            // 1. Try to get dynamic session status from Gateway
            var status = await TryGetAgentStatusAsync(id);

            // 2. Extract model from session_status (dynamic)
            var model = status?["model"]?.GetValue<string>();

            // 3. Extract activity from session_status
            var isActive = false;
            string? currentTask = null;
            if (status is not null)
            {
                // Check explicit isActive field
                var activeVal = status["isActive"];
                if (activeVal is not null && activeVal.GetValueKind() == JsonValueKind.True)
                    isActive = true;
                else if (activeVal is not null && activeVal.GetValueKind() == JsonValueKind.String)
                    isActive = string.Equals(activeVal.GetValue<string>(), "true", StringComparison.OrdinalIgnoreCase);

                // Fall back to status text
                var statusText = status["status"]?.GetValue<string>();
                if (!isActive && statusText is not null)
                    isActive = string.Equals(statusText, "active", StringComparison.OrdinalIgnoreCase)
                            || string.Equals(statusText, "running", StringComparison.OrdinalIgnoreCase);

                currentTask = status["currentTask"]?.GetValue<string>()
                           ?? status["task"]?.GetValue<string>()
                           ?? (isActive ? "Working..." : null);
            }

            // 4. Try to read workspace metadata for richer info
            var (name, description, tags) = await ReadAgentMetadataAsync(id);

            // 5. Fallback to known info if workspace metadata not available
            if (string.IsNullOrWhiteSpace(name) && knownInfo.TryGetValue(id, out var kn))
            {
                name = kn.Name;
                if (string.IsNullOrWhiteSpace(description))
                    description = kn.Description;
                if (tags.Length == 0)
                    tags = kn.Tags;
            }

            if (string.IsNullOrWhiteSpace(model))
            {
                model = id.ToLowerInvariant() switch
                {
                    "iris" or "programmer" or "executor" => "deepseek/deepseek-v4-flash",
                    "reviewer" or "architekt" or "researcher" => "deepseek/deepseek-v4-pro",
                    _ => "deepseek/deepseek-v4-flash"
                };
            }

            agents.Add(new DashboardAgentInfo(
                Id: id,
                Name: string.IsNullOrWhiteSpace(name) ? DeriveRole(id) : name,
                Role: DeriveRole(id),
                Model: model,
                IsActive: isActive,
                CurrentTask: currentTask,
                Description: description,
                Tags: tags
            ));
        }
        return agents;
    }

    /// <summary>
    /// Loads agent IDs from the OpenClaw config file (openclaw.json).
    /// Falls back to the known list if the config file is unavailable.
    /// </summary>
    private List<string> LoadAgentIdsFromConfig()
    {
        try
        {
            var configPath = configuration.GetValue<string>("AgentConfigPath")
                ?? "/home/node/.openclaw/openclaw.json";

            if (!System.IO.File.Exists(configPath))
                return GetDefaultAgentIds();

            var json = System.IO.File.ReadAllText(configPath);
            using var doc = JsonDocument.Parse(json);
            var root = doc.RootElement;

            if (!root.TryGetProperty("agents", out var agentsEl))
                return GetDefaultAgentIds();
            if (!agentsEl.TryGetProperty("list", out var listEl))
                return GetDefaultAgentIds();

            var ids = new List<string>();
            foreach (var agentEl in listEl.EnumerateArray())
            {
                if (agentEl.TryGetProperty("id", out var idEl))
                {
                    var id = idEl.GetString();
                    if (!string.IsNullOrWhiteSpace(id))
                        ids.Add(id);
                }
            }

            return ids.Count > 0 ? ids : GetDefaultAgentIds();
        }
        catch
        {
            return GetDefaultAgentIds();
        }
    }

    private static List<string> GetDefaultAgentIds()
        => new() { "iris", "programmer", "reviewer", "architekt", "executor", "researcher" };

    /// <summary>
    /// Reads agent metadata from workspace files (IDENTITY.md, SOUL.md).
    /// Returns (Name, Description, Tags) — empty strings/arrays if unavailable.
    /// Tags are not read from files (kept as empty for dynamic agents).
    /// </summary>
    private async Task<(string Name, string Description, string[] Tags)> ReadAgentMetadataAsync(string agentId)
    {
        var name = string.Empty;
        var description = string.Empty;
        var tags = Array.Empty<string>();

        try
        {
            // Try the host-mounted workspace path (used by the API container)
            var workspacePath = "/mnt/workspace-" + agentId;
            var identityPath = Path.Combine(workspacePath, "IDENTITY.md");

            if (System.IO.File.Exists(identityPath))
            {
                var content = await System.IO.File.ReadAllTextAsync(identityPath);
                ParseIdentityContent(content, out name, out description);
            }
            else
            {
                // Fallback: try the OpenClaw workspace path inside the gateway container
                var altPath = "/home/node/.openclaw/workspace-" + agentId + "/IDENTITY.md";
                if (System.IO.File.Exists(altPath))
                {
                    var content = await System.IO.File.ReadAllTextAsync(altPath);
                    ParseIdentityContent(content, out name, out description);
                }
            }

            // If description is still empty, try SOUL.md
            if (string.IsNullOrWhiteSpace(description))
            {
                var soulPath = Path.Combine(workspacePath, "SOUL.md");
                string? soulContent = null;
                if (System.IO.File.Exists(soulPath))
                {
                    soulContent = await System.IO.File.ReadAllTextAsync(soulPath);
                }
                else
                {
                    var altSoulPath = "/home/node/.openclaw/workspace-" + agentId + "/SOUL.md";
                    if (System.IO.File.Exists(altSoulPath))
                    {
                        soulContent = await System.IO.File.ReadAllTextAsync(altSoulPath);
                    }
                }

                if (soulContent is not null)
                {
                    description = ExtractDescriptionFromSoul(soulContent);
                }
            }
        }
        catch
        {
            // Fallback to hardcoded values will handle this
        }

        return (name, description, tags);
    }

    /// <summary>
    /// Parses an IDENTITY.md file to extract Name and a short description (role/creature).
    /// Looks for markdown list items like "- **Name:** ...", "- **Rolle:** ...", etc.
    /// </summary>
    private static void ParseIdentityContent(string content, out string name, out string description)
    {
        name = string.Empty;
        description = string.Empty;

        using var reader = new StringReader(content);
        string? line;
        while ((line = reader.ReadLine()) is not null)
        {
            // Extract name from "- **Name:** ..."
            if (string.IsNullOrWhiteSpace(name))
            {
                var nameMarker = "- **Name:**";
                var idx = line.IndexOf(nameMarker, StringComparison.OrdinalIgnoreCase);
                if (idx >= 0)
                {
                    name = line[(idx + nameMarker.Length)..].Trim();
                    continue;
                }
            }

            // Extract role/theme from "- **Rolle:** ..." or "- **Role:** ..." or "- **Creature:** ..."
            if (string.IsNullOrWhiteSpace(description))
            {
                var descMarkers = new[] { "- **Rolle:**", "- **Role:**", "- **Creature:**" };
                foreach (var marker in descMarkers)
                {
                    var idx = line.IndexOf(marker, StringComparison.OrdinalIgnoreCase);
                    if (idx >= 0)
                    {
                        description = line[(idx + marker.Length)..].Trim();
                        break;
                    }
                }
            }
        }
    }

    /// <summary>
    /// Extracts a short description from SOUL.md (first heading or first paragraph after the "Rolle" section).
    /// Returns the first ~200 characters of meaningful content.
    /// </summary>
    private static string ExtractDescriptionFromSoul(string content)
    {
        // Look for "## Rolle" section and take the first paragraph after it
        using var reader = new StringReader(content);
        string? line;
        var inRoleSection = false;
        var paragraphs = new List<string>();

        while ((line = reader.ReadLine()) is not null)
        {
            var trimmed = line.Trim();

            if (trimmed.StartsWith("## ", StringComparison.OrdinalIgnoreCase))
            {
                if (inRoleSection)
                    break; // We've moved past the "Rolle" section

                if (trimmed.IndexOf("Rolle", StringComparison.OrdinalIgnoreCase) >= 0
                    || trimmed.IndexOf("Role", StringComparison.OrdinalIgnoreCase) >= 0)
                {
                    inRoleSection = true;
                }
                continue;
            }

            if (inRoleSection && !string.IsNullOrWhiteSpace(trimmed))
            {
                paragraphs.Add(trimmed);
                if (paragraphs.Count >= 3)
                    break;
            }
        }

        var summary = string.Join(" ", paragraphs);
        return summary.Length > 200 ? summary[..200] + "…" : summary;
    }

    public async Task<List<MessageEntry>> GetSessionHistoryAsync(
        string sessionKey, int limit = 50, int offset = 0)
    {
        var result = new List<MessageEntry>();
        try
        {
            var toolResult = await InvokeToolAsync("sessions_history", new
            {
                sessionKey, limit, offset,
                includeTools = false
            });
            if (toolResult is null)
                return result;

            var json = toolResult.ToJsonString(); result.Add(new MessageEntry("diag", "JSON[" + json.Substring(0, Math.Min(200, json.Length)) + "]", DateTimeOffset.UtcNow.ToString("o")));
            using var doc = JsonDocument.Parse(json);
            var root = doc.RootElement;

            if (!root.TryGetProperty("details", out var detailsEl))
                return result;
            if (!detailsEl.TryGetProperty("messages", out var messagesEl))
                return result;
            if (messagesEl.ValueKind != JsonValueKind.Array)
                return result;

            foreach (var msg in messagesEl.EnumerateArray())
            {
                if (!msg.TryGetProperty("role", out var roleEl))
                    continue;
                var role = roleEl.GetString() ?? "";
                if (role != "user" && role != "assistant")
                    continue;

                if (!msg.TryGetProperty("content", out var contentEl))
                    continue;
                if (contentEl.ValueKind != JsonValueKind.Array)
                    continue;

                var texts = new List<string>();
                foreach (var block in contentEl.EnumerateArray())
                {
                    if (!block.TryGetProperty("type", out var typeEl))
                        continue;
                    if (typeEl.GetString() != "text")
                        continue;
                    if (!block.TryGetProperty("text", out var textEl))
                        continue;
                    var text = textEl.GetString();
                    if (!string.IsNullOrWhiteSpace(text))
                        texts.Add(text);
                }

                if (texts.Count == 0)
                    continue;

                var content = string.Join(" ", texts).Trim();
                if (string.IsNullOrWhiteSpace(content))
                    continue;
                if (content == "REPLY_SKIP" || content == "ANNOUNCE_SKIP")
                    continue;

                var ts = DateTimeOffset.UtcNow.ToString("o");
                if (msg.TryGetProperty("timestamp", out var tsEl))
                    ts = tsEl.GetString() ?? ts;

                result.Add(new MessageEntry(role, content, ts));
            }
        }
        catch
        {
            // return whatever we collected (may be empty)
        }
        return result;
    }

    public async Task<ChatResponse> SendChatMessageAsync(string agentId, string message)
    {
        try
        {
            var result = await InvokeToolAsync("sessions_send", new { agentId, message });
            if (result is null)
                return new ChatResponse(false, null, "Gateway nicht erreichbar");

            var details = result["details"];
            var ok = (details?["status"]?.GetValue<string>()
                       ?? result["status"]?.GetValue<string>()) == "ok";
            var reply = details?["reply"]?.GetValue<string>()
                ?? result["reply"]?.GetValue<string>()
                ?? result["response"]?.GetValue<string>()
                ?? result["content"]?[0]?["text"]?.GetValue<string>();
            var error = details?["error"]?.GetValue<string>()
                ?? result["error"]?.GetValue<string>();

            return new ChatResponse(ok, reply, error);
        }
        catch (Exception ex)
        {
            return new ChatResponse(false, null, "Fehler: " + ex.Message);
        }
    }

    public async Task<List<QueueItem>> GetQueueAsync()
    {
        try
        {
            var result = await InvokeToolAsync("cron", new { action = "list" });
            if (result is null)
                return new List<QueueItem>();

            var details = result["details"];
            var jobs = details?["jobs"] as JsonArray ?? result.AsArray();
            if (jobs is null)
                return new List<QueueItem>();

            var items = new List<QueueItem>();
            foreach (var j in jobs)
            {
                if (j is null) continue;
                var id = j["id"]?.GetValue<string>() ?? "";
                var name = j["name"]?.GetValue<string>() ?? id;
                var status = j["state"]?["lastStatus"]?.GetValue<string>()
                    ?? j["status"]?.GetValue<string>()
                    ?? "unknown";
                items.Add(new QueueItem(id, name, status));
            }
            return items;
        }
        catch
        {
            return new List<QueueItem>();
        }
    }

    public async Task<DashboardStatus> GetStatusAsync()
    {
        var gatewayOk = false;
        var irisStatus = "Offline";
        var activeAgents = 0;
        var pendingTasks = 0;

        try
        {
            using var pingRequest = new HttpRequestMessage(HttpMethod.Get, "/health");
            using var pingResponse = await httpClient.SendAsync(pingRequest);
            gatewayOk = pingResponse.IsSuccessStatusCode;
        }
        catch { }

        if (gatewayOk)
        {
            try
            {
                var r = await InvokeToolAsync("session_status");
                if (r is not null)
                    irisStatus = r["status"]?.GetValue<string>()
                        ?? r["sessionKey"]?.GetValue<string>()
                        ?? "Active";
            }
            catch { }

            try
            {
                var a = await GetAgentsAsync();
                activeAgents = a.Count(x => x.IsActive);
            }
            catch { }

            try
            {
                var q = await GetQueueAsync();
                pendingTasks = q.Count;
            }
            catch { }
        }

        return new DashboardStatus(gatewayOk, irisStatus, activeAgents, pendingTasks);
    }

    public async Task<AgentModelInfo?> GetAgentModelAsync(string agentId)
    {
        try
        {
            var result = await InvokeToolAsync("session_status", new
            {
                sessionKey = $"agent:{agentId}:main"
            });
            if (result is null)
                return null;

            var model = result["model"]?.GetValue<string>();
            var provider = result["provider"]?.GetValue<string>();

            if (model is null)
                return null;

            return new AgentModelInfo(model, provider ?? "unknown");
        }
        catch
        {
            return null;
        }
    }

    public async Task<bool> SetAgentModelAsync(string agentId, string model)
    {
        try
        {
            var result = await InvokeToolAsync("session_status", new
            {
                sessionKey = $"agent:{agentId}:main",
                model
            });
            return result is not null;
        }
        catch
        {
            return false;
        }
    }

    private static string DeriveRole(string agentId) => agentId.ToLowerInvariant() switch
    {
        "iris" => "Chief of Staff",
        "programmer" => "Full-Stack Developer",
        "reviewer" => "Code Quality Assurance",
        "architekt" => "Infrastructure Architect",
        "executor" => "Host Executor",
        "researcher" => "Research & Analysis",
        "main" => "Assistant",
        _ => "Custom"
    };
}