using System.Globalization;
using System.Text;
using System.Threading.Tasks;
using Avalonia;
using Avalonia.Controls;
using Avalonia.Interactivity;
using Avalonia.Layout;
using Avalonia.Platform.Storage;
using Avalonia.VisualTree;
using XSDVisualiser.Core;
using XSDVisualiser.Desktop.ViewModels;

namespace XSDVisualiser.Desktop.Views;

public partial class LeftTreeView : UserControl
{
    public LeftTreeView()
    {
        InitializeComponent();
    }

    private async void OnCopyAsTsvClick(object? sender, RoutedEventArgs e)
    {
        // Determine the node from the menu item's DataContext
        var node = (sender as MenuItem)?.DataContext as SchemaNode;
        if (node == null)
            node =
                (sender as Control)?.GetVisualAncestors().OfType<Control>().FirstOrDefault()?.DataContext as SchemaNode;
        if (node == null)
            return;

        var tsv = BuildTsv(node);

        var topLevel = TopLevel.GetTopLevel(this);
        if (topLevel?.Clipboard != null) await topLevel.Clipboard.SetTextAsync(tsv);
    }

    private async void OnValidateAgainstXmlClick(object? sender, RoutedEventArgs e)
    {
        // Resolve node from context
        var node = (sender as MenuItem)?.DataContext as SchemaNode;
        if (node == null)
            node = (sender as Control)?.GetVisualAncestors().OfType<Control>().FirstOrDefault()?.DataContext as SchemaNode;
        if (node == null)
            return;

        var vm = DataContext as MainWindowViewModel;
        if (vm == null || string.IsNullOrEmpty(vm.CurrentFilePath))
        {
            await ShowTextDialogAsync("Validate XML", "No XSD file is currently loaded. Please open an XSD file first.");
            return;
        }

        var top = TopLevel.GetTopLevel(this);
        var sp = top?.StorageProvider;
        if (sp == null)
            return;

        var options = new FilePickerOpenOptions
        {
            Title = "Select XML file to validate",
            AllowMultiple = false,
            FileTypeFilter = new List<FilePickerFileType>
            {
                new FilePickerFileType("XML files") { Patterns = new List<string> { "*.xml" }, MimeTypes = new List<string>{"application/xml","text/xml"} },
                FilePickerFileTypes.All
            }
        };

        var files = await sp.OpenFilePickerAsync(options);
        var file = files?.FirstOrDefault();
        if (file == null) return;

        var xmlPath = await TryGetLocalPathAsync(file);
        if (string.IsNullOrEmpty(xmlPath))
        {
            await ShowTextDialogAsync("Validate XML", "The selected file is not accessible via a local path. Please choose a local XML file.");
            return;
        }

        if (string.IsNullOrEmpty(node.Name))
        {
            await ShowTextDialogAsync("Validate XML", "Selected schema node has no name and cannot be validated.");
            return;
        }

        var result = XmlValidator.ValidateAgainstElement(vm.CurrentFilePath!, node.Name!, node.Namespace, xmlPath!);

        var summary = BuildValidationSummary(node, xmlPath!, result);
        await ShowTextDialogAsync("Validation Result", summary);
    }

    private static string BuildTsv(SchemaNode root)
    {
        var sb = new StringBuilder();
        // Header
        sb.AppendLine(
            "Depth\tPath\tName\tNamespace\tTypeName\tBuiltInType\tMinOccurs\tMaxOccurs\tContentModel\tConstraints\tIsNillable");
        var initialPath = root.Name ?? string.Empty;
        AppendNode(sb, root, 0, initialPath);
        return sb.ToString();
    }

    private static void AppendNode(StringBuilder sb, SchemaNode node, int depth, string path)
    {
        string San(string? s)
        {
            if (string.IsNullOrEmpty(s)) return string.Empty;
            return s.Replace("\t", " ").Replace("\r", " ").Replace("\n", " ");
        }

        var min = node.Cardinality?.Min.ToString(CultureInfo.InvariantCulture) ?? string.Empty;
        string max;
        if (node.Cardinality?.MaxIsUnbounded == true)
            max = "unbounded";
        else
            max = node.Cardinality != null ? node.Cardinality.Max.ToString(CultureInfo.InvariantCulture) : string.Empty;

        var line = string.Join("\t", new[]
        {
            depth.ToString(CultureInfo.InvariantCulture),
            San(path),
            San(node.Name),
            San(node.Namespace),
            San(node.TypeName),
            San(node.BuiltInType),
            min,
            max,
            San(node.ContentModel),
            San(FormatConstraints(node)),
            node.IsNillable ? "true" : "false"
        });
        sb.AppendLine(line);

        if (node.Children != null)
            foreach (var child in node.Children)
            {
                var nextPathSegment = child.Name ?? string.Empty;
                var childPath = string.IsNullOrEmpty(San(path)) ? nextPathSegment : $"{path}/{nextPathSegment}";
                AppendNode(sb, child, depth + 1, childPath);
            }
    }

    private static async Task<string?> TryGetLocalPathAsync(IStorageFile file)
    {
        // Avalonia provides TryGetLocalPath extension for local files; otherwise, we can't access it via System.IO API.
        return file.TryGetLocalPath();
    }

    private static string BuildValidationSummary(SchemaNode node, string xmlPath, XmlValidationResult result)
    {
        var sb = new StringBuilder();
        sb.AppendLine($"Element: {{{node.Namespace}}}{node.Name}");
        sb.AppendLine($"XML: {xmlPath}");
        sb.AppendLine($"Valid: {(result.IsValid ? "Yes" : "No")}");
        var errors = result.Errors.ToList();
        var warnings = result.Warnings.ToList();
        sb.AppendLine($"Errors: {errors.Count}, Warnings: {warnings.Count}");
        sb.AppendLine();
        foreach (var issue in result.Issues)
        {
            var prefix = issue.Severity == System.Xml.Schema.XmlSeverityType.Error ? "Error" : "Warning";
            var loc = (issue.LineNumber > 0 || issue.LinePosition > 0) ? $" (Line {issue.LineNumber}, Pos {issue.LinePosition})" : string.Empty;
            sb.AppendLine($"- {prefix}{loc}: {issue.Message}");
        }
        return sb.ToString();
    }

    private async Task ShowTextDialogAsync(string title, string text)
    {
        var dialog = new Window
        {
            Title = title,
            Width = 700,
            Height = 500,
            CanResize = true,
            Content = new Grid
            {
                RowDefinitions = new RowDefinitions("*,Auto")
            }
        };

        // Compose content
        if (dialog.Content is Grid grid)
        {
            var textBlock = new TextBlock
            {
                Text = text,
                TextWrapping = Avalonia.Media.TextWrapping.Wrap,
                Margin = new Thickness(12)
            };
            var scroller = new ScrollViewer { Content = textBlock };

            var closeButton = new Button
            {
                Content = "Close",
                MinWidth = 80,
                HorizontalAlignment = HorizontalAlignment.Right,
                Margin = new Thickness(8)
            };
            closeButton.Click += (_, _) => dialog.Close();

            var buttonsPanel = new StackPanel
            {
                Orientation = Orientation.Horizontal,
                HorizontalAlignment = HorizontalAlignment.Right
            };
            buttonsPanel.Children.Add(closeButton);

            Grid.SetRow(buttonsPanel, 1);

            grid.Children.Add(scroller);
            grid.Children.Add(buttonsPanel);
        }

        var top = TopLevel.GetTopLevel(this);
        if (top is Window owner)
            await dialog.ShowDialog(owner);
        else
            dialog.Show();
    }

    private static string FormatConstraints(SchemaNode node)
    {
        var cons = node.Constraints?.Constraints;
        if (cons == null || cons.Count == 0) return string.Empty;

        var dict = new SortedDictionary<string, SortedSet<string>>(StringComparer.Ordinal);
        foreach (var c in cons)
        {
            var name = c.Name;
            var value = c.Value;
            if (string.IsNullOrEmpty(name) || string.IsNullOrEmpty(value)) continue;
            if (!dict.TryGetValue(name, out var set))
            {
                set = new SortedSet<string>(StringComparer.Ordinal);
                dict[name] = set;
            }

            set.Add(value);
        }

        if (dict.Count == 0) return string.Empty;

        var parts = new List<string>(dict.Count);
        foreach (var kvp in dict)
        {
            var joinedValues = string.Join(",", kvp.Value);
            parts.Add($"{kvp.Key}={joinedValues}");
        }

        return string.Join(";", parts);
    }
}