using MahApps.Metro.Controls;
using System.Diagnostics;
using System.IO;
using System.Net;
using System.Net.Http;
using System.Text;
using System.Text.Json;
using System.Text.Json.Serialization;
using System.Web;
using System.Windows;
using System.Windows.Controls;


namespace PrototypWPFHAG
{
    /// <summary>
    /// Interaktionslogik für SearchWindow.xaml
    /// </summary>
    
    public class DocumentResponse
    {
        [JsonPropertyName("documents")]
        public List<SearchResult> Documents {  get; set; }
    }
    public partial class SearchWindow : MetroWindow
    {
        public readonly HttpClient _httpClient;
        private bool _isSearchInProgress;
        private readonly PdfServiceClient _pdfServiceClient = new();
        private const string BaseUrl = "http://localhost:8000"; // Microservice-URL
        private string _selectedPdfPath;
        public SearchWindow()
        {
            InitializeComponent();
            _httpClient = new HttpClient
            {
                BaseAddress = new Uri(BaseUrl),
                Timeout = TimeSpan.FromSeconds(30)
            };
        }

        private void BackToLogIn_Click(object sender, RoutedEventArgs e)
        {
                MainWindow loginWindow = new();
                loginWindow.Show(); // Open new window
                this.Close(); // Close this window
        }
        private async void SearchButton_Click(object sender, RoutedEventArgs e)
        {
            if (_isSearchInProgress) return;

            try
            {
                _isSearchInProgress = true;
                SearchButton.IsEnabled = false;

                if (SearchByIdRadio.IsChecked == true)
                {
                    await SearchByIdAsync();
                }
                else
                {
                    await SearchByTextAsync();
                }
            }
            catch (Exception ex)
            {
                MessageBox.Show($"Fehler bei der Suche: {ex.Message}",
                              "Fehler",
                              MessageBoxButton.OK,
                              MessageBoxImage.Error);
            }
            finally
            {
                _isSearchInProgress = false;
                SearchButton.IsEnabled = true;
            }
        }
        private async Task SearchByIdAsync()
        {
            if (!int.TryParse(SearchTextBox.Text, out int documentId))
            {
                MessageBox.Show("Bitte eine gültige ID eingeben");
                return;
            }

            try
            {
                var response = await _httpClient.GetAsync($"/documents/by-id/{documentId}");
                var json = await response.Content.ReadAsStringAsync();
                var result = JsonSerializer.Deserialize<JsonElement>(json);

                // Extrahiere das Array "documents"
                var documents = result.GetProperty("documents");
                if (documents.GetArrayLength() == 0)
                {
                    MessageBox.Show("Dokument nicht gefunden");
                    return;
                }

                // Nimm das erste Element des Arrays
                var document = documents[0];

                // UI aktualisieren
                await Dispatcher.InvokeAsync(() =>
                {
                    SearchResultsListBox.ItemsSource = new List<SearchResult>
            {
                new SearchResult
                {
                    Id = document.GetProperty("id").GetInt32(),
                    Filename = document.GetProperty("filename").GetString(),
                    Content = document.GetProperty("content").GetString()
                }
            };
                    ContentTextBox.Text = document.GetProperty("content").GetString();
                });
            }
            catch (Exception ex)
            {
                MessageBox.Show($"Fehler: {ex.Message}");
            }
        }
        private async Task SearchByTextAsync()
        {
            try
            {
                var encodedQuery = Uri.EscapeDataString(SearchTextBox.Text);
                var response = await _httpClient.GetAsync($"/documents/search?query={encodedQuery}");

                var json = await response.Content.ReadAsStringAsync();
                var result = JsonSerializer.Deserialize<JsonElement>(json);

                var documents = JsonSerializer.Deserialize<List<SearchResult>>(
                    result.GetProperty("documents").GetRawText());

                MessageBox.Show($"Gefundene Dokumente: {documents?.Count}", "Debug");

                SearchResultsListBox.ItemsSource = documents;
                SearchResultsListBox.DisplayMemberPath = "Filename";
            }
            catch (Exception ex)
            {
                MessageBox.Show($"Fehler: {ex.Message}");
            }
        }



        private void PdfDropCanvas_DragEnter(object sender, DragEventArgs e)
        {
            // Nur PDF-Dateien erlauben
            if (e.Data.GetDataPresent(DataFormats.FileDrop))
            {
                var files = (string[])e.Data.GetData(DataFormats.FileDrop);
                if (files.Any(f => System.IO.Path.GetExtension(f).Equals(".pdf", StringComparison.OrdinalIgnoreCase)))
                {
                    e.Effects = DragDropEffects.Copy;
                    DropHintText.Visibility = Visibility.Collapsed; // Platzhalter ausblenden
                }
            }
            else
            {
                e.Effects = DragDropEffects.None;
            }
            e.Handled = true;
        }

        private void PdfDropCanvas_Drop(object sender, DragEventArgs e)
        {
            if (e.Data.GetDataPresent(DataFormats.FileDrop))
            {
                string[] files = (string[])e.Data.GetData(DataFormats.FileDrop);
                _selectedPdfPath = files.FirstOrDefault(f => System.IO.Path.GetExtension(f).Equals(".pdf", StringComparison.OrdinalIgnoreCase));

                if (_selectedPdfPath != null)
                {
                    // Vorschau anzeigen
                    PdfIcon.Visibility = Visibility.Visible;
                    PdfFileNameText.Text = System.IO.Path.GetFileName(_selectedPdfPath);
                    PdfFileNameText.Visibility = Visibility.Visible;
                    DropHintText.Visibility = Visibility.Collapsed;
                }
            }
        }

        // Response-Klassen
        public class ApiResponse
        {
            [JsonPropertyName("success")]
            public bool Success { get; set; }

            [JsonPropertyName("document")]
            public DocumentDetail Document { get; set; }
        }

        public class DocumentDetail
        {
            [JsonPropertyName("id")]
            public int Id { get; set; }

            [JsonPropertyName("filename")]
            public string Filename { get; set; }

            [JsonPropertyName("content")]
            public string Content { get; set; }
        }
        public class ApiError
        {
            public string Detail { get; set; }
        }

        private async void UploadButton_Click(object sender, RoutedEventArgs e)
        {
            if (string.IsNullOrEmpty(_selectedPdfPath))
            {
                MessageBox.Show("Keine PDF ausgewählt!");
                return;
            }

            // UI zurücksetzen
            UploadProgressBar.Visibility = Visibility.Visible;
            UploadProgressBar.Value = 0;
            UploadStatusText.Text = "Upload läuft...";

            try
            {
                using (var httpClient = new HttpClient())
                using (var fileStream = File.OpenRead(_selectedPdfPath))
                {
                    var progress = new Progress<float>(percent =>
                    {
                        Dispatcher.Invoke(() =>
                        {
                            UploadProgressBar.Value = percent * 100;
                            UploadStatusText.Text = $"Upload: {(int)(percent * 100)}%";
                        });
                    });

                    var content = new StreamContent(fileStream);
                    var formData = new MultipartFormDataContent();
                    formData.Add(content, "file", Path.GetFileName(_selectedPdfPath));

                    // Simulierter Fortschritt
                    for (int i = 0; i <= 100; i += 10)
                    {
                        await Task.Delay(100);
                        ((IProgress<float>)progress).Report(i / 100f);
                    }

                    var response = await httpClient.PostAsync($"{BaseUrl}/upload-pdf", formData);

                    if (response.IsSuccessStatusCode)
                    {
                        // Erfolgsmeldung anzeigen
                        UploadStatusText.Text = "Erfolgreich hochgeladen!";

                        // Canvas zurücksetzen
                        Dispatcher.Invoke(() =>
                        {
                            PdfIcon.Visibility = Visibility.Collapsed;
                            PdfFileNameText.Visibility = Visibility.Collapsed;
                            DropHintText.Visibility = Visibility.Visible;
                            _selectedPdfPath = null;
                        });

                        // Erfolgsmeldung nach 3 Sekunden ausblenden
                        await Task.Delay(3000);
                        UploadStatusText.Text = string.Empty;
                    }
                    else
                    {
                        UploadStatusText.Text = "Fehler beim Upload";
                    }
                }
            }
            catch (Exception ex)
            {
                UploadStatusText.Text = $"Fehler: {ex.Message}";
            }
            finally
            {
                UploadProgressBar.Visibility = Visibility.Collapsed;
            }
        }
        private async void DeleteButton_Click(object sender, RoutedEventArgs e)
        {
            if (SearchResultsListBox.SelectedItems.Count == 0)
            {
                MessageBox.Show("Bitte Dokumente auswählen.");
                return;
            }

            var result = MessageBox.Show(
                $"{SearchResultsListBox.SelectedItems.Count} Dokument(e) löschen?",
                "Bestätigung",
                MessageBoxButton.YesNo,
                MessageBoxImage.Warning
            );

            if (result != MessageBoxResult.Yes) return;

            var deletedIds = new List<int>();
            var errorIds = new List<int>();

            foreach (var item in SearchResultsListBox.SelectedItems.Cast<SearchResult>().ToList())
            {
                try
                {
                    var response = await _httpClient.DeleteAsync($"/documents/by-id/{item.Id}/delete");
                    if (response.IsSuccessStatusCode)
                    {
                        deletedIds.Add(item.Id);
                        Debug.WriteLine($"Gelöscht: {item.Id}");
                    }
                    else
                    {
                        errorIds.Add(item.Id);
                        var errorContent = await response.Content.ReadAsStringAsync();
                        Debug.WriteLine($"Fehler bei {item.Id}: {errorContent}");
                    }
                }
                catch (Exception ex)
                {
                    errorIds.Add(item.Id);
                    Debug.WriteLine($"Ausnahme: {ex.Message}");
                }
            }

            // Aktualisiere die Liste unabhängig vom Suchmodus
            if (SearchByIdRadio.IsChecked == true)
            {
                await SearchByIdAsync();  // Neu laden der ID-Suche
            }
            else
            {
                await SearchByTextAsync(); // Neu laden der Textsuche
            }

            // Feedback an Benutzer
            var message = new StringBuilder();
            if (deletedIds.Count > 0)
            {
                message.AppendLine($"{deletedIds.Count} Dokument(e) gelöscht.");
            }
            if (errorIds.Count > 0)
            {
                message.AppendLine($"{errorIds.Count} Dokument(e) konnten nicht gelöscht werden.");
            }
            MessageBox.Show(message.ToString());
        }

        private async void SearchResultsListBox_SelectionChanged(object sender, SelectionChangedEventArgs e)
        {
            if (SearchResultsListBox.SelectedItem is SearchResult selectedDocument)
            {
                try
                {
                    var response = await _httpClient.GetAsync($"/documents/by-id/{selectedDocument.Id}");
                    var json = await response.Content.ReadAsStringAsync();
                    var result = JsonSerializer.Deserialize<JsonElement>(json);

                    // Sicherstellen, dass das "documents" Array existiert
                    if (!result.TryGetProperty("documents", out var documents))
                    {
                        ContentTextBox.Text = "Ungültiges Antwortformat";
                        return;
                    }

                    // Sicherstellen, dass das Array mindestens ein Element hat
                    if (documents.GetArrayLength() == 0)
                    {
                        ContentTextBox.Text = "Dokument nicht gefunden";
                        return;
                    }

                    var document = documents[0];

                    // Sicherstellen, dass alle benötigten Felder existieren
                    if (!document.TryGetProperty("content", out var contentProp))
                    {
                        ContentTextBox.Text = "Dokumentinhalt fehlt";
                        return;
                    }

                    ContentTextBox.Text = contentProp.GetString();

                    Debug.WriteLine($"API-Antwort: {json}");
                }
                catch (Exception ex)
                {
                    ContentTextBox.Text = $"Fehler: {ex.Message}";
                }
            }
        }
    }
}