using Avalonia.Controls;
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Net;
using System.Net.Sockets;
using System.Reflection;
using System.Text.Json;
using System.Threading;
using System.Threading.Tasks;

namespace Avalonia_PC.Views
{
    public partial class MainWindow : Window
    {
        private const string AppScheme = "app";
        private const string? OnlineStartupUrl = null;
        private const string? LocalStartupPath = null;
        private static readonly JsonSerializerOptions BridgeJsonSerializerOptions = new()
        {
            PropertyNamingPolicy = JsonNamingPolicy.CamelCase,
        };

        private NativeWebView? _webView;
        private bool _eventsAttached;
        private object? _webViewAdapter;
        private HttpListener? _localHttpServer;
        private CancellationTokenSource? _localHttpServerCts;
        private string? _localHttpBaseUrl;
        private string? _localHttpRoot;

        public MainWindow()
        {
            InitializeComponent();

            Opened += OnOpened;
            Closed += OnClosed;
        }

        private async void OnOpened(object? sender, EventArgs e)
        {
            if (_eventsAttached)
            {
                return;
            }

            _webView = this.FindControl<NativeWebView>("WebView");
            if (_webView is null)
            {
                return;
            }

            _eventsAttached = true;
            _webView.NavigationCompleted += OnNavigationCompleted;
            _webView.WebMessageReceived += OnWebMessageReceived;
            _webView.AdapterCreated += OnAdapterCreated;

            await LoadInitialContentAsync();
        }

        private void OnAdapterCreated(object? sender, WebViewAdapterEventArgs e)
        {
            _webViewAdapter = e.GetType().GetProperty("Adapter")?.GetValue(e);
        }

        private void OnClosed(object? sender, EventArgs e)
        {
            if (_webView is not null)
            {
                _webView.NavigationCompleted -= OnNavigationCompleted;
                _webView.WebMessageReceived -= OnWebMessageReceived;
                _webView.AdapterCreated -= OnAdapterCreated;
            }

            _webViewAdapter = null;
            StopLocalHttpServer();
        }

        private async void OnNavigationCompleted(object? sender, WebViewNavigationCompletedEventArgs e)
        {
            await InjectBridgeScriptAsync();
        }

        private async void OnWebMessageReceived(object? sender, WebMessageReceivedEventArgs e)
        {
            var messageJson = e.Body;
            if (string.IsNullOrWhiteSpace(messageJson))
            {
                return;
            }

            AppResponse? response = null;

            try
            {
                using var document = JsonDocument.Parse(messageJson);
                var root = document.RootElement;

                if (!root.TryGetProperty("kind", out var kindProperty))
                {
                    return;
                }

                var kind = kindProperty.GetString();
                if (string.Equals(kind, "app-open-devtools", StringComparison.OrdinalIgnoreCase))
                {
                    TryOpenDevTools();
                    return;
                }

                if (!string.Equals(kind, "app-request", StringComparison.OrdinalIgnoreCase))
                {
                    return;
                }

                response = await HandleAppRequestAsync(root);
            }
            catch (Exception ex)
            {
                response = new AppResponse
                {
                    Kind = "app-response",
                    Id = TryGetRequestId(messageJson),
                    StatusCode = 500,
                    StatusMessage = "Internal Server Error",
                    Body = JsonSerializer.Serialize(new { success = false, error = ex.Message }),
                    Headers = CreateJsonHeaders(),
                };
            }

            if (_webView is not null && response is not null)
            {
                var responseJson = JsonSerializer.Serialize(response, BridgeJsonSerializerOptions);
                var responseJsonLiteral = JsonSerializer.Serialize(responseJson);
                await _webView.InvokeScript($"window.__dispatchAppResponse({responseJsonLiteral})");
            }
        }

        private async Task LoadInitialContentAsync()
        {
            if (_webView is null)
            {
                return;
            }

            var onlineUrl = GetConfiguredOnlineStartupUrl();
            if (onlineUrl is not null)
            {
                StopLocalHttpServer();
                _webView.Source = onlineUrl;
                return;
            }

            var localHtmlPath = GetConfiguredLocalStartupPath();
            if (string.IsNullOrWhiteSpace(localHtmlPath) || !File.Exists(localHtmlPath))
            {
                return;
            }

            var localRoot = Path.GetDirectoryName(localHtmlPath);
            if (string.IsNullOrWhiteSpace(localRoot))
            {
                return;
            }

            await EnsureLocalHttpServerStartedAsync(localRoot);
            if (string.IsNullOrWhiteSpace(_localHttpBaseUrl))
            {
                _webView.Source = new Uri(localHtmlPath);
                return;
            }

            _webView.Source = new Uri(new Uri(_localHttpBaseUrl), Path.GetFileName(localHtmlPath));
        }

        private async Task InjectBridgeScriptAsync()
        {
            if (_webView is null)
            {
                return;
            }

            const string script = """
if (!window.__appBridgeInstalled) {
    window.__appBridgeInstalled = true;
    window.isWebView2 = true;
    const pending = new Map();

    const tryOpenDevTools = () => {
        window.invokeCSharpAction(JSON.stringify({ kind: 'app-open-devtools' }));
    };

    window.__dispatchAppResponse = function(jsonStr) {
        const payload = JSON.parse(jsonStr);
        const responseId = payload.id ?? payload.Id;
        const entry = pending.get(responseId);
        if (!entry) return;
        pending.delete(responseId);
        entry.resolve(new Response(payload.body ?? payload.Body ?? '', {
            status: payload.statusCode ?? payload.StatusCode ?? 200,
            statusText: payload.statusMessage ?? payload.StatusMessage ?? 'OK',
            headers: payload.headers ?? payload.Headers ?? { 'Content-Type': 'application/json' }
        }));
    };

    const nativeFetch = window.fetch ? window.fetch.bind(window) : null;

    document.addEventListener('keydown', event => {
        if (event.key === 'F12' || (event.ctrlKey && event.shiftKey && (event.key === 'I' || event.key === 'i'))) {
            event.preventDefault();
            tryOpenDevTools();
        }
    }, true);

    document.addEventListener('contextmenu', event => {
        if (event.shiftKey) {
            event.preventDefault();
            tryOpenDevTools();
        }
    }, true);

    window.fetch = async (input, init) => {
        const request = input instanceof Request ? input : null;
        const requestUrl = typeof input === 'string' || input instanceof URL
            ? input.toString()
            : request?.url;

        if (!requestUrl || !requestUrl.startsWith('app://')) {
            if (!nativeFetch) throw new Error('window.fetch is not available.');
            return nativeFetch(input, init);
        }

        const combinedHeaders = new Headers(request?.headers);
        if (init?.headers) {
            new Headers(init.headers).forEach((value, key) => combinedHeaders.set(key, value));
        }

        const headers = {};
        combinedHeaders.forEach((value, key) => headers[key] = value);

        let body = init?.body;
        if (body === undefined && request) {
            body = await request.clone().text();
        }

        if (body && typeof body !== 'string') {
            body = await new Response(body).text();
        }

        const id = globalThis.crypto?.randomUUID?.() ?? `${Date.now()}-${Math.random()}`;
        const responsePromise = new Promise((resolve, reject) => {
            const timeoutId = setTimeout(() => {
                pending.delete(id);
                reject(new Error(`Timed out waiting for ${requestUrl}`));
            }, 30000);

            pending.set(id, {
                resolve: response => { clearTimeout(timeoutId); resolve(response); },
                reject: error => { clearTimeout(timeoutId); reject(error); }
            });
        });

        window.invokeCSharpAction(JSON.stringify({
            kind: 'app-request',
            id,
            url: requestUrl,
            method: init?.method ?? request?.method ?? 'GET',
            headers,
            body: body ?? null
        }));

        return responsePromise;
    };
}
""";

            await _webView.InvokeScript(script);
        }

        private async Task<AppResponse> HandleAppRequestAsync(JsonElement request)
        {
            var id = request.TryGetProperty("id", out var idProperty) ? idProperty.GetString() : null;
            var url = request.TryGetProperty("url", out var urlProperty) ? urlProperty.GetString() : null;
            var method = request.TryGetProperty("method", out var methodProperty) ? methodProperty.GetString() : "GET";
            var body = request.TryGetProperty("body", out var bodyProperty) ? bodyProperty.GetString() : null;
            var headers = ExtractHeaders(request);

            return await HandleAppRequestAsync(id, url, method, body, headers);
        }

        private async Task<AppResponse> HandleAppRequestAsync(
            string? id,
            string? rawUrl,
            string? method,
            string? body,
            Dictionary<string, string> headers)
        {
            var response = new AppResponse
            {
                Kind = "app-response",
                Id = id,
                StatusCode = 200,
                StatusMessage = "OK",
                Headers = CreateJsonHeaders(),
            };

            try
            {
                var uri = new Uri(rawUrl ?? throw new InvalidOperationException("请求地址不能为空。"));
                var path = uri.AbsolutePath.TrimStart('/');
                var normalizedPath = path.StartsWith("api/", StringComparison.OrdinalIgnoreCase)
                    ? path
                    : $"api/{path}";
                var authorization = GetAuthorizationHeader(headers);
                _ = authorization;

                if (string.Equals(method, "OPTIONS", StringComparison.OrdinalIgnoreCase))
                {
                    response.StatusCode = 200;
                    response.StatusMessage = "OK";
                    response.Body = JsonSerializer.Serialize(new { success = true });
                    return response;
                }

                if (string.Equals(normalizedPath, "api/getUser", StringComparison.OrdinalIgnoreCase))
                {
                    var user = await GetUserFromDatabaseAsync();
                    response.Body = JsonSerializer.Serialize(new { success = true, data = user });
                    return response;
                }

                if (string.Equals(normalizedPath, "api/processData", StringComparison.OrdinalIgnoreCase))
                {
                    var input = string.Empty;
                    if (!string.IsNullOrWhiteSpace(body))
                    {
                        using var jsonDocument = JsonDocument.Parse(body);
                        if (jsonDocument.RootElement.TryGetProperty("input", out var inputProperty))
                        {
                            input = inputProperty.GetString() ?? string.Empty;
                        }
                    }

                    var result = await ProcessDataAsync(input);
                    response.Body = JsonSerializer.Serialize(new { success = true, result });
                    return response;
                }

                response.StatusCode = 404;
                response.StatusMessage = "Not Found";
                response.Body = JsonSerializer.Serialize(new { success = false, error = "API not found" });
                return response;
            }
            catch (Exception ex)
            {
                response.StatusCode = 500;
                response.StatusMessage = "Internal Server Error";
                response.Body = JsonSerializer.Serialize(new { success = false, error = ex.Message });
                return response;
            }
        }

        private static Dictionary<string, string> CreateJsonHeaders() => new()
        {
            ["Content-Type"] = "application/json; charset=utf-8",
            ["Access-Control-Allow-Origin"] = "*",
            ["Access-Control-Allow-Methods"] = "GET, POST, OPTIONS",
            ["Access-Control-Allow-Headers"] = "Content-Type, Authorization",
        };

        private static Dictionary<string, string> ExtractHeaders(JsonElement request)
        {
            if (!request.TryGetProperty("headers", out var headersElement) ||
                headersElement.ValueKind != JsonValueKind.Object)
            {
                return new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);
            }

            var headers = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);
            foreach (var property in headersElement.EnumerateObject())
            {
                headers[property.Name] = property.Value.GetString() ?? string.Empty;
            }

            return headers;
        }

        private static string? GetAuthorizationHeader(Dictionary<string, string> headers)
        {
            return headers.FirstOrDefault(
                entry => string.Equals(entry.Key, "Authorization", StringComparison.OrdinalIgnoreCase)).Value;
        }

        private static string? TryGetRequestId(string messageJson)
        {
            try
            {
                using var document = JsonDocument.Parse(messageJson);
                return document.RootElement.TryGetProperty("id", out var idProperty) ? idProperty.GetString() : null;
            }
            catch
            {
                return null;
            }
        }

        private static Uri? GetConfiguredOnlineStartupUrl()
        {
            if (string.IsNullOrWhiteSpace(OnlineStartupUrl))
            {
                return null;
            }

            if (!Uri.TryCreate(OnlineStartupUrl, UriKind.Absolute, out var uri))
            {
                return null;
            }

            return uri.Scheme is "http" or "https" ? uri : null;
        }

        private static string? GetConfiguredLocalStartupPath()
        {
            if (!string.IsNullOrWhiteSpace(LocalStartupPath))
            {
                return Path.GetFullPath(LocalStartupPath);
            }

            return Path.Combine(AppContext.BaseDirectory, "www", "index.html");
        }

        private async Task EnsureLocalHttpServerStartedAsync(string localRoot)
        {
            if (!string.IsNullOrWhiteSpace(_localHttpBaseUrl) &&
                _localHttpServer is not null &&
                string.Equals(_localHttpRoot, localRoot, StringComparison.OrdinalIgnoreCase))
            {
                return;
            }

            StopLocalHttpServer();

            var port = GetAvailableTcpPort();
            var prefix = $"http://127.0.0.1:{port}/";

            _localHttpServerCts = new CancellationTokenSource();
            _localHttpServer = new HttpListener();
            _localHttpServer.Prefixes.Add(prefix);
            _localHttpServer.Start();
            _localHttpBaseUrl = prefix;
            _localHttpRoot = localRoot;

            _ = Task.Run(() => RunLocalHttpServerLoopAsync(_localHttpServer, _localHttpServerCts.Token, localRoot));
        }

        private static async Task RunLocalHttpServerLoopAsync(HttpListener listener, CancellationToken cancellationToken, string wwwRoot)
        {
            try
            {
                while (!cancellationToken.IsCancellationRequested)
                {
                    var context = await listener.GetContextAsync();
                    _ = Task.Run(() => HandleLocalHttpRequest(context, wwwRoot), cancellationToken);
                }
            }
            catch
            {
            }
        }

        private static async Task HandleLocalHttpRequest(HttpListenerContext context, string wwwRoot)
        {
            try
            {
                var relativePath = context.Request.Url?.AbsolutePath.TrimStart('/') ?? string.Empty;
                if (string.IsNullOrWhiteSpace(relativePath))
                {
                    relativePath = "index.html";
                }

                relativePath = relativePath.Replace('/', Path.DirectorySeparatorChar);
                var fullPath = Path.GetFullPath(Path.Combine(wwwRoot, relativePath));
                var fullRoot = Path.GetFullPath(wwwRoot);

                if (!fullPath.StartsWith(fullRoot, StringComparison.OrdinalIgnoreCase) || !File.Exists(fullPath))
                {
                    context.Response.StatusCode = 404;
                    context.Response.Close();
                    return;
                }

                context.Response.ContentType = GetContentType(fullPath);
                await using var input = File.OpenRead(fullPath);
                context.Response.ContentLength64 = input.Length;
                await input.CopyToAsync(context.Response.OutputStream);
                context.Response.OutputStream.Close();
            }
            catch
            {
                try
                {
                    context.Response.StatusCode = 500;
                    context.Response.Close();
                }
                catch
                {
                }
            }
        }

        private static string GetContentType(string filePath)
        {
            return Path.GetExtension(filePath).ToLowerInvariant() switch
            {
                ".html" => "text/html; charset=utf-8",
                ".js" => "application/javascript; charset=utf-8",
                ".css" => "text/css; charset=utf-8",
                ".json" => "application/json; charset=utf-8",
                _ => "application/octet-stream",
            };
        }

        private static int GetAvailableTcpPort()
        {
            var listener = new TcpListener(IPAddress.Loopback, 0);
            listener.Start();
            var port = ((IPEndPoint)listener.LocalEndpoint).Port;
            listener.Stop();
            return port;
        }

        private void TryOpenDevTools()
        {
            if (_webViewAdapter is null)
            {
                return;
            }

            var adapterType = _webViewAdapter.GetType();
            var method = adapterType.GetMethod("OpenDevTools", BindingFlags.Public | BindingFlags.Instance) ??
                         adapterType.GetMethod("ShowDevTools", BindingFlags.Public | BindingFlags.Instance);
            method?.Invoke(_webViewAdapter, null);
        }

        private void StopLocalHttpServer()
        {
            try
            {
                _localHttpServerCts?.Cancel();
                _localHttpServer?.Stop();
                _localHttpServer?.Close();
            }
            catch
            {
            }
            finally
            {
                _localHttpServerCts?.Dispose();
                _localHttpServerCts = null;
                _localHttpServer = null;
                _localHttpBaseUrl = null;
                _localHttpRoot = null;
            }
        }

        private static async Task<object> GetUserFromDatabaseAsync()
        {
            await Task.Delay(100);
            return new { id = 1, name = "张三", email = "zhangsan@example.com" };
        }

        private static async Task<string> ProcessDataAsync(string? input)
        {
            await Task.Delay(200);
            return $"Processed: {input?.ToUpperInvariant()}";
        }

        private sealed class AppResponse
        {
            public string Kind { get; set; } = string.Empty;

            public string? Id { get; set; }

            public int StatusCode { get; set; }

            public string StatusMessage { get; set; } = string.Empty;

            public string Body { get; set; } = string.Empty;

            public Dictionary<string, string> Headers { get; set; } = new();
        }
    }
}