using file_finder__test;
using LibVLCSharp.Shared;
using ModuleManager.Modules;
using NotVPR_SideProjecktForVpr_FreeTime;
using ShadowStream;
using ShadowStream.LogHelper;
using ShadowStream.Modules;
using ShadowStream.Obejeckte;
using ShadowStream.ObjecktForJason;
using ShadowStream.Views;
using System.Collections.Concurrent;
using System.Collections.ObjectModel;
using System.Net.Mime;
using System.Text;
using System.Text.RegularExpressions;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Input;
using System.Windows.Media;
using System.Windows.Media.Imaging;
using System.Windows.Threading;
using Brushes = System.Windows.Media.Brushes;
using Color = System.Windows.Media.Color;
using File = System.IO.File;
using Path = System.IO.Path;
using Point = System.Windows.Point;


namespace ModuleManager;

/// <summary>
/// Interaction logic for MainWindow.xaml
/// </summary>
//Quinn and Reda and Yazan
public partial class MainWindow : Window
{   //quinn
    #region no dont cahnge

    //adding base components used threw out the code
        LogWindow logWin = new LogWindow(log.GetEntries());
        static LogHelper log = new LogHelper();
        
        PlaylistEditor popupWindow;
        
        ObjListBP _playlists = new ObjListBP();
        
        private Catagory Muvie = new Catagory("Muvie");
        private Catagory Serie = new Catagory("Serie");
        private Catagory Music = new Catagory("Music");
        private Catagory Photo = new Catagory("Photos");

        private Catagory Favorites;
        
        List<string> suportedVidioFiles = new List<string>();
        List<string> suportedMusicFiles = new List<string>();
        List<string> suportedPhotoFiles = new List<string>();
        
        //root directory
        List<string> dirs = new List<string>();
        private int option = 2;
        int specificOption = 0;
        string rootPath = "M:/Media";
        
        FileScanner fileScanner;
        
        
        //video player variables
        public string _path ;
        public string _category;
        
        StringConversions stringConversions = new StringConversions();
        
        private DispatcherTimer _progressTimer;
        
    #endregion

    //Quinn
    #region vlc logic

    private LibVLC _libVLC;
    private LibVLCSharp.Shared.MediaPlayer _mediaPlayer;
    
    #endregion
    //code start
    private void MainWindow_Loaded(object sender, RoutedEventArgs e)
    {
        FirstCat?.Focus();
    }

    public MainWindow()
    {
        #region Init wpf
        InitializeComponent();
        //Initialise but Hide
        //logWin.Show();
        //logWin.Hide();
        //this.Hide();
        //Begin Login Process
        var login = new LogIn();
        login.Show();
        //login.Owner = this;
        Favorites = new Catagory("Favorites",Favorites_Home);

        #endregion
        //Quinn Dont change or remuve!!!
        #region vlc init

        Core.Initialize(); // Important: load native libvlc binaries

        _libVLC = new LibVLC();
        _mediaPlayer = new LibVLCSharp.Shared.MediaPlayer(_libVLC);

        VideoView.MediaPlayer = _mediaPlayer;

        _mediaPlayer.Volume = Convert.ToInt32(vol.Value);
        
        _progressTimer = new DispatcherTimer
        {
            Interval = TimeSpan.FromSeconds(1)
        };
        _progressTimer.Tick += ProgressTimer_Tick;

        #endregion

        #region BlutuethLogic
        InitBluetoothServer();
        #endregion

        #region only exdend. no remuving of code

        //adding all extensions... example values added
        suportedVidioFiles.Add(".mp4");
        suportedVidioFiles.Add(".mkv");
        suportedMusicFiles.Add(".wav");
        suportedMusicFiles.Add(".mp3");
        suportedPhotoFiles.Add(".jpg");
        Createscan();
        //dirs.Add("C:/");
        
        //execute and wait for task completion
        var tmp = fileScanner.ScanAllDrivesAsync();
        
        //load json parallel to finding drives
        //add code laiter
        
        tmp.Wait();
        foreach (var VARIABLE in tmp.Result)
        {
            dirs.Add(VARIABLE);
        }

        #endregion
        
        LoadSavedData();

    }
    //Quinn
    #region dont change
    //reminder to self. if issue acures. check if anyone changed folder names/or if paths are being refrenced wrongly

    #region ScannLogic

    void Createscan()
    {
        //adding all string arrays to one temp array to do the initial scan of the designated drive
        int count = 0;
        string[] tmp = new string[suportedMusicFiles.Count + suportedVidioFiles.Count + suportedPhotoFiles.Count];
        foreach (var suportedVidioFile in suportedVidioFiles)
        {
            tmp[count] = suportedVidioFile;
            count++;
        }

        foreach (var suportedMusicFile in suportedMusicFiles)
        {
            tmp[count] = suportedMusicFile;
            count++;
        }
        
        foreach (var suportedPhotoFile in suportedPhotoFiles)
        {
            tmp[count] = suportedPhotoFile;
            count++;
        }
        //initialise the file scanner with all files endings wanted
        fileScanner = new FileScanner(tmp); 
    }
    
        
    #endregion
    
    #region Click Methods
        //-_- warum klapt es nicht
        private ProgressBar progressScann;
        private void OnItemPlayButtonClick(object sender, RoutedEventArgs e)
        {
            
            if (sender is Button btn && btn.Tag is string filePath)
            {
                string[] parts = filePath.Split("||");
                string left = parts[0];
                PlayVideo(left);
            }
        }
        private void OnItemNextButtonClick(object sender, RoutedEventArgs e)
        {
            setStrings();
            switch (_category.ToLower())
            {
                case "muvie":
                    videoArrows(ref Muvie,true); break;
                case "serie":
                    videoArrows(ref Serie,true);break;
                case "music":
                    videoArrows(ref Music,true); break;
                case "photos":
                    videoArrows(ref Photo,true); break;
                default:
                    break;
            }
        }
        private void OnItemPriorButtonClick(object sender, RoutedEventArgs e)
        {
            setStrings();
            switch (_category.ToLower())
            {
                case "muvie":
                    videoArrows(ref Muvie,false); break;
                case "serie":
                    videoArrows(ref Serie,false);break;
                case "music":
                    videoArrows(ref Music,false); break;
                case "photos":
                    videoArrows(ref Photo,false); break;
                default:
                    break;
            }
        }

        private void OnItemPauseBtn_Click(object sender, RoutedEventArgs e)
        {
            if (_mediaPlayer.IsPlaying)
            {
                _mediaPlayer.Pause(); // Pauses the video
            }
            else
            {
                _mediaPlayer.SetPause(false); // Unpauses the video
            }
        }

        private void Close_Player(object sender, RoutedEventArgs e)
        {
            _mediaPlayer.Stop();
            VideoView.Visibility = Visibility.Collapsed;
        }
        
        
        private async void scanButton_Click(object sender, RoutedEventArgs e)
        {
            try
            {
                MessageBoxResult result =
                    MessageBox.Show(
                        "Do you want to replace existing items\nyes will delite existing items/no keeps them",
                        "replace items", MessageBoxButton.YesNoCancel);
                
                if (result == MessageBoxResult.Cancel)
                    return;
                else if (result == MessageBoxResult.Yes)
                {
                    Muvie.clear();
                    Serie.clear();
                    Music.clear();
                    Photo.clear();
                }
                
                
                log.Log("Scanning files...");
                
                List<string> tmp = new List<string>();

                switch (option)
                {
                    case 0:
                        foreach (var VARIABLE in dirs)
                        {
                            var scanResult = await fileScanner.ScanDriveParallel(VARIABLE);
                            tmp.AddRange(scanResult);
                        }
                        break;
                    case 1:
                        var scanResult1 = await fileScanner.ScanDriveParallel(dirs[specificOption]);
                        tmp.AddRange(scanResult1);
                        break;
                    case 2:
                        var scanResult2 = await fileScanner.ScanDriveParallel(rootPath);
                        tmp.AddRange(scanResult2);
                        break;
                }

                log.Log($"Total scanned files: {tmp.Count}");

                var classifier = new FileClassifier();
                var (musicFiles, videoFiles, photoFiles) = await classifier.ClassifyFilesAsync(tmp, suportedMusicFiles, suportedVidioFiles, suportedPhotoFiles);

                var separator = new VideoSeparator();
                var (series, movies) = await separator.SeparateVideosAsync(videoFiles);

                log.Log($"musicFiles count: {musicFiles.Count}");
                log.Log($"videoFiles count: {videoFiles.Count}");
                log.Log($"photoFiles count: {photoFiles.Count}");
                log.Log($"series count: {series.Count}");
                log.Log($"movies count: {movies.Count}");

                Console.WriteLine($"Total scanned files: {tmp.Count}");
                Console.WriteLine($"Total video files: {videoFiles.Count}");

                Console.WriteLine($"Total musicFiles count: {musicFiles.Count}");
                Console.WriteLine($"Total photo files: {photoFiles.Count}");
                Console.WriteLine($"Total series count: {series.Count}");
                Console.WriteLine($"Total muvies count: {movies.Count}");

                if (result == MessageBoxResult.No)
                {
                    var tmp2 = new List<string>();
                    foreach (var VARIABLE in musicFiles)
                    {
                        if (!Music.getLink().Contains(VARIABLE)) ;
                            tmp2.Add(VARIABLE);
                    }
                    musicFiles.Clear();
                    musicFiles.AddRange(tmp2);
                    tmp2.Clear();
                    foreach (var VARIABLE in series)
                    {
                        if (!Serie.getLink().Contains(VARIABLE)) ;
                            tmp2.Add(VARIABLE);
                    }
                    series.Clear();
                    series.AddRange(tmp2);
                    tmp2.Clear();
                    foreach (var VARIABLE in movies)
                    {
                        if(!Muvie.getLink().Contains(VARIABLE)) ;
                            tmp2.Add(VARIABLE);
                    }
                    movies.Clear();
                    movies.AddRange(tmp2);
                    tmp2.Clear();
                    foreach (var VARIABLE in photoFiles)
                    {
                        if(!Photo.getLink().Contains(VARIABLE))
                            tmp2.Add(VARIABLE);
                    }
                    photoFiles.Clear();
                    photoFiles.AddRange(tmp2);
                    tmp2.Clear();
                }
                

                progressScann = new ProgressBar("ImageGen", musicFiles.Count + videoFiles.Count + photoFiles.Count);
                progressScann.Show();
                videoFiles = null;

                log.Log("files sorted");

                List<locJason> muviesJS = new List<locJason>();
                List<locJason> seriesJS = new List<locJason>();
                List<locJason> photosJS = new List<locJason>();
                List<locJason> musicJS = new List<locJason>();

                JasonToString jasonToString = new JasonToString();

                var movieItems = await ItemCreater(movies, "Muvie", false);
                foreach (var item in movieItems)
                {
                    BitmapImage bitmapImage = item.getImage();
                    if (bitmapImage != null)
                    {
                        try
                        {
                            string base64Image = jasonToString.BitmapToBase64String(
                                                    BitmapConversions.BitmapImageToBitmap(bitmapImage));
                            Muvie.addItem(item);
                            muviesJS.Add(new locJason
                            {
                                path = item.getLink(),
                                imageData = base64Image,
                                type = item.getType()
                            });
                        }
                        catch (Exception exception)
                        {
                            Console.WriteLine($"Error processing movie item {item.getLink()}: {exception.Message}");
                            log.Error($"Error processing movie item {item.getLink()}: {exception}");
                        }
                    }
                    else
                    {
                        Console.WriteLine($"Warning: Movie item {item.getLink()} has no image data.");
                        log.Log($"Warning: Movie item {item.getLink()} has no image data.");
                    }
                }

                var seriesItems = await ItemCreater(series, "Serie", false);
                foreach (var item in seriesItems)
                {
                    BitmapImage bitmapImage = item.getImage();
                    if (bitmapImage != null)
                    {
                        try
                        {
                            string base64Image = jasonToString.BitmapToBase64String(
                                                    BitmapConversions.BitmapImageToBitmap(bitmapImage));
                            Serie.addItem(item);
                            seriesJS.Add(new locJason
                            {
                                path = item.getLink(),
                                imageData = base64Image,
                                type = item.getType()
                            });
                        }
                        catch (Exception exception)
                        {
                            Console.WriteLine($"Error processing series item {item.getLink()}: {exception.Message}");
                            log.Error($"Error processing series item {item.getLink()}: {exception}");
                        }
                    }
                    else
                    {
                        Console.WriteLine($"Warning: Series item {item.getLink()} has no image data.");
                        log.Log($"Warning: Series item {item.getLink()} has no image data.");
                    }
                }

                var photoItems = await ItemCreater(photoFiles, "Photo", true);
                foreach (var item in photoItems)
                {
                    BitmapImage bitmapImage = item.getImage();
                    if (bitmapImage != null)
                    {
                        try
                        {
                            string base64Image = jasonToString.BitmapToBase64String(
                                                    BitmapConversions.BitmapImageToBitmap(bitmapImage));
                            Photo.addItem(item);
                            photosJS.Add(new locJason
                            {
                                path = item.getLink(),
                                imageData = base64Image,
                                type = item.getType()
                            });
                        }
                        catch (Exception exception)
                        {
                            Console.WriteLine($"Error processing photo item {item.getLink()}: {exception.Message}");
                            log.Error($"Error processing photo item {item.getLink()}: {exception}");
                        }
                    }
                    else
                    {
                        Console.WriteLine($"Warning: Photo item {item.getLink()} has no image data.");
                        log.Log($"Warning: Photo item {item.getLink()} has no image data.");
                    }
                }

                var musicItems = await ItemCreater(musicFiles, "Music", false);
                foreach (var item in musicItems)
                {
                    BitmapImage bitmapImage = item.getImage();
                    if (bitmapImage != null)
                    {
                        try
                        {
                            string base64Image = jasonToString.BitmapToBase64String(
                                                    BitmapConversions.BitmapImageToBitmap(bitmapImage));
                            Music.addItem(item);
                            musicJS.Add(new locJason
                            {
                                path = item.getLink(),
                                imageData = base64Image,
                                type = item.getType()
                            });
                        }
                        catch (Exception exception)
                        {
                            Console.WriteLine($"Error processing music item {item.getLink()}: {exception.Message}");
                            log.Error($"Error processing music item {item.getLink()}: {exception}");
                        }
                    }
                    else
                    {
                        Console.WriteLine($"Info: Music item {item.getLink()} has no image data.");
                        log.Log($"Info: Music item {item.getLink()} has no image data.");
                    }
                }

                log.Log("scan finished");

                Jason_Writer jason_Writer = new Jason_Writer();
                List<Task> tasks = new List<Task>
                {
                    jason_Writer.SaveList("Muvies", muviesJS),
                    jason_Writer.SaveList("Series", seriesJS),
                    jason_Writer.SaveList("Photos", photosJS),
                    jason_Writer.SaveList("Music", musicJS)
                };

                await Task.WhenAll(tasks);

                musicJS = null;
                seriesJS = null;
                photosJS = null;

                MenueItems();
                progressScann.Hide();
                MessageBox.Show("Scan finished");
            }
            catch (Exception ex)
            {
                MessageBox.Show($"An error occurred during scanning:\n\n{ex.Message}", "Error", MessageBoxButton.OK, MessageBoxImage.Error);
                log.Error($"An error occurred during scanning:\n\n{ex}");
            }
        }

        private void PlayListButton_Click(object sender, RoutedEventArgs e)
        {
            ObservableCollection<Catagory> tmpBP= new ObservableCollection<Catagory>();
            tmpBP.Add(Muvie);
            tmpBP.Add(Serie);
            tmpBP.Add(Photo);
            tmpBP.Add(Music);
            popupWindow = new PlaylistEditor(tmpBP,false,false);
            popupWindow.Owner = this;
            popupWindow.ShowInTaskbar = false;
            popupWindow.Show();
        }

        private void EdditFav_Click(object sender, RoutedEventArgs e)
        {
            ObservableCollection<Catagory> tmpBP= new ObservableCollection<Catagory>();
            tmpBP.Add(Muvie);
            tmpBP.Add(Serie);
            tmpBP.Add(Photo);
            tmpBP.Add(Music);
            popupWindow = new PlaylistEditor(tmpBP,true,true,Favorites);
            popupWindow.Owner = this;
            popupWindow.ShowInTaskbar = false;
            popupWindow.Show();
        }
        
        

        #region Catagory btns
        private void Home_OnClick(object sender, RoutedEventArgs e)
        {
            Close_Player();
            ScrollContentPlaylist.Visibility = Visibility.Collapsed;
            ScrollContentCat.Visibility = Visibility.Collapsed;
            ScrollContentHome.Visibility = Visibility.Visible;
            MenueItems();
            SetInitialFocusForCurrentView();
        }
        private void Musik_OnClick(object sender, RoutedEventArgs e)
        {
            Close_Player();
            Name_of_Catagory_Text1.Visibility = Visibility.Collapsed;
            ScrollContentPlaylist.Visibility = Visibility.Collapsed;
            
            ScrollContentHome.Visibility = Visibility.Collapsed;
            ScrollContentCat.Visibility = Visibility.Visible;
            Name_of_Catagory1.Visibility = Visibility.Collapsed;
            MenueItems(ref Music);
            SetInitialFocusForCurrentView();
        }
        private void Photo_OnClick(object sender, RoutedEventArgs e)
        {
            Close_Player();
            Name_of_Catagory_Text1.Visibility = Visibility.Collapsed;
            ScrollContentPlaylist.Visibility = Visibility.Collapsed;
            
            ScrollContentHome.Visibility = Visibility.Collapsed;
            ScrollContentCat.Visibility = Visibility.Visible;
            Name_of_Catagory1.Visibility = Visibility.Collapsed;
            MenueItems(ref Photo);
            SetInitialFocusForCurrentView();
        }
        private void Video_OnClick(object sender, RoutedEventArgs e)
        {
            Close_Player();
            Name_of_Catagory_Text1.Visibility = Visibility.Visible;
            ScrollContentPlaylist.Visibility = Visibility.Collapsed;
            ScrollContentHome.Visibility = Visibility.Collapsed;
            ScrollContentCat.Visibility = Visibility.Visible;
            Name_of_Catagory1.Visibility = Visibility.Visible;
            MenueItems(ref Muvie,ref Serie);
            SetInitialFocusForCurrentView();
        }
        private void PlayListButton_OnClick(object sender, RoutedEventArgs e)
        {
            Close_Player();
            Name_of_Catagory_Text1.Visibility = Visibility.Collapsed;

            ScrollContentHome.Visibility = Visibility.Collapsed;
            ScrollContentCat.Visibility = Visibility.Collapsed;
            Name_of_Catagory1.Visibility = Visibility.Collapsed;

            PopulateAllCategoriesFromPlaylists();  // <-- This needs to set ScrollContentPlaylist visible

            SetInitialFocusForCurrentView();
        }

        
    #endregion

    #endregion
            
    #region itemCreation

    public async Task<List<Item>> ItemCreater(List<string> paths, string type, bool isFoto)
{
    // Determine if it's music based on 'type' string
    bool isMusic = (type == "Music"); 

    // Semaphore for concurrency control
    var semaphore = new SemaphoreSlim(Math.Max(1, Environment.ProcessorCount / 2));
    // ConcurrentBag for thread-safe collection of items
    var itemsBag = new ConcurrentBag<Item>(); 

    // Pre-load default music image once, if applicable
    BitmapImage defaultMusicImage = null;
    if (isMusic)
    {
        string baseDir = AppDomain.CurrentDomain.BaseDirectory;
        string imagePath = System.IO.Path.Combine(baseDir, "Resources", "Pics", "MusicD.jpeg");

        if (System.IO.File.Exists(imagePath))
        {
            try
            {
                await Application.Current.Dispatcher.InvokeAsync(() =>
                {
                    defaultMusicImage = new BitmapImage(new Uri(imagePath));
                    defaultMusicImage.DecodePixelWidth = 150;
                    defaultMusicImage.DecodePixelHeight = 100;
                    defaultMusicImage.Freeze(); // Crucial for cross-thread access
                });
            }
            catch (Exception ex)
            {
                // Log error if default image itself cannot be loaded
                Console.WriteLine($"Error loading default music image {imagePath}: {ex.Message}");
                // Consider adding to your specific logger here: log.Error(...)
                defaultMusicImage = null;
            }
        }
        else
        {
            // Inform the user if the default image is missing
            MessageBox.Show($"Default music image not found at: {imagePath}");
            // Consider adding to your specific logger here: log.Error(...)
        }
    }

    // Create a list of tasks, one for each path
    var tasks = paths.Select(async path =>
    {
        await semaphore.WaitAsync(); // Acquire a slot from the semaphore
        BitmapImage bitmapImage = null; // To hold the image for the current item
        Item newItem = null; // The Item object to be created

        try
        {
            if (isMusic) // Logic for Music files: extract album art or use default
            {
                bitmapImage = defaultMusicImage; // Start with the default image

                TagLib.File file = null; // TagLib.File object for disposing
                try
                {
                    file = TagLib.File.Create(path); // Create TagLib file instance
                    if (file.Tag.Pictures.Length > 0) // Check if album art exists
                    {
                        var pic = file.Tag.Pictures[0];
                        var ms = new System.IO.MemoryStream(pic.Data.Data); // Get image data as MemoryStream

                        await Application.Current.Dispatcher.InvokeAsync(() =>
                        {
                            var img = new BitmapImage();
                            img.BeginInit();
                            img.CacheOption = BitmapCacheOption.OnLoad; // Load full image data
                            ms.Position = 0; // Reset stream position
                            img.StreamSource = ms; // Set image source from stream
                            img.EndInit();
                            img.Freeze(); // Make immutable for performance
                            img.DecodePixelWidth = 150;
                            img.DecodePixelHeight = 100;
                            bitmapImage = img; // Overwrite default with extracted cover
                        });
                        ms.Dispose(); // Dispose MemoryStream
                    }
                }
                catch (Exception tagLibEx)
                {
                    // Catch errors during TagLib processing (e.g., corrupted file, unsupported format)
                    Console.WriteLine($"Error extracting album art for {path}: {tagLibEx.Message}");
                    // Consider adding to your specific logger here: log.Error(...)
                    // bitmapImage remains defaultMusicImage or null if default also failed
                }
                finally
                {
                    file?.Dispose(); // Ensure TagLib.File is disposed to release file locks
                }
            }
            else if (isFoto) // Logic for Photo files: direct image loading
            {
                try
                {
                    await Application.Current.Dispatcher.InvokeAsync(() =>
                    {
                        bitmapImage = new BitmapImage();
                        bitmapImage.BeginInit();
                        bitmapImage.CacheOption = BitmapCacheOption.OnLoad; // Load full image data
                        bitmapImage.UriSource = new Uri(path, UriKind.Absolute); // Set URI source
                        bitmapImage.DecodePixelWidth = 150;
                        bitmapImage.DecodePixelHeight = 100;
                        bitmapImage.EndInit();
                        bitmapImage.Freeze(); // Make immutable
                    });
                }
                catch (Exception ex)
                {
                    // Catch errors during photo image loading
                    Console.WriteLine($"Error loading photo image {path}: {ex.Message}");
                    // Consider adding to your specific logger here: log.Error(...)
                    bitmapImage = null; // Set image to null on failure
                }
            }
            else // Logic for Video files: using VideoFrameExtractor
            {
                // VideoFrameExtractor.GetFrame200 should return null on failure (as previously discussed)
                bitmapImage = await Task.Run(() => VideoFrameExtractor.GetFrame200(path));
            }

            // Create the Item object on the UI thread
            await Application.Current.Dispatcher.InvokeAsync(() =>
            {
                // newItem will have the extracted image, default image, or null if all failed
                newItem = new Item(path, type, bitmapImage, isFoto, OnItemPlayButtonClick);
            });

            itemsBag.Add(newItem); // Add the created item to the thread-safe bag
            Application.Current.Dispatcher.Invoke(() => progressScann.UpdateProgress(1)); // Update progress on UI thread
        }
        catch (Exception ex)
        {
            // Catch any unexpected exceptions during the processing of a single item
            Console.WriteLine($"Unexpected error processing item {path}: {ex.Message}");
            // Consider adding to your specific logger here: log.Error(...)

            // Create a fallback Item with a null image to ensure the task completes
            await Application.Current.Dispatcher.InvokeAsync(() =>
            {
                newItem = new Item(path, type, null, isFoto, OnItemPlayButtonClick);
            });
            itemsBag.Add(newItem); // Add this fallback item
            Application.Current.Dispatcher.Invoke(() => progressScann.UpdateProgress(1)); // Still update progress
        }
        finally
        {
            semaphore.Release(); // Release the semaphore slot regardless of success or failure
        }
        return newItem; // Return the processed item (can have null image)
    }).ToList(); // Convert the collection of tasks to a List<Task<Item>>

    // Wait for all individual item processing tasks to complete
    await Task.WhenAll(tasks);

    // Convert the ConcurrentBag to a List and return
    return itemsBag.ToList();
}

    #endregion
    
    #region Comunication
    public void ReciveErrorLog(string logMessage)
    {
        log.Error(logMessage);
    }
    public void PlayVideo(string filePath)
    {   
        if(suportedVidioFiles.Contains(Path.GetExtension(filePath))||suportedPhotoFiles.Contains(Path.GetExtension(filePath)))
            VideoView.Visibility = Visibility.Visible;
        var media = new Media(_libVLC, filePath, FromType.FromPath);
        Console.WriteLine(filePath);
        media.ParsedChanged += (sender, args) =>
        {
            if (args.ParsedStatus == MediaParsedStatus.Done)
            {
                Dispatcher.Invoke(() =>
                {
                    var duration = media.Duration;
                    Console.WriteLine(duration);
                    videoSliderInit(duration / 1000);
                    title.Text=Path.GetFileNameWithoutExtension(filePath);
                });
            }
        };
        media.Parse(MediaParseOptions.ParseLocal);
        _mediaPlayer.Play(media);
    }
    public void setStrings()
    {
        #region type?
        var currentMedia = _mediaPlayer?.Media;

        if (currentMedia != null)
        {
            var mrl = currentMedia.Mrl; // This is the media resource locator
            _path = new Uri(mrl).LocalPath;;
            _path = stringConversions.ReplaceFirst(_path, '/', '\\');

            Console.WriteLine("Now Playing Path: " + _path);
        }
        if (_mediaPlayer.IsPlaying)
        {
            _mediaPlayer.Stop();
        }

        

        if (suportedMusicFiles.Any(keyword => _path.Contains(keyword, StringComparison.OrdinalIgnoreCase)))
        {
            _category = "music";
        }
        else if (suportedPhotoFiles.Any(keyword => _path.Contains(keyword, StringComparison.OrdinalIgnoreCase)))
        {
            _category = "photos";
        }
        else
        {
            
            if (Regex.IsMatch(_path, @"\b(E|EP|Ep|e|ep)\d+\b", RegexOptions.IgnoreCase))
            {
                _category = "serie";
            }
            else
            {
                _category = "muvie";
            }
        }
        
        log.Log($"replacing: {_path} from {_category}");
        #endregion
    }
    public void videoArrows(ref Catagory catagory, bool next)
    {
        catagory = catagory as Catagory;
        var items = catagory?.getAllItems();
    
        if (catagory == null || items == null)
        {
            MessageBox.Show("Category or items are null");
            return;
        }

        int tmp = catagory.contains(_path);
        if (tmp == -1 || tmp >= items.Count)
        {
            MessageBox.Show("Current item not found in category");
            return;
        }

        Media media = null;
        int newIndex =0;

        if (next)
        {
            if (tmp + 1 < items.Count)
            {
                var link = items[tmp + 1]?.getLink();
                if (!string.IsNullOrEmpty(link))
                    media = new Media(_libVLC, link, FromType.FromPath);
            }
        }
        if (!next)
        {
            newIndex = (tmp - 1 >= 0) ? tmp - 1 : items.Count - 1;  // wrap around
            var link = items[newIndex]?.getLink();
            Console.WriteLine(link);
            if (!string.IsNullOrEmpty(link))
                media = new Media(_libVLC, link, FromType.FromPath);
        }


        if (media != null)
        {
            _mediaPlayer.Play(media);
            title.Text = items[newIndex].Name.ToString();
        }
        else
            MessageBox.Show("Could not load media. Media or link is null.");
    }
    private void Close_Player()
    {
        _mediaPlayer.Stop();
        VideoView.Visibility = Visibility.Collapsed;
    }

    public void RecivePlaylist(Catagory items)
    {
        _playlists.SharedRefs.Add(items);
        RecivePlaylist();
        var writer = new Jason_Writer();
        var tmp = new List<locJasonPlaylist>();
        int index = 0;
        foreach (var VARIABLE in items.getAllItems())
        {
            tmp.Add(new locJasonPlaylist());
            tmp[index].name = VARIABLE.Name;
            tmp[index].path = VARIABLE.Path;
            tmp[index].type = VARIABLE.Type;
            index++;
        }
        writer.SavePlaylistListAsync(items.name,tmp);
        Console.WriteLine("wrote"+items.name);
    }
    public void RecivePlaylist(Catagory items,bool favorite)
    {
        if (favorite)
        {
            Favorites.clear();
            foreach (var VARIABLE in items.getAllItems())
            {
                Favorites.addItem(VARIABLE);
            }
        }
        else
        {
            foreach (var VARIABLE in _playlists.SharedRefs)
            {
                if (VARIABLE.name == items.name)
                {
                    
                    VARIABLE.clear();
                    foreach (var var2 in items.getAllItems())
                    {
                        VARIABLE.addItem(var2);
                    }
                    break;
                }
            }
            
        }
        RecivePlaylist();
        var writer = new Jason_Writer();
        var tmp = new List<locJasonPlaylist>();
        int index = 0;
        foreach (var VARIABLE in items.getAllItems())
        {
            tmp.Add(new locJasonPlaylist());
            tmp[index].name = VARIABLE.Name;
            tmp[index].path = VARIABLE.Path;
            tmp[index].type = VARIABLE.Type;
            index++;
        }
        writer.SavePlaylistListAsync(items.name,tmp);
        Console.WriteLine("faf updated");
        if (favorite)
            Application.Current.Dispatcher.Invoke(() =>
            {
                MenueItems(); // safely update UI
            });


        foreach (var VARIABLE in items.getAllItems())
        {
            Console.WriteLine(VARIABLE.Name);
        }
    }
    public void RecivePlaylist()
    {
        popupWindow.Close();
    }
    
    private void PopulateAllCategoriesFromPlaylists()
    {
        PlaylistContentPanel.Children.Clear(); // Optional: clear previous entries

        foreach (Catagory category in _playlists.SharedRefs)
        {
            // Create TextBlock for category name
            var textBlock = new TextBlock
            {
                Text = category.name,
                FontSize = 18,
                Foreground = Brushes.White,
                Margin = new Thickness(0, 10, 0, 5)
            };

            // Create WrapPanel for items
            var wrapPanel = new WrapPanel
            {
                Margin = new Thickness(0, 0, 0, 10)
            };

            // Fill WrapPanel with items
            PopulatePanelWithItems(category.getAllItems(), wrapPanel);

            // Add both to the ScrollViewer's inner panel
            PlaylistContentPanel.Children.Add(textBlock);
            PlaylistContentPanel.Children.Add(wrapPanel);
        }

        // Make the ScrollViewer visible
        ScrollContentPlaylist.Visibility = Visibility.Visible;
        
        PopulatePlaylistsWithButtons();
    }

    #region tvRemote
    BluetoothServer Server1;
    private void InitBluetoothServer()
    {
        Server1 = new BluetoothServer();

        Server1.ClientConnected += () =>
        {
            Dispatcher.Invoke(() =>
            {
                MessageBox.Show("🔗 Client connected!");
                
            });
        };

        Server1.MessageReceived += (msg) =>
        {
            Dispatcher.BeginInvoke(new Action(()=>
            {
                //MessageBox.Show($"📨 Message: {msg.Trim()}");
                switch (msg.Trim())
                {
                    // Arrow Up
                    case "↑": // \u2191
                        var keyEventArgs = new KeyEventArgs(
                                Keyboard.PrimaryDevice,
                                PresentationSource.FromVisual(this),
                                0,
                                Key.Up)
                            {
                                RoutedEvent = Keyboard.PreviewKeyDownEvent
                            };

                        this.RaiseEvent(keyEventArgs);
                        
                        break;

                    // Arrow Down
                    case "↓": // \u2193
                        var keyEventArgs2 = new KeyEventArgs(
                                Keyboard.PrimaryDevice,
                                PresentationSource.FromVisual(this),
                                0,
                                Key.Down)
                            {
                                RoutedEvent = Keyboard.PreviewKeyDownEvent
                            };

                        this.RaiseEvent(keyEventArgs2);
                        break;

                    // Arrow Left
                    case "←": // \u2190
                        var keyEventArgs3 = new KeyEventArgs(
                                Keyboard.PrimaryDevice,
                                PresentationSource.FromVisual(this),
                                0,
                                Key.Left)
                            {
                                RoutedEvent = Keyboard.PreviewKeyDownEvent
                            };

                        this.RaiseEvent(keyEventArgs3);
                        break;

                    // Arrow Right
                    case "→": // \u2192
                        var keyEventArgs4 = new KeyEventArgs(
                                Keyboard.PrimaryDevice,
                                PresentationSource.FromVisual(this),
                                0,
                                Key.Right)
                            {
                                RoutedEvent = Keyboard.PreviewKeyDownEvent
                            };

                        this.RaiseEvent(keyEventArgs4);
                        break;

                    // Double Left
                    case "⇚": // \u21DA
                        var clickEventArgs1 = new RoutedEventArgs(Button.ClickEvent);
                        prior.RaiseEvent(clickEventArgs1);
                        break;

                    // Double Right
                    case "⇛": // \u21DB
                        var clickEventArgs2 = new RoutedEventArgs(Button.ClickEvent);
                        next.RaiseEvent(clickEventArgs2);

                        break;
                    // Center button (Dot)
                    case "●":
                        Dispatcher.BeginInvoke(new Action(() =>
                        {
                            if (_mediaPlayer.IsPlaying)
                            {
                                // Simulate pause
                                OnItemPauseBtn_Click(null, null);
                            }
                            else
                            {
                                // Simulate item selection
                                var focused = Keyboard.FocusedElement as Button;
                                focused?.RaiseEvent(new RoutedEventArgs(Button.ClickEvent));
                            }
                        }));
                        break;

                    case "Vol -":
                        if(_mediaPlayer.Volume>10)
                            _mediaPlayer.Volume = _mediaPlayer.Volume - 10;
                        else
                            _mediaPlayer.Volume = 10;
                        vol.Value = _mediaPlayer.Volume;
                        break;
                    case "Vol +":
                        if(_mediaPlayer.Volume<90)
                            _mediaPlayer.Volume = _mediaPlayer.Volume + 10;
                        else
                            _mediaPlayer.Volume = 100;
                        vol.Value = _mediaPlayer.Volume;
                        break;   
                    case string s when s.StartsWith("Time:"):
                        string valuePart = s.Substring("Time:".Length);
                        if (double.TryParse(valuePart, out double timeValue))
                        {
                            _mediaPlayer.Time= Convert.ToInt32(valuePart);;
                        }
                        else
                        {
                            MessageBox.Show("Invalid time format.");
                        }
                        break;
                    default:
                        MessageBox.Show($"Unrecognized input: '{msg}'");
                        break;
                }
                Console.WriteLine(msg+":recived");

            }));
                

            // Optional: echo back the message
            Server1.SendMessage("Echo: " + msg.Trim());
        };

        Server1.ErrorOccurred += (err) =>
        {
            Dispatcher.Invoke(() =>
            {
                MessageBox.Show($"⚠️ Error: {err}");
            });
        };

        // Start server in background
        new Thread(() => Server1.Init())
        {
            IsBackground = true
        }.Start();
    }


    #endregion
    #endregion

    #endregion

    #region Menue


    void MenueItems(ref  Catagory catagory)
    {
        PopulatePanelWithItemsCatagorised(Name_of_Catagory,ref catagory);
    }
    void MenueItems(ref  Catagory catagory,ref Catagory catagory1)
    {
        PopulatePanelWithItemsCatagorised(Name_of_Catagory,ref catagory);
        PopulatePanelWithItemsCatagorised(Name_of_Catagory1,ref catagory1);
    }    
    void MenueItems()
    {
        PopulatePanelWithItems(Favorites.getAllItems(), Favorites_Home);
        PopulatePanelWithItems(Muvie.getAllItems(), Muvies_Home);
        PopulatePanelWithItems(Serie.getAllItems(), Series_Home);
        PopulatePanelWithItems(Photo.getAllItems(), Photos_Home);
        PopulatePanelWithItems(Music.getAllItems(), Music_Home);
    }
    #endregion

    #region PanelPop

        private void PopulatePanelWithItemsCatagorised(Panel targetPanel,ref Catagory catagory)
        {
            if (catagory.name == "Serie")
            {
                Name_of_Catagory_Text1.Text = catagory.name;
            }
            else
            {
                Name_of_Catagory_Text.Text = catagory.name;
            }
            PopulatePanelWithItems(catagory.getAllItems(),targetPanel);
        }
        private void PopulatePanelWithItems(List<Item> items, Panel targetPanel)
        {
            targetPanel.Children.Clear();
            byte tmp = 0;
            foreach (var item in items)
            {
                if(tmp >= 10)
                    break;
                if (ScrollContentHome.Visibility == Visibility.Visible)
                    tmp++;
                if (tmp < 10)
                {
                    var name = item.getName();
                var image = item.getImage();
                var isFoto = item.getType() == "Photo";
                var path = item.getLink();
                var buttonText = isFoto ? "Show" : "Play";

                if (image == null)
                    continue; // Skip if image is not available

                // Container for stacking label, image, and button
                var container = new Grid
                {
                    Width = 150,
                    Height = 120,
                    Margin = new Thickness(5)
                };

                // Define rows for layout
                container.RowDefinitions.Add(new RowDefinition { Height = new GridLength(1, GridUnitType.Star) }); // Image
                container.RowDefinitions.Add(new RowDefinition { Height = new GridLength(30) }); // Button

                // Image
                var imgControl = new System.Windows.Controls.Image
                {
                    Source = image,
                    Width = 150,
                    Height = 90,
                    Stretch = Stretch.UniformToFill
                };

                Grid.SetRow(imgControl, 0);
                container.Children.Add(imgControl);

                // Label (overlays top-left, optional)
                var label = new Label
                {
                    Content = name,
                    HorizontalAlignment = HorizontalAlignment.Left,
                    VerticalAlignment = VerticalAlignment.Top,
                    Background = new SolidColorBrush(Color.FromArgb(180, 0, 0, 0)),
                    Foreground = Brushes.White,
                    Padding = new Thickness(4),
                    FontSize = 12
                };
                Grid.SetRow(label, 0);
                container.Children.Add(label);

                // Button
                var btn = new Button
                {
                    Content = buttonText,
                    Height = 25,
                    Width = 140,
                    HorizontalAlignment = HorizontalAlignment.Center,
                    VerticalAlignment = VerticalAlignment.Center,
                    Margin = new Thickness(0, 0, 0, 5)
                };
                btn.Click += (s, e) => PlayVideo(path);
                Grid.SetRow(btn, 1);
                container.Children.Add(btn);

                // Add to target UI panel
                targetPanel.Children.Add(container);
                }
                
            }
        }
        private void PopulatePlaylistsWithButtons()
{
    // Make sure the playlist ScrollViewer is visible
    ScrollContentHome.Visibility = Visibility.Collapsed;
    ScrollContentCat.Visibility = Visibility.Collapsed;
    ScrollContentPlaylist.Visibility = Visibility.Visible;

    // Clear previous content
    PlaylistContentPanel.Children.Clear();

    // Add "New Playlist" button
    var newPlaylistBtn = new Button
    {
        Content = "New Playlist",
        Background = Brushes.Black,
        Foreground = Brushes.White,
        Margin = new Thickness(5)
    };
    newPlaylistBtn.Click += PlayListButton_Click;
    PlaylistContentPanel.Children.Add(newPlaylistBtn);

    // Guard: If there are no playlists, show a message
    if (_playlists?.SharedRefs == null || !_playlists.SharedRefs.Any())
    {
        PlaylistContentPanel.Children.Add(new TextBlock
        {
            Text = "No playlists available.",
            Foreground = Brushes.White,
            Margin = new Thickness(10)
        });
        return;
    }

    // Add playlist sections
    foreach (var playlistCategory in _playlists.SharedRefs)
    {
        var container = new StackPanel
        {
            Margin = new Thickness(10),
            Orientation = Orientation.Vertical,
            HorizontalAlignment = HorizontalAlignment.Stretch
        };

        // Header row with playlist name and ">>" button
        var headerRow = new DockPanel
        {
            LastChildFill = true, // Let the title take remaining space
            HorizontalAlignment = HorizontalAlignment.Stretch
        };

        // Button (goes first, docked right)
        var btn = new Button
        {
            Content = ">>",
            Width = 30,
            Height = 25,
            Margin = new Thickness(10, 0, 0, 0),
            VerticalAlignment = VerticalAlignment.Center
        };
        DockPanel.SetDock(btn, Dock.Right);
        btn.Click += (s, e) => ShowFullCategoryView(playlistCategory);
        headerRow.Children.Add(btn);

        // Playlist name
        var title = new TextBlock
        {
            Text = playlistCategory.name,
            FontSize = 18,
            FontWeight = FontWeights.Bold,
            Foreground = Brushes.White,
            VerticalAlignment = VerticalAlignment.Center,
            Margin = new Thickness(5)
        };
        headerRow.Children.Add(title);

        container.Children.Add(headerRow);

        // Preview items in WrapPanel
        var wrap = new WrapPanel();
        PopulatePanelWithItems(playlistCategory.getAllItems().Take(9).ToList(), wrap);
        container.Children.Add(wrap);

        PlaylistContentPanel.Children.Add(container);
    }
}


        private void ShowFullCategoryView(Catagory category)
        {
        ScrollContentHome.Visibility = Visibility.Collapsed;
        ScrollContentPlaylist.Visibility = Visibility.Collapsed;

        ScrollContentCat.Visibility = Visibility.Visible;

        Name_of_Catagory_Text.Text = category.name;
        Name_of_Catagory1.Visibility = Visibility.Collapsed;

        PopulatePanelWithItems(category.getAllItems(), Name_of_Catagory);
        }


        #endregion

    #region load saved data

        private async void LoadSavedData()
            {
                try
                {
                    Jason_Writer jason_Writer = new Jason_Writer(); // Uses default "Temp Data" folder

                    // Load main media lists
                    var muvies = await jason_Writer.LoadListAsync("Muvies");
                    var series = await jason_Writer.LoadListAsync("Series");
                    var photos = await jason_Writer.LoadListAsync("Photos");
                    var music = await jason_Writer.LoadListAsync("Music");
                    var favorites = await jason_Writer.LoadListAsync("Favorit");

                    // Initialize progress bar with total count
                    progressScann = new ProgressBar("Reading saved data",
                        muvies.Count + series.Count + photos.Count + music.Count + favorites.Count);
                    progressScann.Show();

                    // Create Item lists from JSON
                    List<Item> MuvieItems = CreateItemsFromJson(muvies);
                    List<Item> SerieItems = CreateItemsFromJson(series);
                    List<Item> PhotoItems = CreateItemsFromJson(photos, isPhoto: true);
                    List<Item> MusicItems = CreateItemsFromJson(music, isPhoto: false, isMusic: true);

                    Muvie.addItems(MuvieItems);
                    Serie.addItems(SerieItems);
                    Photo.addItems(PhotoItems);
                    Music.addItems(MusicItems);

                    // Combine all media items for playlist/favorite matching
                    var allLocs = muvies.Concat(series).Concat(photos).Concat(music).ToList();

                    // Enrich favorite items by matching them with main list entries
                    var enrichedFavorites = new List<locJason>();
                    foreach (var fav in favorites)
                    {
                        var match = allLocs.FirstOrDefault(item =>
                            string.Equals(item.path, fav.path, StringComparison.OrdinalIgnoreCase));

                        if (match != null)
                        {
                            enrichedFavorites.Add(match);
                        }
                        else
                        {
                            enrichedFavorites.Add(fav); // fallback if not found
                            Console.WriteLine($"[Warning] Favorite not found in main lists: {fav.path}");
                        }
                    }

                    List<Item> FavoriteItems = CreateItemsFromJson(enrichedFavorites);
                    Favorites.addItems(FavoriteItems);

                    // Load playlists
                    var playlistNames = await jason_Writer.GetSavedPlaylistNamesAsync();

                    foreach (var playlistName in playlistNames)
                    {
                        var playlistEntries = await jason_Writer.LoadPlaylistListAsync(playlistName);

                        var matchedLocs = new List<locJason>();
                        foreach (var entry in playlistEntries)
                        {
                            var match = allLocs.FirstOrDefault(item =>
                                string.Equals(item.path, entry.path, StringComparison.OrdinalIgnoreCase));

                            if (match != null)
                            {
                                matchedLocs.Add(match);
                            }
                            else
                            {
                                Console.WriteLine($"[Warning] Playlist '{playlistName}' contains unknown path: {entry.path}");
                            }
                        }

                        List<Item> PlaylistItems = CreateItemsFromJson(matchedLocs);
                        var playlistCategory = new Catagory(playlistName);
                        playlistCategory.addItems(PlaylistItems);
                        _playlists.SharedRefs.Add(playlistCategory);
                    }

                    MenueItems(); // Refresh the UI
                    progressScann.Hide();
                    log.Log("Loaded saved data from JSON.");
                }
                catch (Exception ex)
                {
                    MessageBox.Show($"Failed to load saved data:\n{ex.Message}", "Error", MessageBoxButton.OK, MessageBoxImage.Error);
                    log.Error($"LoadSavedData error: {ex}");
                }
        }
                
        private List<Item> CreateItemsFromJson(List<locJason> jsonItems)
        {
            return CreateItemsFromJson(jsonItems, isPhoto: false, isMusic: false);
        }

        private List<Item> CreateItemsFromJson(List<locJason> jsonItems, bool isPhoto)
        {
            return CreateItemsFromJson(jsonItems, isPhoto, isMusic: false);
        }

        private List<Item> CreateItemsFromJson(List<locJason> jsonItems, bool isPhoto, bool isMusic)
        {
            List<Item> items = new List<Item>();
            JasonToString jasonToString = new JasonToString();

            foreach (var loc in jsonItems)
            {
                BitmapImage bitmapImage = null;

                try
                {
                    if (!string.IsNullOrEmpty(loc.imageData))
                    {
                        bitmapImage = BitmapConversions.BitmapToBitmapImage(
                            jasonToString.Base64StringToBitmap(loc.imageData)
                        );
                    }
                    else if (isMusic)
                    {
                        string defaultImagePath = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "Resources", "Pics", "MusicD.jpeg");
                        if (File.Exists(defaultImagePath))
                        {
                            bitmapImage = new BitmapImage(new Uri(defaultImagePath));
                            bitmapImage.Freeze();
                        }
                    }
                    else if (isPhoto && File.Exists(loc.path))
                    {
                        bitmapImage = new BitmapImage(new Uri(loc.path));
                        bitmapImage.Freeze();
                    }
                }
                catch
                {
                    // Handle any corrupt or missing image cases
                }

                items.Add(new Item(loc.path, loc.type, bitmapImage, isPhoto, OnItemPlayButtonClick));
                Application.Current.Dispatcher.Invoke(() =>
                {
                    progressScann.UpdateProgress(1);
                });
            }

            return items;
        }

        #endregion

    #region sliders

        private void RangeBase_OnValueChanged(object sender, RoutedPropertyChangedEventArgs<double> e)
        {
            if (sender is Slider&&_mediaPlayer != null)
            {
                Slider slider = sender as Slider;
                int value = Convert.ToInt32(slider.Value);
                _mediaPlayer.Volume = value;
                Server1.SendMessage("Vol=" + value);
                log.Log("VolumeChanged");
            }
        }

        #endregion

    #region progress slider
        private void ItemProgress_OnValueChanged(object sender, RoutedPropertyChangedEventArgs<double> e)
        {
            if (itemProgress.IsMouseOver&&(itemProgress.Value>_mediaPlayer.Time/1000+2||itemProgress.Value<_mediaPlayer.Time/1000-2))
            {
                ProgressBarValueChange();
            }
        }
        private void ItemProgress_OnValueChangedMil(long timeStap)
        {
            itemProgress.Value = timeStap/1000;
            itemProgressVisual.Value = itemProgress.Value;
            if(Server1!=null)
                Server1.SendMessage("Progress="+itemProgress.Value);
        }
        private void ProgressBarValueChange()
        {
            itemProgressVisual.Value = itemProgress.Value;
            if(itemProgress.IsMouseOver)
                _mediaPlayer.Time = Convert.ToInt64(itemProgress.Value) * 1000; // convert to milliseconds
        }
        private void videoSliderInit(long timeStap)
        {
            itemProgress.Maximum = timeStap;
            itemProgressVisual.Maximum = timeStap;
            itemProgress.Minimum = 0;
            itemProgressVisual.Minimum = 0;
            StartProgressTimer();
            Console.WriteLine(timeStap);
        }
        private void ItemProgress_OnPreviewMouseDown(object sender, MouseButtonEventArgs e)
        {
            var slider = sender as Slider;
            if (slider == null) return;
            Point position = e.GetPosition(slider);
            double relativePosition = position.X / slider.ActualWidth;
            relativePosition = Math.Max(0, Math.Min(1, relativePosition));
            double newValue = slider.Minimum + (relativePosition * (slider.Maximum - slider.Minimum));
            slider.Value = newValue;
            
            ProgressBarValueChange();
            
        }
        private void ProgressTimer_Tick(object sender, EventArgs e)
        {
            if (!_mediaPlayer.IsPlaying)
            {
                StopProgressTimer();
            }
            // Get current timestamp from media player in seconds
            long currentTimeInSeconds = _mediaPlayer.Time;

            // Update progress bar value
            ItemProgress_OnValueChangedMil(currentTimeInSeconds);
        }
        private void StartProgressTimer()
        {
            if (!_progressTimer.IsEnabled)
                _progressTimer.Start();
        }
        private void StopProgressTimer()
        {
            if (_progressTimer.IsEnabled)
                _progressTimer.Stop();
        }

        private void Key_Up(object sender, KeyEventArgs e)
        {
            switch (e.Key)
            {
                case Key.Escape:
                    var result = MessageBox.Show(
                        "Do you want to quit?",
                        "Exit",
                        MessageBoxButton.YesNo,
                        MessageBoxImage.Question
                    );

                    if (result == MessageBoxResult.Yes)
                    {
                        Application.Current.Shutdown(); 
                    }
                    break;

            }

            if (VideoView.IsVisible)
            {
                switch (e.Key)
                {
                    case Key.Left:_mediaPlayer.Time=_mediaPlayer.Time-10000;break;
                    case Key.Right:_mediaPlayer.Time=_mediaPlayer.Time+10000;break;
                    case Key.Space:
                        if (_mediaPlayer.IsPlaying)
                            _mediaPlayer.Pause();
                        else
                            _mediaPlayer.Play();
                        break;
                }
            }
            else
            {
                
            }
        }
        

        #endregion

    #region arrow nav
private void MainWindow_PreviewKeyDown(object sender, KeyEventArgs e)
{
    if (Keyboard.FocusedElement is not DependencyObject focusedElement)
        return;

    var wrapPanel = FindAncestor<WrapPanel>(focusedElement);
    var stackPanel = FindAncestor<StackPanel>(focusedElement);
    if (wrapPanel != null && wrapPanel.Children.Count > 0)
    {
        int focusedIndex = FindFocusedIndexInWrapPanel(wrapPanel, focusedElement);
        if (focusedIndex == -1)
            return;

        int columns = CalculateColumns(wrapPanel);

        switch (e.Key)
        {
            case Key.Left:
                e.Handled = true;
                if (IsLeftmostInRow(focusedIndex, columns))
                {
                    FirstCat?.Focus();
                }
                else
                {
                    MoveFocusInWrapPanel(wrapPanel, focusedIndex - 1);
                }
                break;

            case Key.Right:
                e.Handled = true;
                MoveFocusInWrapPanel(wrapPanel, focusedIndex + 1);
                break;

            case Key.Up:
                e.Handled = true;
                if (focusedIndex < columns)
                {
                    if (stackPanel != null)
                    {
                        int currentWrapPanelIndex = stackPanel.Children.IndexOf(wrapPanel);
                        if (currentWrapPanelIndex > 0)
                        {
                            for (int i = currentWrapPanelIndex - 1; i >= 0; i--)
                            {
                                if (stackPanel.Children[i] is WrapPanel prevWrapPanel && prevWrapPanel.Children.Count > 0)
                                {
                                    int targetIndexInPrev = Math.Min(prevWrapPanel.Children.Count - 1, focusedIndex + ((prevWrapPanel.Children.Count / columns) * columns));
                                    MoveFocusInWrapPanel(prevWrapPanel, targetIndexInPrev);
                                    return;
                                }
                            }
                        }
                    }
                }
                MoveFocusInWrapPanel(wrapPanel, focusedIndex - columns);
                break;

            case Key.Down:
                e.Handled = true;
                if (focusedIndex >= wrapPanel.Children.Count - columns)
                {
                    if (stackPanel != null)
                    {
                        int currentWrapPanelIndex = stackPanel.Children.IndexOf(wrapPanel);
                        if (currentWrapPanelIndex != -1 && currentWrapPanelIndex < stackPanel.Children.Count - 1)
                        {
                            for (int i = currentWrapPanelIndex + 1; i < stackPanel.Children.Count; i++)
                            {
                                if (stackPanel.Children[i] is WrapPanel nextWrapPanel && nextWrapPanel.Children.Count > 0)
                                {
                                    int targetIndexInNext = Math.Min(columns - 1, nextWrapPanel.Children.Count - 1);
                                    MoveFocusInWrapPanel(nextWrapPanel, targetIndexInNext);
                                    return;
                                }
                            }
                        }
                    }
                }
                MoveFocusInWrapPanel(wrapPanel, focusedIndex + columns);
                break;
        }
    }
    else if (FirstCat.IsFocused && e.Key == Key.Right)
    {
        e.Handled = true; // Always handle the key if we are trying to move from FirstCat
        var firstFocusable = FindFirstFocusableInVisibleWrapPanel();
        if (firstFocusable != null)
        {
            firstFocusable.Focus();
        }
        else
        {
            // Fallback: Wenn kein spezifisches fokussierbares Element gefunden wurde, versuchen Sie, den ScrollViewer selbst zu fokussieren
            if (ScrollContentHome.Visibility == Visibility.Visible) ScrollContentHome.Focus();
            else if (ScrollContentCat.Visibility == Visibility.Visible) ScrollContentCat.Focus();
            else if (ScrollContentPlaylist.Visibility == Visibility.Visible) ScrollContentPlaylist.Focus();
        }
    }
    else if (catPan.IsAncestorOf(Keyboard.FocusedElement as DependencyObject) && e.Key == Key.Down)
    {
        e.Handled = true;

        var buttons = catPan.Children.OfType<Button>().ToList();
        var focused = Keyboard.FocusedElement as Button;
        int index = buttons.IndexOf(focused);
    
        if (index != -1 && index < buttons.Count - 1)
        {
            Dispatcher.BeginInvoke(new Action(() =>
            {
                buttons[index + 1].Focus();
            }));
        }
    }

    else if (catPan.IsAncestorOf(Keyboard.FocusedElement as DependencyObject) && e.Key == Key.Up)
    {
        e.Handled = true;

        var buttons = catPan.Children.OfType<Button>().ToList();
        var focused = Keyboard.FocusedElement as Button;
        int index = buttons.IndexOf(focused);
    
        if (index > 0)
        {
            Dispatcher.BeginInvoke(new Action(() =>
            {
                buttons[index - 1].Focus();
            }));
        }
    }



}

private Control FindFirstFocusableInVisibleWrapPanel()
{
    ScrollViewer currentScrollViewer = null;

    if (ScrollContentHome.Visibility == Visibility.Visible)
    {
        currentScrollViewer = ScrollContentHome;
    }
    else if (ScrollContentCat.Visibility == Visibility.Visible)
    {
        currentScrollViewer = ScrollContentCat;
    }
    else if (ScrollContentPlaylist.Visibility == Visibility.Visible)
    {
        currentScrollViewer = ScrollContentPlaylist;
    }
    else
    {
        Console.WriteLine("No visible ScrollViewer found");
        return null;
    }

    Panel mainPanel = currentScrollViewer.Content as Panel;
    if (mainPanel != null)
    {
        for (int i = 0; i < mainPanel.Children.Count; i++)
        {
            var child = mainPanel.Children[i];
            WrapPanel wp = child as WrapPanel;
            if (wp != null && wp.Visibility == Visibility.Visible && wp.Children.Count > 0)
            {
                Control firstFocusable = FindFirstFocusableChild(wp);
                if (firstFocusable != null)
                {
                    return firstFocusable;
                }
            }
        }
    }
    else
    {
        Console.WriteLine("ScrollViewer content is not a Panel");
    }

    Control fallback = FindFirstFocusableChild(currentScrollViewer.Content as DependencyObject);
    if (fallback != null)
        return fallback;

    return null;
}

private int CalculateColumns(WrapPanel panel)
{
    if (panel.Children.Count == 0) return 1;

    var firstChild = panel.Children[0] as FrameworkElement;
    if (firstChild == null) return 1;

    double itemWidth = firstChild.ActualWidth + firstChild.Margin.Left + firstChild.Margin.Right;
    if (itemWidth <= 1) itemWidth = 150;

    double panelWidth = panel.ActualWidth;
    int columns = Math.Max(1, (int)(panelWidth / itemWidth));
    return columns;
}

private bool IsLeftmostInRow(int index, int columns) => (index % columns) == 0;

private void MoveFocusInWrapPanel(WrapPanel panel, int index)
{
    if (index < 0) index = 0;
    if (index >= panel.Children.Count) index = panel.Children.Count - 1;

    if (panel.Children[index] is Control ctrl && ctrl.Focusable)
    {
        ctrl.Focus();
        ctrl.BringIntoView();
    }
    else if (panel.Children[index] is Panel container)
    {
        var focusable = FindFirstFocusableChild(container);
        if (focusable != null)
        {
            focusable.Focus();
            focusable.BringIntoView();
        }
    }
}

private int FindFocusedIndexInWrapPanel(WrapPanel panel, DependencyObject focusedElement)
{
    for (int i = 0; i < panel.Children.Count; i++)
    {
        var container = panel.Children[i];
        if (IsOrContains(container, focusedElement))
            return i;
    }
    return -1;
}

private bool IsOrContains(DependencyObject parent, DependencyObject child)
{
    if (parent == child) return true;

    for (int i = 0; i < VisualTreeHelper.GetChildrenCount(parent); i++)
    {
        var sub = VisualTreeHelper.GetChild(parent, i);
        if (IsOrContains(sub, child))
            return true;
    }
    return false;
}

private Control FindFirstFocusableChild(DependencyObject parent)
{
    if (parent is Control c && c.Focusable)
        return c;

    for (int i = 0; i < VisualTreeHelper.GetChildrenCount(parent); i++)
    {
        var found = FindFirstFocusableChild(VisualTreeHelper.GetChild(parent, i));
        if (found != null)
            return found;
    }

    return null;
}

private static T FindAncestor<T>(DependencyObject child) where T : DependencyObject
{
    DependencyObject current = child;
    while (current != null)
    {
        if (current is T match)
            return match;
        current = VisualTreeHelper.GetParent(current);
    }
    return null;
}

public void SetInitialFocusForCurrentView()
{
    this.Dispatcher.BeginInvoke(System.Windows.Threading.DispatcherPriority.Input, new Action(() =>
    {
        Control firstFocusable = FindFirstFocusableInVisibleWrapPanel();
        if (firstFocusable != null)
        {
            firstFocusable.Focus();
        }
        else
        {
            if (ScrollContentHome.Visibility == Visibility.Visible) ScrollContentHome.Focus();
            else if (ScrollContentCat.Visibility == Visibility.Visible) ScrollContentCat.Focus();
            else if (ScrollContentPlaylist.Visibility == Visibility.Visible) ScrollContentPlaylist.Focus();
        }
    }));
}
#endregion



}