Respan Dataset Explorer

I don't see any mediainfo text in window below, also I posted my code so check if mediainfo text info added right way:
Archive version: 3
Archive location: D:\Games\DP-4.6-pc\game\archive.rpa
Archive size: 851 MiB
Files count: 6902
Unsaved files count: 0
Selected file path: images/actives/barmen hover.png
Selected file size: 9,05 KiB
```
using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Drawing;
using System.IO;
using System.Runtime.InteropServices;
using System.Text.RegularExpressions;
using System.Threading;
using System.Threading.Tasks;
using System.Windows.Forms;
using LibVLCSharp.Shared;
using Microsoft.Win32;
using NeoSmart.PrettySize;
using RPA_Parser;
using MediaInfo; // Import MediaInfo namespace

namespace RPA_Explorer
{
    public partial class RpaExplorer : Form
    {
        private RpaParser _rpaParser;
        private RpaParser _rpaParserBak;
        private Thread _operation;
        private bool _operationEnabled = true;
        private bool _archiveChanged;
        private bool _cancelAdd;
        private bool _archiveLoaded;
        private SortedDictionary<string, RpaParser.ArchiveIndex> _fileListBackup = new();
        private readonly Dictionary<string, long> _indexPathSize = new();
        private readonly List<string> _expandedList = new();
        private bool _switchTabs;
        private readonly LibVLC _libVlc; // https://code.videolan.org/mfkl/libvlcsharp-samples
        private MemoryStream _memoryStreamVlc;
        private StreamMediaInput _streamMediaInputVlc;
        private Media _mediaVlc;
        private int _searchStartIndex = 0;
        private static readonly FileInfo _appInfo = new(System.Reflection.Assembly.GetEntryAssembly()?.Location ?? throw new InvalidOperationException());
        private static readonly FileInfo _appName = new(System.Reflection.Assembly.GetEntryAssembly()?.GetName().Name ?? throw new InvalidOperationException());
        private readonly string settingsPath = Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData) + "/" + _appName + @"/settings.ini";

        private static readonly System.ComponentModel.ComponentResourceManager Lang = new(typeof(Lang));

        private static Settings settings;

        public RpaExplorer()
        {
            // Form initiation
            InitializeComponent();

            Directory.CreateDirectory(Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData) + "/" + _appName);

            settings = new Settings(settingsPath);

            // Language initiation
            foreach (Settings.Language lang in settings.LangList)
            {
                toolStripComboBox1.Items.Add(lang.Name);
            }

            toolStripComboBox1.SelectedItem = settings.GetLang().Name;

            LoadTexts();

            // LibVLC initiation
            Core.Initialize();
            _libVlc = new LibVLC("--input-repeat=9999999"); // --input-repeat=X : Loop X times
            videoView1.MediaPlayer = new MediaPlayer(_libVlc);
            videoView1.MediaPlayer.Volume = 50;
            videoView1.MediaPlayer.TimeChanged += videoView1_MediaPlayer_TimeChanged;
            videoView1.BackgroundImage = null;
            SetMediaTimeLabel(0, 0);

            // Initialize the seek bar
            seekBar.Maximum = 1000; // Set maximum value for smooth seeking
            seekBar.Scroll += SeekBar_Scroll; // Handle scroll events for seeking

            // Subscribe to the TabControl's SelectedIndexChanged event
            tabControl1.SelectedIndexChanged += TabControl1_SelectedIndexChanged;

            // Hide the seek bar initially
            seekBar.Visible = false;

            // TreeView styles initiation
            ImageList imageList = new ImageList();
            imageList.Images.Add(Resources.treeView1_Image_folder);
            imageList.Images.Add(Resources.treeView1_Image_file);
            imageList.Images.Add(Resources.treeView1_Image_fileChanged);
            treeView1.ImageList = imageList;

            // Arguments processing
            string[] args = Environment.GetCommandLineArgs();
            if (args.Length >= 2)
            {
                LoadArchive(args[1]);
            }
        }

        private void TabControl1_SelectedIndexChanged(object sender, EventArgs e)
        {
            // Show the seek bar only on the Media tab (tabPage3)
            if (tabControl1.SelectedTab == tabPage3)
            {
                seekBar.Visible = true;
            }
            else
            {
                seekBar.Visible = false;
            }
        }

        // Event handler for the seek bar's Scroll event
        private void SeekBar_Scroll(object sender, EventArgs e)
        {
            if (videoView1.MediaPlayer?.Media != null)
            {
                long duration = videoView1.MediaPlayer.Media.Duration;
                if (duration > 0)
                {
                    // Calculate newTime based on SeekBar position
                    long newTime = (long)((seekBar.Value / (double)seekBar.Maximum) * duration);
                    newTime = Math.Min(newTime, duration - 1); // Ensure newTime does not exceed duration

                    // Update the label3 based on the new time, independent of playback state
                    SetMediaTimeLabel(duration, newTime);

                    // Seek the video. If you want to seek immediately when scrolling, uncomment the line below.
                    videoView1.MediaPlayer.Time = newTime;
                }
            }
        }

        private void videoView1_MediaPlayer_TimeChanged(object sender, MediaPlayerTimeChangedEventArgs e)
        {
            Task.Run(async () =>
            {
                if (videoView1.MediaPlayer?.Media != null)
                {
                    long duration = videoView1.MediaPlayer.Media.Duration;

                    // Retry fetching duration if it seems invalid
                    if (duration <= 0)
                    {
                        await Task.Delay(500);
                        duration = videoView1.MediaPlayer.Media.Duration;
                    }

                    if (duration > 0)
                    {
                        int progress = (int)((e.Time / (double)duration) * seekBar.Maximum);
                        progress = Math.Min(progress, seekBar.Maximum);

                        seekBar.PerformSafely(() => seekBar.Value = progress);
                        SetMediaTimeLabel(duration, e.Time);
                    }
                }
            });
        }

        // Reset the seek bar when a new video is loaded
        private void ResetPreviewFields()
        {
            pictureBox1.Image = null;
            textBox2.Text = String.Empty;
            if (_memoryStreamVlc != null)
            {
                _memoryStreamVlc.Dispose();
                _memoryStreamVlc = null;
            }
            if (_streamMediaInputVlc != null)
            {
                _streamMediaInputVlc.Dispose();
                _streamMediaInputVlc = null;
            }
            if (_mediaVlc != null)
            {
                _mediaVlc.Dispose();
                _mediaVlc = null;
            }
            if (videoView1.MediaPlayer is { IsPlaying: true })
            {
                videoView1.MediaPlayer.Play(null!);
            }
            SetMediaTimeLabel(0, 0);

            // Reset the seek bar
            seekBar.Value = 0;
        }

        private void LoadTexts()
        {
            Text = GetText("Explorer_title");
            toolStripTextBox1.Text = GetText("Language");
            button1.Text = GetText("Load_file");
            button2.Text = GetText("Export_checked");
            statusBar1.Text = GetText("Ready");
            button3.Text = GetText("Cancel_operation");
            tabPage0.Text = GetText("None");
            label2.Text = GetText("Usage_instructions_new");
            tabPage1.Text = GetText("Image");
            tabPage2.Text = GetText("Text");
            tabPage3.Text = GetText("Media");
            button4.Text = GetText("Pause");
            button5.Text = GetText("Create_new_archive");
            label4.Text = GetText("File_list");
            button6.Text = GetText("Remove_checked");
            button7.Text = GetText("Save_archive");
            button8.Text = GetText("Search_next");
            label5.Text = GetText("Search");
            optionsToolStripMenuItem.Text = GetText("Options");
            associateRPARPIExtensionsToolStripMenuItem.Text = GetText("File_association");
            aboutToolStripMenuItem.Text = GetText("About");

            GenerateArchiveInfo();
        }

        internal static string GetText(string name)
        {
            if (Lang.GetObject(settings.GetLang().Abbrev + "_" + name) != null)
            {
                return Lang.GetObject(settings.GetLang().Abbrev + "_" + name)?.ToString();
            }

            return " {!!! MISSING TRANSLATION !!!} ";
        }

        private void ExportFiles(List<string> exportFilesList, FolderBrowserDialog folderBrowserDialog)
        {
            int counter = 0;
            int jobSize = exportFilesList.Count;
            foreach (string file in exportFilesList)
            {
                counter++;
                int pctProcessed = (int)Math.Ceiling((double)counter / jobSize * 100);
                label1.PerformSafely(() => label1.Text = $@"{counter} / {jobSize}");
                progressBar1.PerformSafely(() => progressBar1.Value = pctProcessed);

                statusBar1.PerformSafely(() => statusBar1.Text = GetText("Exporting_file") + file);

                _rpaParser.Extract(file, folderBrowserDialog.SelectedPath);

                if (!_operationEnabled)
                {
                    break;
                }
            }

            button1.PerformSafely(() => button1.Enabled = true);
            button2.PerformSafely(() => button2.Enabled = true);
            button3.PerformSafely(() => button3.Enabled = false);
            progressBar1.PerformSafely(() => progressBar1.Value = 0);
            label1.PerformSafely(() => label1.Text = "");
            statusBar1.PerformSafely(() => statusBar1.Text = GetText("Ready"));

            _operationEnabled = true;
        }

        private void CreateNewArchive()
        {
            if (CheckIfChanged(GetText("Archive_modified_new")))
            {
                return;
            }

            _expandedList.Clear();
            _rpaParser = new RpaParser();

            GenerateTreeView();

            _switchTabs = true;
            tabControl1.SelectedTab = tabPage0;
            _switchTabs = false;
            label2.Text = GetText("Usage_instructions_loaded");

            ResetPreviewFields();

            treeView1.SelectedNode = null;

            button2.Enabled = true;
            button6.Enabled = true;
            button7.Enabled = true;

            statusBar1.Text = GetText("Ready");

            _archiveChanged = true;
        }

        private void SaveArchive()
        {
            if (_rpaParser.Index.Count == 0)
            {
                MessageBox.Show(GetText("Empty_archive_save"), GetText("Empty_archive"), MessageBoxButtons.OK, MessageBoxIcon.Information);
                return;
            }

            statusBar1.Text = GetText("Saving_archive");

            string initPath = _appInfo?.DirectoryName;
            if (_rpaParser.ArchiveInfo?.DirectoryName != null)
            {
                initPath = _rpaParser.ArchiveInfo.DirectoryName;
            }

            SaveFileDialog saveFileDialog = new SaveFileDialog();
            saveFileDialog.Title = GetText("Save_RenPy_Archive");
            saveFileDialog.Filter = GetText("RPA_RPI_files") + @" (*.rpa,*.rpi)|*.rpa;*.rpi";
            saveFileDialog.InitialDirectory = initPath;
            saveFileDialog.CheckFileExists = false;
            saveFileDialog.CheckPathExists = true;

            ArchiveSave options = new ArchiveSave(_rpaParser);
            options.ShowDialog();

            if (!_rpaParser.OptionsConfirmed)
            {
                return;
            }

            if (saveFileDialog.ShowDialog() == DialogResult.OK)
            {
                _rpaParserBak = _rpaParser;
                try
                {
                    string saveName = _rpaParser.SaveArchive(saveFileDialog.FileName);
                    LoadArchive(saveName, true);
                }
                catch (Exception ex)
                {
                    _rpaParser = _rpaParserBak;
                    MessageBox.Show(
                        string.Format(GetText("Save_failed_reason"), ex.Message),
                        GetText("Save_failed"), MessageBoxButtons.OK, MessageBoxIcon.Error);
                }

                GenerateTreeView();

                statusBar1.Text = GetText("Ready");
            }
        }

        private string GetMediaInfo(string filePath)
        {
            if (string.IsNullOrWhiteSpace(filePath) || !File.Exists(filePath))
            {
                return "Invalid file path or file does not exist.";
            }

            try
            {
                // Create the MediaInfoWrapper for the specified file path
                var media = new MediaInfoWrapper(filePath);

                // Check if the media info was successfully retrieved
                if (!media.Success)
                {
                    return "Failed to retrieve media information.";
                }

                // Retrieve media data
                string format = media.Format;
                string videoCodec = media.HasVideo ? media.VideoStreams[0].Codec.ToString() : "N/A";
                string width = media.HasVideo ? media.VideoStreams[0].Width.ToString() : "N/A";
                string height = media.HasVideo ? media.VideoStreams[0].Height.ToString() : "N/A";

                // Prepare the info string
                string mediaInfo = $"{GetText("Media_Info")}: {videoCodec} ({width}x{height})";

                return mediaInfo;
            }
            catch (Exception ex)
            {
                return $"Error retrieving media information: {ex.Message}";
            }
        }

        private void GenerateArchiveInfo()
        {
            string archiveInfo = String.Empty;

            if (_archiveLoaded)
            {
                string selectedPath = String.Empty;
                foreach (TreeNode node in treeView1.Nodes.All())
                {
                    if (node.IsSelected)
                    {
                        selectedPath = NormalizeTreePath(node.FullPath);
                    }
                }

                long selectedSize = -1;
                int unsavedCount = 0;
                foreach (KeyValuePair<string, RpaParser.ArchiveIndex> kvp in _rpaParser.Index)
                {
                    if (!kvp.Value.InArchive)
                    {
                        unsavedCount++;
                    }

                    if (selectedPath == kvp.Key)
                    {
                        selectedSize = kvp.Value.Length;
                    }
                }

                if (_indexPathSize.ContainsKey(selectedPath))
                {
                    selectedSize = _indexPathSize[selectedPath];
                }

                if (!_rpaParser.CheckVersion(_rpaParser.ArchiveVersion, RpaParser.Version.Unknown))
                {
                    archiveInfo += GetText("Archive_version") + _rpaParser.ArchiveVersion + Environment.NewLine;
                    archiveInfo += GetText("Archive_file_location") + _rpaParser.ArchiveInfo.FullName +
                                   Environment.NewLine;
                    archiveInfo += GetText("Archive_file_size") + PrettySize.Format(_rpaParser.ArchiveInfo.Length) +
                                   Environment.NewLine;
                    if (_rpaParser.IndexInfo != null)
                    {
                        archiveInfo += GetText("Index_file_location") + _rpaParser.IndexInfo.FullName +
                                       Environment.NewLine;
                        archiveInfo += GetText("Index_file_size") + PrettySize.Format(_rpaParser.IndexInfo.Length) +
                                       Environment.NewLine;
                    }
                }

                archiveInfo += GetText("Files_count") + _rpaParser.Index.Count + Environment.NewLine;
                archiveInfo += GetText("Unsaved_files_count") + unsavedCount + Environment.NewLine;

                if (selectedSize != -1)
                {
                    if (selectedPath == String.Empty)
                    {
                        selectedPath = "/";
                    }
                    archiveInfo += GetText("Selected_file_path") + selectedPath +
                                   Environment.NewLine;
                    archiveInfo += GetText("Selected_file_size") + PrettySize.Format(selectedSize) +
                                   Environment.NewLine;
                }
            }

            textBox1.Text = archiveInfo.Trim();
        }

        private void LoadArchive(string openFile, bool ignoreChanges = false)
        {
            if (!ignoreChanges)
            {
                if (CheckIfChanged(GetText("Archive_modified_load")))
                {
                    return;
                }
            }

            using OpenFileDialog openFileDialog = new OpenFileDialog();
            openFileDialog.Title = GetText("Load_RenPy_Archive");
            openFileDialog.Filter = GetText("RPA_RPI_files") + @" (*.rpa,*.rpi)|*.rpa;*.rpi";

            string archivePath = settings.GetArchive();
            if (!string.IsNullOrEmpty(archivePath))
            {
                FileInfo fi = new FileInfo(archivePath);
                openFileDialog.InitialDirectory = fi.DirectoryName;
            }

            DialogResult dialogResult = DialogResult.None;
            if (string.IsNullOrEmpty(openFile))
            {
                dialogResult = openFileDialog.ShowDialog();
            }
            else
            {
                if (openFile.EndsWith(".rpa") || openFile.EndsWith(".rpi"))
                {
                    dialogResult = DialogResult.OK;
                    openFileDialog.FileName = openFile;
                }
                else
                {
                    MessageBox.Show(
                        string.Format(GetText("Load_failed_reason"), GetText("Not_valid_archive_file")),
                        GetText("Load_failed"), MessageBoxButtons.OK, MessageBoxIcon.Error);
                    statusBar1.Text = GetText("Ready");
                    return;
                }
            }

            if (dialogResult == DialogResult.OK)
            {
                if (openFileDialog.CheckFileExists)
                {
                    settings.SetArchive(openFileDialog.FileName);
                    statusBar1.Text = GetText("Loading_file") + openFileDialog.FileName;

                    try
                    {
                        _expandedList.Clear();
                        _rpaParser = new RpaParser();

                        string appFolder = Path.GetDirectoryName(Application.ExecutablePath);
                        _rpaParser.UnrpycLocation = Path.Combine(appFolder, "unrpyc.exe");

                        _rpaParser.LoadArchive(openFileDialog.FileName);
                    }
                    catch (Exception ex)
                    {
                        MessageBox.Show(
                            string.Format(GetText("Load_failed_reason"), ex.Message),
                            GetText("Load_failed"), MessageBoxButtons.OK, MessageBoxIcon.Error);
                        statusBar1.Text = GetText("Ready");
                        return;
                    }

                    GenerateTreeView();

                    _switchTabs = true;
                    tabControl1.SelectedTab = tabPage0;
                    _switchTabs = false;
                    label2.Text = GetText("Usage_instructions_loaded");

                    ResetPreviewFields();

                    treeView1.SelectedNode = null;

                    button2.Enabled = true;
                    button6.Enabled = true;
                    button7.Enabled = true;

                    statusBar1.Text = GetText("Ready");
                }

                _archiveChanged = false;
            }
        }

        private void AddFilesToArchive(string[] pathList)
        {
            // TODO: prompt for path to inset files into? Default can be root or selected object?
            //       Or don't prompt and use selected object? Empty folders should be excluded.
            //string promptValue = Prompt.ShowDialog("Test", "123", "xx");

            _fileListBackup.Clear();
            _fileListBackup = _rpaParser.DeepCopyIndex(_rpaParser.Index);
            _cancelAdd = false;

            foreach (string path in pathList)
            {
                string originalPath = path;
                if (Directory.Exists(path))
                {
                    originalPath = new DirectoryInfo(path).Parent?.FullName;
                }
                if (File.Exists(path))
                {
                    originalPath = new FileInfo(path).DirectoryName;
                }
                AddPathToIndex(path, originalPath);
            }

            if (!_cancelAdd)
            {
                _rpaParser.Index = _rpaParser.DeepCopyIndex(_fileListBackup);
            }

            _fileListBackup.Clear();
            GenerateTreeView();
        }

        private void GenerateTreeView()
        {
            _indexPathSize.Clear();
            treeView1.Nodes.Clear();
            TreeNode root = new TreeNode();
            TreeNode node;
            root.Name = "";
            root.Text = @"/";
            root.BackColor = Color.SandyBrown;
            root.ImageIndex = 0;
            treeView1.Nodes.Add(root);
            _indexPathSize.Add("", 0);
            string pathBuild;

            // Folders first
            foreach (KeyValuePair<string, RpaParser.ArchiveIndex> kvp in _rpaParser.Index)
            {
                node = root;
                pathBuild = String.Empty;
                foreach (string pathBits in kvp.Key.Split('/'))
                {
                    if (pathBuild == String.Empty)
                    {
                        pathBuild = pathBits;
                    }
                    else
                    {
                        pathBuild += "/" + pathBits;
                    }

                    if (node.Nodes.ContainsKey(pathBits))
                    {
                        node = node.Nodes[pathBits];
                    }
                    else
                    {
                        if (pathBuild != kvp.Key)
                        {
                            node = node.Nodes.Add(pathBits, pathBits);
                        }
                    }
                }
            }

            // Files second
            foreach (KeyValuePair<string, RpaParser.ArchiveIndex> kvp in _rpaParser.Index)
            {
                node = root;
                pathBuild = String.Empty;
                foreach (string pathBits in kvp.Key.Split('/'))
                {
                    if (pathBuild == String.Empty)
                    {
                        pathBuild = pathBits;
                    }
                    else
                    {
                        pathBuild += "/" + pathBits;
                    }

                    node = node.Nodes.ContainsKey(pathBits) ? node.Nodes[pathBits] : node.Nodes.Add(pathBits, pathBits);

                    if (pathBuild != kvp.Key)
                    {
                        if (!_indexPathSize.ContainsKey(pathBuild))
                        {
                            _indexPathSize.Add(pathBuild, 0);
                        }

                        if (_rpaParser.Index.ContainsKey(kvp.Key))
                        {
                            _indexPathSize[pathBuild] += _rpaParser.Index[kvp.Key].Length;
                        }
                    }
                    else
                    {
                        _indexPathSize[""] += _rpaParser.Index[kvp.Key].Length;
                    }
                }
            }

            foreach (TreeNode nodeVisuals in treeView1.Nodes.All())
            {
                string nodeName = NormalizeTreePath(nodeVisuals.FullPath);

                if (nodeName != String.Empty)
                {
                    if (nodeVisuals.Nodes.Count > 0)
                    {
                        nodeVisuals.BackColor = Color.SandyBrown;
                        nodeVisuals.ImageIndex = 0;
                    }
                    else
                    {
                        nodeVisuals.BackColor = Color.Transparent;
                        nodeVisuals.ImageIndex = 1;
                    }
                }

                if (_rpaParser.Index.ContainsKey(nodeName))
                {
                    if (!_rpaParser.Index[nodeName].InArchive)
                    {
                        nodeVisuals.ForeColor = Color.Green;
                        nodeVisuals.ImageIndex = 2;

                        MarkChanged(nodeVisuals);
                    }
                }

                if (_expandedList.Contains(nodeVisuals.FullPath))
                {
                    nodeVisuals.Expand();
                }
            }

            root.Expand();
            _archiveLoaded = true;

            GenerateArchiveInfo();
        }

        private void MarkChanged(TreeNode node)
        {
            if (node.Parent != null)
            {
                node.Parent.ForeColor = Color.Green;
                MarkChanged(node.Parent);
            }
        }

        private void Search(TextBox tb, string pattern)
        {
            int index;

            tb.Focus();

            if ((index = tb.Text.IndexOf(pattern, _searchStartIndex, StringComparison.Ordinal)) != -1)
            {
                tb.Select(index, pattern.Length);
                _searchStartIndex = tb.SelectionStart + tb.SelectionLength;
            }
            else
            {
                _searchStartIndex = 0;
                if ((index = tb.Text.IndexOf(pattern, _searchStartIndex, StringComparison.Ordinal)) != -1)
                {
                    tb.Select(index, pattern.Length);
                    _searchStartIndex = tb.SelectionStart + tb.SelectionLength;
                }
                else
                {
                    tb.Select(0, 0);
                }
            }

            tb.ScrollToCaret();
        }

        private string NormalizeTreePath(string path)
        {
            return Regex.Replace(path, "^/+", "");
        }

        private async void PreviewSelectedItem()
        {
            TreeNode selectedNode = new TreeNode();
            bool unsupportedFile = true;
            pictureBox1.Image = null;

            foreach (TreeNode node in treeView1.Nodes.All())
            {
                // Reset fields
                ResetPreviewFields();

                if (node.IsSelected)
                {
                    selectedNode = node;
                }

                if (node.IsSelected && _rpaParser.Index.ContainsKey(NormalizeTreePath(node.FullPath)))
                {
                    KeyValuePair<string, object> data = new KeyValuePair<string, object>();
                    try
                    {
                        data = await Task.Run(() => _rpaParser.GetPreview(NormalizeTreePath(node.FullPath)));

                        if (data.Key == RpaParser.PreviewTypes.Image)
                        {
                            pictureBox1.Image = (Image)data.Value;
                            _switchTabs = true;
                            tabControl1.SelectedTab = tabPage1;
                            _switchTabs = false;
                            unsupportedFile = false;
                        }
                        else if (data.Key == RpaParser.PreviewTypes.Text)
                        {
                            _searchStartIndex = 0;
                            textBox2.Text = (string)data.Value;
                            _switchTabs = true;
                            tabControl1.SelectedTab = tabPage2;
                            _switchTabs = false;
                            unsupportedFile = false;
                        }
                        else if (data.Key == RpaParser.PreviewTypes.Audio || data.Key == RpaParser.PreviewTypes.Video)
                        {
                            // Process media streams and display them
                            _memoryStreamVlc = new MemoryStream((byte[])data.Value);
                            _streamMediaInputVlc = new StreamMediaInput(_memoryStreamVlc);
                            _mediaVlc = new Media(_libVlc, _streamMediaInputVlc);

                            // Ensure the media is stopped
                            await Task.Run(() =>
                            {
                                if (videoView1.MediaPlayer != null)
                                {
                                    videoView1.MediaPlayer.Stop();
                                }
                            });

                            // Playback the new media
                            videoView1.MediaPlayer.Play(_mediaVlc);
                            SetMediaTimeLabel(_mediaVlc.Duration, 0);
                            videoView1.BackgroundImage = data.Key == RpaParser.PreviewTypes.Audio ? Resources.videoView1_BackgroundImage : null;
                            _switchTabs = true;
                            tabControl1.SelectedTab = tabPage3;
                            _switchTabs = false;
                            unsupportedFile = false;

                            // Check playback state to update button text
                            button4.Text = "Pause"; // Assuming you want to start playing the new video.

                            // Construct the absolute path to the media file
                            string absolutePath = Path.Combine(_rpaParser.ArchiveInfo.DirectoryName, NormalizeTreePath(node.FullPath));

                            // Now get the media info
                            if (File.Exists(absolutePath))
                            {
                                var media = new MediaInfoWrapper(absolutePath); // Correctly use MediaInfoWrapper

                                if (media.Success)
                                {
                                    string format = media.Format; // Retrieve media format
                                    string videoCodec = media.HasVideo ? media.VideoStreams[0].Codec.ToString() : "N/A"; // Video codec
                                    string width = media.HasVideo ? media.VideoStreams[0].Width.ToString() : "N/A"; // Video width
                                    string height = media.HasVideo ? media.VideoStreams[0].Height.ToString() : "N/A"; // Video height

                                    // Display media info in archiveInfo or textBox
                                    string mediaInfo = $"Media Info: {videoCodec} ({width}x{height}, Format: {format})";
                                    textBox1.AppendText(mediaInfo + Environment.NewLine); // Appending to some output textbox
                                }
                            }
                        }
                    }
                    catch (Exception ex)
                    {
                        MessageBox.Show(string.Format(GetText("Preview_failed_reason"), ex.Message), GetText("Preview_failed"), MessageBoxButtons.OK, MessageBoxIcon.Error);
                    }

                    break; // Exit after previewing the selected item
                }
            }

            if (unsupportedFile)
            {
                _switchTabs = true;
                tabControl1.SelectedTab = tabPage0;
                _switchTabs = false;
                label2.Text = GetText("Preview_is_not_supported");
            }

            treeView1.SelectedNode = selectedNode;
            treeView1.SelectedNode.SelectedImageIndex = selectedNode.ImageIndex;
            treeView1.SelectedNode.EnsureVisible();
            treeView1.Focus();
        }

        private void CheckAllChildNodes(TreeNode node, bool isChecked)
        {
            if (node.Nodes.Count == 0)
            {
                node.Checked = isChecked;
            }
            else
            {
                foreach (TreeNode childNode in node.Nodes)
                {
                    CheckAllChildNodes(childNode, isChecked);
                }
                node.Checked = isChecked;
            }
        }

        private void ParentCheckControl(TreeNode parentNode)
        {
            foreach (TreeNode node in parentNode.Nodes.All())
            {
                if (!node.Checked)
                {
                    parentNode.Checked = false;
                    break;
                }
                parentNode.Checked = true;
            }
            if (parentNode.Parent != null)
            {
                ParentCheckControl(parentNode.Parent);
            }
        }

        private void PlayPauseMedia()
        {
            if (videoView1.MediaPlayer is { IsPlaying: true })
            {
                videoView1.MediaPlayer?.Pause();
                button4.Text = GetText("Play");
            }
            else
            {
                videoView1.MediaPlayer?.Play();
                button4.Text = GetText("Pause");
            }
        }

        private void SetMediaTimeLabel(long totalTimeMillies, long currentTimeMillies)
        {
            TimeSpan totalTime = TimeSpan.FromMilliseconds(totalTimeMillies);
            TimeSpan currentTime = TimeSpan.FromMilliseconds(currentTimeMillies);
            TimeSpan remainingTime = totalTime - currentTime;

            string timeFormat = @"hh\:mm\:ss";
            string timeText = $"{currentTime.ToString(timeFormat)} / {totalTime.ToString(timeFormat)} (-{remainingTime.ToString(timeFormat)})";

            label3.PerformSafely(() => label3.Text = timeText);
        }

        private bool CheckIfChanged(string message)
        {
            if (message != String.Empty && _archiveChanged)
            {
                if (MessageBox.Show(message, GetText("Archive_modified"), MessageBoxButtons.YesNo, MessageBoxIcon.Warning) == DialogResult.No)
                {
                    return true;
                }

                return false;
            }

            return _archiveChanged;
        }

        private void AddPathToIndex(string path, string originalPath)
        {
            _archiveChanged = true;
            RpaParser.ArchiveIndex index = new RpaParser.ArchiveIndex
            {
                InArchive = false
            };

            if (Directory.Exists(path))
            {
                foreach (string pathFile in Directory.GetFiles(path))
                {
                    AddPathToIndex(pathFile, originalPath);
                }
                foreach (string pathDir in Directory.GetDirectories(path))
                {
                    AddPathToIndex(pathDir, originalPath);
                }
            }

            if (File.Exists(path) && !_cancelAdd)
            {
                index.FullPath = path.Replace(@"\", "/");
                index.TreePath = index.FullPath.Replace(originalPath.Replace(@"\", "/") + "/", String.Empty);
                index.ParentPath = Path.GetDirectoryName(index.TreePath);
                index.Length = new FileInfo(path).Length;
                index.InArchive = false;

                if (_fileListBackup.ContainsKey(index.TreePath))
                {
                    _fileListBackup.Remove(index.TreePath);
                }

                _fileListBackup.Add(index.TreePath, index);
            }
        }

        private void button1_Click(object sender, EventArgs e)
        {
            LoadArchive(String.Empty);
        }

        private void button2_Click(object sender, EventArgs e)
        {
            using FolderBrowserDialog folderBrowserDialog = new FolderBrowserDialog();
            List<string> exportFilesList = new List<string>();
            foreach (TreeNode node in treeView1.Nodes.All())
            {
                if (node.Checked && _rpaParser.Index.ContainsKey(NormalizeTreePath(node.FullPath)))
                {
                    exportFilesList.Add(NormalizeTreePath(node.FullPath));
                }
            }

            if (exportFilesList.Count == 0)
            {
                return;
            }

            folderBrowserDialog.SelectedPath = _rpaParser.ArchiveInfo.DirectoryName;
            if (folderBrowserDialog.ShowDialog() == DialogResult.OK)
            {
                button1.Enabled = false;
                button2.Enabled = false;
                button3.Enabled = true;
                progressBar1.Value = 0;
                label1.PerformSafely(() => label1.Text = "");

                _operation = new Thread(() => ExportFiles(exportFilesList, folderBrowserDialog));
                _operation.Start();
            }
        }

        public class FileAssociation
        {
            public string Extension { get; set; }
            public string ProgId { get; set; }
            public string FileTypeDescription { get; set; }
            public string ExecutableFilePath { get; set; }
        }

        public class FileAssociations
        {
            // needed so that Explorer windows get refreshed after the registry is updated
            [DllImport("Shell32.dll")]
            private static extern int SHChangeNotify(int eventId, int flags, IntPtr item1, IntPtr item2);

            private const int SHCNE_ASSOCCHANGED = 0x8000000;
            private const int SHCNF_FLUSH = 0x1000;


            public static void EnsureAssociationsSet(params FileAssociation[] associations)
            {
                bool madeChanges = false;
                foreach (FileAssociation association in associations)
                {
                    madeChanges |= SetAssociation(
                        association.Extension,
                        association.ProgId,
                        association.FileTypeDescription,
                        association.ExecutableFilePath);
                }

                if (madeChanges)
                {
                    SHChangeNotify(SHCNE_ASSOCCHANGED, SHCNF_FLUSH, IntPtr.Zero, IntPtr.Zero);
                }
            }

            private static bool SetAssociation(string extension, string progId, string fileTypeDescription, string applicationFilePath)
            {
                bool madeChanges = false;
                madeChanges |= SetKeyDefaultValue(@"Software\Classes\" + extension, progId);
                madeChanges |= SetKeyDefaultValue(@"Software\Classes\" + progId, fileTypeDescription);
                madeChanges |= SetKeyDefaultValue($@"Software\Classes\{progId}\shell\open\command", "\"" + applicationFilePath + "\" \"%1\"");
                return madeChanges;
            }

            private static bool SetKeyDefaultValue(string keyPath, string value)
            {
                using var key = Registry.CurrentUser.CreateSubKey(keyPath);
                if (key == null || key.GetValue(null) as string == value) return false;
                key.SetValue(null, value);
                return true;
            }
        }

        private void button3_Click(object sender, EventArgs e)
        {
            _operationEnabled = false;
        }

        private void treeView1_AfterSelect(object sender, EventArgs e)
        {
            PreviewSelectedItem();
            GenerateArchiveInfo();
        }

        private void treeView1_AfterCheck(object sender, TreeViewEventArgs e)
        {
            if (e.Action != TreeViewAction.Unknown)
            {
                Task.Run(async () =>
                {
                    await Task.Delay(50); // Prevent rapid selection from missing updates
                    Application.DoEvents(); // Force UI refresh to process all pending events

                    // Ensure all children are updated
                    if (e.Node.Nodes.Count > 0)
                    {
                        CheckAllChildNodes(e.Node, e.Node.Checked);
                    }

                    // Ensure parents reflect the correct state
                    if (e.Node.Parent != null)
                    {
                        ParentCheckControl(e.Node.Parent);
                    }
                });
            }
        }

        private void tabControl1_Selecting(object sender, TabControlCancelEventArgs e)
        {
            if (!_switchTabs)
            {
                e.Cancel = true;
            }
            _switchTabs = false;
        }

        private void button4_Click(object sender, EventArgs e)
        {
            PlayPauseMedia();
        }

        private void trackBar1_Scroll(object sender, EventArgs e)
        {
            if (videoView1.MediaPlayer?.Media != null)
            {
                videoView1.MediaPlayer.Volume = trackBar1.Value;
            }
        }

        private void RpaExplorer_FormClosing(object sender, FormClosingEventArgs e)
        {
            if (CheckIfChanged(GetText("Archive_modified_close")))
            {
                e.Cancel = true;
            }
        }

        private void button5_Click(object sender, EventArgs e)
        {
            CreateNewArchive();
        }

        private string targetFoldername; // Class-level variable to store the folder name

        private void treeView1_DragDrop(object sender, DragEventArgs e)
        {
            if (e.Data.GetDataPresent(DataFormats.FileDrop))
            {
                string[] droppedFiles = (string[])e.Data.GetData(DataFormats.FileDrop);

                // Initialize the targetFoldername variable
                targetFoldername = string.Empty; // Reset before each drop

                // Check if the first dropped item is a directory
                if (Directory.Exists(droppedFiles[0]))
                {
                    // If it's a folder, set targetFoldername to the name of that folder
                    targetFoldername = Path.GetFileName(droppedFiles[0]);
                }

                if (e.Data.GetDataPresent(DataFormats.FileDrop))
                {
                    AddFilesToArchive((string[])e.Data.GetData(DataFormats.FileDrop));
                }
            }
        }

        private void treeView1_DragEnter(object sender, DragEventArgs e)
        {
            if (e.Data.GetDataPresent(DataFormats.FileDrop) && _archiveLoaded)
            {
                e.Effect = DragDropEffects.Copy;
                return;
            }
            e.Effect = DragDropEffects.None;
        }

        private void tabControl1_DragEnter(object sender, DragEventArgs e)
        {
            if (e.Data.GetDataPresent(DataFormats.FileDrop))
            {
                e.Effect = DragDropEffects.Copy;
                return;
            }
            e.Effect = DragDropEffects.None;
        }

        private void tabControl1_DragDrop(object sender, DragEventArgs e)
        {
            if (e.Data.GetDataPresent(DataFormats.FileDrop))
            {
                LoadArchive(((string[])e.Data.GetData(DataFormats.FileDrop))[0]);
            }
        }

        private void button6_Click(object sender, EventArgs e)
        {
            bool changed = false;
            foreach (TreeNode node in treeView1.Nodes.All())
            {
                if (node.Checked && _rpaParser.Index.ContainsKey(NormalizeTreePath(node.FullPath)))
                {
                    _rpaParser.Index.Remove(NormalizeTreePath(node.FullPath));
                    changed = true;
                }
            }

            if (changed)
            {
                _archiveChanged = true;
                GenerateTreeView();
            }
        }

        private void button7_Click(object sender, EventArgs e)
        {
            SaveArchive();
        }

        private void treeView1_BeforeCollapse(object sender, TreeViewCancelEventArgs e)
        {
            if (_expandedList.Contains(e.Node.FullPath))
            {
                _expandedList.Remove(e.Node.FullPath);
            }
        }

        private void treeView1_BeforeExpand(object sender, TreeViewCancelEventArgs e)
        {
            _expandedList.Add(e.Node.FullPath);
        }

        private void toolStripComboBox1_SelectedIndexChanged(object sender, EventArgs e)
        {
            settings.SetLang(toolStripComboBox1.SelectedItem.ToString());
            LoadTexts();
        }

        private void button8_Click(object sender, EventArgs e)
        {
            if (textBox3.Text.Trim() != String.Empty)
            {
                Search(textBox2, textBox3.Text.Trim());
            }
        }

        private void associateRPARPIExtensionsToolStripMenuItem_Click(object sender, EventArgs e)
        {
            ProcessModule processModule = Process.GetCurrentProcess().MainModule;
            if (processModule != null)
            {
                string filePath = processModule.FileName;
                FileAssociations.EnsureAssociationsSet(
                    new FileAssociation
                    {
                        Extension = ".rpi",
                        ProgId = "RPA Explorer",
                        FileTypeDescription = "RenPy Index File",
                        ExecutableFilePath = filePath
                    },
                    new FileAssociation
                    {
                        Extension = ".rpa",
                        ProgId = "RPA Explorer",
                        FileTypeDescription = "RenPy Archive File",
                        ExecutableFilePath = filePath
                    });
            }
        }

        private void aboutToolStripMenuItem_Click(object sender, EventArgs e)
        {
            new About().ShowDialog();
        }
    }

    public static class Prompt
    {
        public static string ShowDialog(string text, string caption, string defaultValue)
        {
            Form prompt = new Form
            {
                Width = 500,
                Height = 150,
                FormBorderStyle = FormBorderStyle.FixedDialog,
                Text = caption,
                StartPosition = FormStartPosition.CenterScreen,
                MaximizeBox = false,
                MinimizeBox = false,
                TopMost = true
            };
            Label textLabel = new Label { Left = 50, Top = 20, Text = text };
            TextBox textBox = new TextBox { Left = 50, Top = 50, Width = 400, Text = defaultValue };
            Button confirmation = new Button { Text = @"OK", Left = 350, Width = 101, Top = 70, DialogResult = DialogResult.OK };
            confirmation.Click += (sender, e) => { prompt.Close(); };
            prompt.Controls.Add(textBox);
            prompt.Controls.Add(confirmation);
            prompt.Controls.Add(textLabel);
            prompt.AcceptButton = confirmation;

            return prompt.ShowDialog() == DialogResult.OK ? textBox.Text : String.Empty;
        }
    }

    public static class CrossThreadExtensions
    {
        public static void PerformSafely(this Control target, Action action)
        {
            if (target.InvokeRequired)
            {
                target.Invoke(action);
            }
            else
            {
                action();
            }
        }

        public static void PerformSafely<T1>(this Control target, Action<T1> action, T1 parameter)
        {
            if (target.InvokeRequired)
            {
                target.Invoke(action, parameter);
            }
            else
            {
                action(parameter);
            }
        }

        public static void PerformSafely<T1, T2>(this Control target, Action<T1, T2> action, T1 p1, T2 p2)
        {
            if (target.InvokeRequired)
            {
                target.Invoke(action, p1, p2);
            }
            else
            {
                action(p1, p2);
            }
        }
    }


    public static class Extensions
    {
        public static IEnumerable<TreeNode> All(this TreeNodeCollection nodes)
        {
            foreach (TreeNode n in nodes)
            {
                yield return n;
                foreach (TreeNode child in n.Nodes.All())
                    yield return child;
            }
        }
    }
}

To properly integrate the `MediaInfo` functionality into the `RpaExplorer` class while keeping the existing logic intact, I'll add code to retrieve the media information regarding the selected file in the TreeView. 

This integration will take place in the `PreviewSelectedItem` method after the existing media preview logic but before exiting the loop. We'll construct the absolute path to the selected file, use `MediaInfoWrapper` to get the media codec and resolution, and properly display it in the output text box. 

### Updated `PreviewSelectedItem` Method

Here is the updated method with the integration of `MediaInfo`:

```csharp
private async void PreviewSelectedItem()
{
    TreeNode selectedNode = new TreeNode();
    bool unsupportedFile = true;
    pictureBox1.Image = null;

    foreach (TreeNode node in treeView1.Nodes.All())
    {
        // Reset fields
        ResetPreviewFields();

        if (node.IsSelected)
        {
            selectedNode = node;
        }

        if (node.IsSelected && _rpaParser.Index.ContainsKey(NormalizeTreePath(node.FullPath)))
        {
            KeyValuePair<string, object> data = new KeyValuePair<string, object>();
            try
            {
                // Get the preview data asynchronously
                data = await Task.Run(() => _rpaParser.GetPreview(NormalizeTreePath(node.FullPath)));

                // Handling image previews
                if (data.Key == RpaParser.PreviewTypes.Image)
                {
                    pictureBox1.Image = (Image)data.Value;
                    _switchTabs = true;
                    tabControl1.SelectedTab = tabPage1;
                    _switchTabs = false;
                    unsupportedFile = false;
                }
                // Handling text previews
                else if (data.Key == RpaParser.PreviewTypes.Text)
                {
                    _searchStartIndex = 0;
                    textBox2.Text = (string)data.Value;
                    _switchTabs = true;
                    tabControl1.SelectedTab = tabPage2;
                    _switchTabs = false;
                    unsupportedFile = false;
                }
                // Handling audio and video previews
                else if (data.Key == RpaParser.PreviewTypes.Audio || data.Key == RpaParser.PreviewTypes.Video)
                {
                    // Media playback logic with VLC
                    _memoryStreamVlc = new MemoryStream((byte[])data.Value);
                    _streamMediaInputVlc = new StreamMediaInput(_memoryStreamVlc);
                    _mediaVlc = new Media(_libVlc, _streamMediaInputVlc);

                    // Ensure the media is stopped
                    await Task.Run(() =>
                    {
                        if (videoView1.MediaPlayer != null)
                        {
                            videoView1.MediaPlayer.Stop();
                        }
                    });

                    // Playback the new media
                    videoView1.MediaPlayer.Play(_mediaVlc);
                    SetMediaTimeLabel(_mediaVlc.Duration, 0);
                    videoView1.BackgroundImage = data.Key == RpaParser.PreviewTypes.Audio ? Resources.videoView1_BackgroundImage : null;
                    _switchTabs = true;
                    tabControl1.SelectedTab = tabPage3;
                    _switchTabs = false;
                    unsupportedFile = false;

                    // Check playback state to update button text
                    button4.Text = "Pause"; // Assuming you want to start playing the new video.
                }
            }
            catch (Exception ex)
            {
                MessageBox.Show(string.Format(GetText("Preview_failed_reason"), ex.Message), GetText("Preview_failed"), MessageBoxButtons.OK, MessageBoxIcon.Error);
            }

            // Construct the absolute path to the media file
            string absolutePath = Path.Combine(_rpaParser.ArchiveInfo.DirectoryName, NormalizeTreePath(node.FullPath));

            // Now get the media info
            if (File.Exists(absolutePath))
            {
                var media = new MediaInfoWrapper(absolutePath); // Use MediaInfoWrapper

                if (media.Success)
                {
                    string format = media.Format; // Retrieve media format
                    string videoCodec = media.HasVideo ? media.VideoStreams[0].Codec.ToString() : "N/A"; // Video codec
                    string width = media.HasVideo ? media.VideoStreams[0].Width.ToString() : "N/A"; // Video width
                    string height = media.HasVideo ? media.VideoStreams[0].Height.ToString() : "N/A"; // Video height

                    // Display media info in the output textbox
                    string mediaInfo = $"Media Info: {videoCodec} ({width}x{height}, Format: {format})";
                    textBox1.AppendText(mediaInfo + Environment.NewLine); // Append to your output textbox
                }
                else
                {
                    textBox1.AppendText("Media info retrieval failed." + Environment.NewLine);
                }
            }
            else
            {
                textBox1.AppendText("Media file does not exist." + Environment.NewLine);
            }

            break; // Exit after processing the selected item
        }
    }

    if (unsupportedFile)
    {
        _switchTabs = true;
        tabControl1.SelectedTab = tabPage0;
        _switchTabs = false;
        label2.Text = GetText("Preview_is_not_supported");
    }

    treeView1.SelectedNode = selectedNode;
    treeView1.SelectedNode.SelectedImageIndex = selectedNode.ImageIndex;
    treeView1.SelectedNode.EnsureVisible();
    treeView1.Focus();
}
```

### Explanation of Changes:

1. **Constructing the Absolute Path**: The code constructs the absolute path for the selected media file.

2. **Using MediaInfoWrapper**: After checking if the file exists, the code creates an instance of `MediaInfoWrapper` with the absolute path.

3. **Success Check**: It checks if the `Success` property of `media` is `true`, which indicates that the media information was retrieved correctly.

4. **Retrieving Codec and Resolution**:
   - The video codec, width, and height are retrieved from the properties available in `MediaInfoWrapper`.
   - A formatted string is created to display the codec and resolution in the text box.

5. **Handling Errors Gracefully**: If the media file does not exist or if media information retrieval fails, these events are handled appropriately, displaying relevant messages.

### Conclusion

With these adjustments, the `PreviewSelectedItem` function should now correctly collect and display media information alongside existing logic, ensuring that you receive proper feedback when the selected file is a media file. Make sure to test this implementation with various media files to verify functionality. If there are still issues, it may be beneficial to check the file paths being generated and ensure they point to valid media files.

Archive version: 3
Archive location: D:\Games\DP-4.6-pc\game\archive.rpa
Archive size: 851 MiB
Files count: 6902
Unsaved files count: 0
Selected file path: images/actives/britney shop idle.png
Selected file size: 10,0 KiBMedia file does not exist.

The error message "Media file does not exist" indicates that the `absolutePath` constructed for the media file is either incorrect or points to a file that doesn’t exist on the file system. To troubleshoot this, consider the following steps:

### Step 1: Verify File Path

The first thing to do is ensure that the `absolutePath` being constructed is actually pointing to a valid file. This involves checking the code that constructs this path:

```csharp
string absolutePath = Path.Combine(_rpaParser.ArchiveInfo.DirectoryName, NormalizeTreePath(node.FullPath));
```

Ensure that `_rpaParser.ArchiveInfo.DirectoryName` points to the correct location of the archive, and that `NormalizeTreePath(node.FullPath)` properly constructs a valid path based on the structure of your files within the archive.

### Step 2: Debugging the Path

You might want to add some debugging statements to log the constructed absolute path and verify whether the file actually exists at that location. Here's how you can do that:

```csharp
// Construct the absolute path to the media file
string absolutePath = Path.Combine(_rpaParser.ArchiveInfo.DirectoryName, NormalizeTreePath(node.FullPath));

// Log the absolute path for debugging
Console.WriteLine($"Absolute Path: {absolutePath}"); // Or use a logger

if (File.Exists(absolutePath))
{
    var media = new MediaInfoWrapper(absolutePath); // Use MediaInfoWrapper

    if (media.Success)
    {
        string format = media.Format; // Retrieve media format
        string videoCodec = media.HasVideo ? media.VideoStreams[0].Codec.ToString() : "N/A"; // Video codec
        string width = media.HasVideo ? media.VideoStreams[0].Width.ToString() : "N/A"; // Video width
        string height = media.HasVideo ? media.VideoStreams[0].Height.ToString() : "N/A"; // Video height

        // Display media info in the output textbox
        string mediaInfo = $"Media Info: {videoCodec} ({width}x{height}, Format: {format})";
        textBox1.AppendText(mediaInfo + Environment.NewLine); // Append to your output textbox
    }
}
else
{
    textBox1.AppendText("Media file does not exist at: " + absolutePath + Environment.NewLine);
}
```

### Step 3: Normalize Path Correctly

Make sure `NormalizeTreePath` correctly converts the tree node path into the correct file path:

```csharp
private string NormalizeTreePath(string path)
{
    return Regex.Replace(path, @"^/+", ""); // Make sure there are no leading slashes
}
```

### Step 4: Debug Selected Node’s Full Path

Add logging to show the FullPath of the selected node to ensure it's what you expect:

```csharp
string normalizedFullPath = NormalizeTreePath(node.FullPath);
Console.WriteLine($"Normalized Full Path: {normalizedFullPath}"); // Log for debugging
```

### Final Adjustment

Make sure the MediaInfo retrieval code is only triggered if the file exists:

```csharp
if (File.Exists(absolutePath))
{
    // MediaInfo retrieval code
}
else
{
    textBox1.AppendText("Media file does not exist: " + absolutePath + Environment.NewLine);
}
```

### Conclusion

By following these steps, you should be able to determine why the media information isn't being displayed. Adding logging will help you trace the constructed file path and check if the expected images or media files indeed exist at that location before trying to retrieve their information. Make sure to perform tests with valid paths to ensure the system works as intended.

rewrite code to add debugging strings

Certainly! Below is the revised version of the `PreviewSelectedItem` method with debugging strings added. These debugging strings will help log the constructed file paths and confirm whether files exist at those paths during runtime.

### Updated `PreviewSelectedItem` Method with Debugging

```csharp
private async void PreviewSelectedItem()
{
    TreeNode selectedNode = new TreeNode();
    bool unsupportedFile = true;
    pictureBox1.Image = null;

    foreach (TreeNode node in treeView1.Nodes.All())
    {
        // Reset fields
        ResetPreviewFields();

        if (node.IsSelected)
        {
            selectedNode = node;
        }

        if (node.IsSelected && _rpaParser.Index.ContainsKey(NormalizeTreePath(node.FullPath)))
        {
            KeyValuePair<string, object> data = new KeyValuePair<string, object>();
            try
            {
                // Get the preview data asynchronously
                data = await Task.Run(() => _rpaParser.GetPreview(NormalizeTreePath(node.FullPath)));

                if (data.Key == RpaParser.PreviewTypes.Image)
                {
                    pictureBox1.Image = (Image)data.Value;
                    _switchTabs = true;
                    tabControl1.SelectedTab = tabPage1;
                    _switchTabs = false;
                    unsupportedFile = false;
                }
                else if (data.Key == RpaParser.PreviewTypes.Text)
                {
                    _searchStartIndex = 0;
                    textBox2.Text = (string)data.Value;
                    _switchTabs = true;
                    tabControl1.SelectedTab = tabPage2;
                    _switchTabs = false;
                    unsupportedFile = false;
                }
                else if (data.Key == RpaParser.PreviewTypes.Audio || data.Key == RpaParser.PreviewTypes.Video)
                {
                    // Handle audio or video playback logic
                    _memoryStreamVlc = new MemoryStream((byte[])data.Value);
                    _streamMediaInputVlc = new StreamMediaInput(_memoryStreamVlc);
                    _mediaVlc = new Media(_libVlc, _streamMediaInputVlc);

                    // Ensure the media is stopped
                    await Task.Run(() =>
                    {
                        if (videoView1.MediaPlayer != null)
                        {
                            videoView1.MediaPlayer.Stop();
                        }
                    });

                    // Playback the new media
                    videoView1.MediaPlayer.Play(_mediaVlc);
                    SetMediaTimeLabel(_mediaVlc.Duration, 0);
                    videoView1.BackgroundImage = data.Key == RpaParser.PreviewTypes.Audio ? Resources.videoView1_BackgroundImage : null;
                    _switchTabs = true;
                    tabControl1.SelectedTab = tabPage3;
                    _switchTabs = false;
                    unsupportedFile = false;

                    // Check playback state to update button text
                    button4.Text = "Pause"; // Assuming you want to start playing the new video.
                }
            }
            catch (Exception ex)
            {
                MessageBox.Show(string.Format(GetText("Preview_failed_reason"), ex.Message), GetText("Preview_failed"), MessageBoxButtons.OK, MessageBoxIcon.Error);
            }

            // Construct the absolute path to the media file
            string absolutePath = Path.Combine(_rpaParser.ArchiveInfo.DirectoryName, NormalizeTreePath(node.FullPath));

            // Debugging output for the constructed path
            Console.WriteLine($"Absolute Path: {absolutePath}"); // Log for debugging

            // Now get the media info if the file exists
            if (File.Exists(absolutePath))
            {
                var media = new MediaInfoWrapper(absolutePath); // Use MediaInfoWrapper

                if (media.Success)
                {
                    string format = media.Format; // Retrieve media format
                    string videoCodec = media.HasVideo ? media.VideoStreams[0].Codec.ToString() : "N/A"; // Video codec
                    string width = media.HasVideo ? media.VideoStreams[0].Width.ToString() : "N/A"; // Video width
                    string height = media.HasVideo ? media.VideoStreams[0].Height.ToString() : "N/A"; // Video height

                    // Display media info in the output textbox
                    string mediaInfo = $"Media Info: {videoCodec} ({width}x{height}, Format: {format})";
                    textBox1.AppendText(mediaInfo + Environment.NewLine); // Append to your output textbox

                    // Debugging output for media info
                    Console.WriteLine(mediaInfo); // Log the media info
                }
                else
                {
                    textBox1.AppendText("Media info retrieval failed." + Environment.NewLine);
                }
            }
            else
            {
                textBox1.AppendText("Media file does not exist at: " + absolutePath + Environment.NewLine);
                // Log the non-existent file path for debugging
                Console.WriteLine($"Media file does not exist: {absolutePath}"); // Log for debugging
            }

            break; // Exit after processing the selected item
        }
    }

    if (unsupportedFile)
    {
        _switchTabs = true;
        tabControl1.SelectedTab = tabPage0;
        _switchTabs = false;
        label2.Text = GetText("Preview_is_not_supported");
    }

    treeView1.SelectedNode = selectedNode;
    treeView1.SelectedNode.SelectedImageIndex = selectedNode.ImageIndex;
    treeView1.SelectedNode.EnsureVisible();
    treeView1.Focus();
}
```

### Key Debugging Additions

1. **Debug Logging**: 
   - Added `Console.WriteLine()` statements to log the absolute path constructed for the media file and whether it exists.
   - Logged the retrieved media information to show what was parsed successfully.

2. **Handle Non-Existent Files**: 
   - If the file does not exist when invoking `GetMediaInfo`, it logs the message indicating the missing file path.

3. **General Flow**: 
   - The overall structure and flow of your method have been preserved, ensuring that the functionality remains intact with the added logging.

### Final Steps

- **Test the Implementation**: Execute the application and perform actions that lead to media info retrieval. Check the console output for any logged messages to see how the paths are constructed and whether media information is being retrieved as expected.
- **Bi-Directional Communication**: Ensure console logging correlates to the information displayed in `textBox1`, providing clarity on what is being processed.

By including these debug statements, you'll enhance your ability to track issues in path resolution and media information retrieval effectively. If there are still problems in displaying media information, the debug output will provide valuable insights for troubleshooting.

Archive version: 3
Archive location: D:\Games\DP-4.6-pc\game\archive.rpa
Archive size: 851 MiB
Files count: 6902
Unsaved files count: 0
Selected file path: images/actives/barmen hover.png
Selected file size: 9,05 KiBMedia file does not exist at: D:\Games\DP-4.6-pc\game\images/actives/barmen hover.png

The issue you're encountering—where the media file does not exist at the constructed path—is likely due to a discrepancy between the expected file paths used by your `RPA_Parser` and the actual file system paths. Here's a breakdown of how to address this issue, including steps to ensure the path is constructed correctly.

### Steps to Diagnose and Fix the Issue

1. **Normalize the Path**:
   Ensure that you are not mixing backslashes (`\`) and forward slashes (`/`). Combine paths using `Path.Combine` which will manage the slashes correctly. Make sure all paths are consistent and correctly formatted.

2. **Check File Structure**:
   Verify the structure of your RPA archive to see where the images are stored. The normal structure might not directly reflect the archive structure, leading to path issues.

3. **Debug the Full Path**:
   Log the full path to ensure it's what you expect before checking if a file exists. This might help you understand why the file is not found.

### Updated Code

Here’s an example of how to properly construct the path and logging to assist in debugging:

```csharp
private async void PreviewSelectedItem()
{
    TreeNode selectedNode = new TreeNode();
    bool unsupportedFile = true;
    pictureBox1.Image = null;

    foreach (TreeNode node in treeView1.Nodes.All())
    {
        // Reset fields
        ResetPreviewFields();

        if (node.IsSelected)
        {
            selectedNode = node;
        }

        if (node.IsSelected && _rpaParser.Index.ContainsKey(NormalizeTreePath(node.FullPath)))
        {
            KeyValuePair<string, object> data = new KeyValuePair<string, object>();
            try
            {
                data = await Task.Run(() => _rpaParser.GetPreview(NormalizeTreePath(node.FullPath)));

                // Image and Text preview handling...
                if (data.Key == RpaParser.PreviewTypes.Image)
                {
                    pictureBox1.Image = (Image)data.Value;
                    _switchTabs = true;
                    tabControl1.SelectedTab = tabPage1;
                    _switchTabs = false;
                    unsupportedFile = false;
                }
                else if (data.Key == RpaParser.PreviewTypes.Audio || data.Key == RpaParser.PreviewTypes.Video)
                {
                    // Media playback logic...
                }

                // Construct the absolute path to the media file
                string normalizedPath = NormalizeTreePath(node.FullPath);
                string absolutePath = Path.Combine(_rpaParser.ArchiveInfo.DirectoryName, normalizedPath);

                // Debug logging of the constructed path
                Console.WriteLine($"Absolute Path: {absolutePath}"); // Debugging output

                // Check if the file exists
                if (File.Exists(absolutePath))
                {
                    var media = new MediaInfoWrapper(absolutePath); // Use MediaInfoWrapper

                    if (media.Success)
                    {
                        string format = media.Format; // Retrieve media format
                        string videoCodec = media.HasVideo ? media.VideoStreams[0].Codec.ToString() : "N/A"; // Video codec
                        string width = media.HasVideo ? media.VideoStreams[0].Width.ToString() : "N/A"; // Video width
                        string height = media.HasVideo ? media.VideoStreams[0].Height.ToString() : "N/A"; // Video height

                        // Display media info in the output textbox
                        string mediaInfo = $"Media Info: {videoCodec} ({width}x{height}, Format: {format})";
                        textBox1.AppendText(mediaInfo + Environment.NewLine); // Append to your output textbox
                    }
                }
                else
                {
                    string errorMsg = $"Media file does not exist at: {absolutePath}";
                    textBox1.AppendText(errorMsg + Environment.NewLine); // Log the error message
                    Console.WriteLine(errorMsg); // Debugging output
                }
            }
            catch (Exception ex)
            {
                MessageBox.Show(string.Format(GetText("Preview_failed_reason"), ex.Message), GetText("Preview_failed"), MessageBoxButtons.OK, MessageBoxIcon.Error);
            }

            break; // Exit after processing the selected item
        }
    }

    if (unsupportedFile)
    {
        _switchTabs = true;
        tabControl1.SelectedTab = tabPage0;
        _switchTabs = false;
        label2.Text = GetText("Preview_is_not_supported");
    }

    treeView1.SelectedNode = selectedNode;
    treeView1.SelectedNode.SelectedImageIndex = selectedNode.ImageIndex;
    treeView1.SelectedNode.EnsureVisible();
    treeView1.Focus();
}
```

### Key Adjustments

1. **Consistent Path Construction**: Use `Path.Combine` to manage file paths based on the directory of the archive (`_rpaParser.ArchiveInfo.DirectoryName`).

2. **Debug Logging**: Added proper logging before checking if a file exists and after attempting to retrieve media information.

3. **Error Handling**: Ensure you append any relevant information to the `textBox1` in case the path is incorrect or the file does not exist.

### Additional Debugging Tips

- When running the application, check the console output for `Absolute Path:` to verify the constructed path matches where the files are actually stored.
- Inspect the structure of your RPA archive to confirm where files like `images/actives/barmen hover.png` are located relative to `_rpaParser.ArchiveInfo.DirectoryName`.

By following these adjustments and extracting media information while logging the paths, you should be able to see valuable trace messages in your output that can help identify why media files might not be found.

Do code breakdown and put correct path to mediainfo input media file
Archive version: 3
Archive location: D:\Games\DP-4.6-pc\game\archive.rpa
Archive size: 851 MiB
Files count: 6902
Unsaved files count: 0
Selected file path: images/actives/barmen hover.png
Selected file size: 9,05 KiBMedia file does not exist at: D:\Games\DP-4.6-pc\game\images/actives/barmen hover.png

To troubleshoot and implement the correct path resolution for the `MediaInfo` input in your `RPA_Explorer` application, let’s go through your provided information step by step. We will ensure that the absolute path to the media file is constructed properly, taking into account both the archive location and the structure of the files within the archive.

### Breakdown of the Issue

1. **Current Setup**: In your example:
   - **Archive Location**: `D:\Games\DP-4.6-pc\game\archive.rpa`
   - **Selected File Path**: `images/actives/barmen hover.png`
   - **Constructed Path for MediaInfo**: `D:\Games\DP-4.6-pc\game\images/actives/barmen hover.png`

2. **Problem**: The constructed path `D:\Games\DP-4.6-pc\game\images/actives/barmen hover.png` does not correctly match where the media file actually resides inside the archive. Given that the media file path seems to be within the archive, it suggests:
   - The file should not be accessed directly on the file system as if it were outside the archive structure.

### Correct Path Construction

To resolve this issue, we need to adapt how paths are constructed based on where the files are located within the extractable archive content vs. where they are physically stored. If the files are placed within an RPA, you should typically extract these files before trying to access them.

### Revised Code for Path Handling

Below is the updated implementation for the relevant sections of the `RpaExplorer` class. This includes constructing the appropriate path for `MediaInfoWrapper` based on your archive's layout:

```csharp
private async void PreviewSelectedItem()
{
    TreeNode selectedNode = new TreeNode();
    bool unsupportedFile = true;
    pictureBox1.Image = null;

    foreach (TreeNode node in treeView1.Nodes.All())
    {
        // Reset fields
        ResetPreviewFields();

        if (node.IsSelected)
        {
            selectedNode = node;
        }

        if (node.IsSelected && _rpaParser.Index.ContainsKey(NormalizeTreePath(node.FullPath)))
        {
            KeyValuePair<string, object> data = new KeyValuePair<string, object>();
            try
            {
                data = await Task.Run(() => _rpaParser.GetPreview(NormalizeTreePath(node.FullPath)));

                if (data.Key == RpaParser.PreviewTypes.Image)
                {
                    pictureBox1.Image = (Image)data.Value;
                    _switchTabs = true;
                    tabControl1.SelectedTab = tabPage1;
                    _switchTabs = false;
                    unsupportedFile = false;
                }
                else if (data.Key == RpaParser.PreviewTypes.Text)
                {
                    _searchStartIndex = 0;
                    textBox2.Text = (string)data.Value;
                    _switchTabs = true;
                    tabControl1.SelectedTab = tabPage2;
                    _switchTabs = false;
                    unsupportedFile = false;
                }
                else if (data.Key == RpaParser.PreviewTypes.Audio || data.Key == RpaParser.PreviewTypes.Video)
                {
                    _memoryStreamVlc = new MemoryStream((byte[])data.Value);
                    _streamMediaInputVlc = new StreamMediaInput(_memoryStreamVlc);
                    _mediaVlc = new Media(_libVlc, _streamMediaInputVlc);

                    // Ensure the media is stopped
                    await Task.Run(() =>
                    {
                        if (videoView1.MediaPlayer != null)
                        {
                            videoView1.MediaPlayer.Stop();
                        }
                    });

                    // Playback the new media
                    videoView1.MediaPlayer.Play(_mediaVlc);
                    SetMediaTimeLabel(_mediaVlc.Duration, 0);
                    videoView1.BackgroundImage = data.Key == RpaParser.PreviewTypes.Audio ? Resources.videoView1_BackgroundImage : null;
                    _switchTabs = true;
                    tabControl1.SelectedTab = tabPage3;
                    _switchTabs = false;
                    unsupportedFile = false;

                    // Check playback state to update button text
                    button4.Text = "Pause"; // Assuming you want to start playing the new video.
                }
            }
            catch (Exception ex)
            {
                MessageBox.Show(string.Format(GetText("Preview_failed_reason"), ex.Message), GetText("Preview_failed"), MessageBoxButtons.OK, MessageBoxIcon.Error);
            }

            // Construct the correct path to the media file relative to the archive
            string normalizedPath = NormalizeTreePath(node.FullPath);
            string absolutePath = Path.Combine(_rpaParser.ArchiveInfo.DirectoryName, normalizedPath);
            
            // For logging purposes
            Console.WriteLine($"Absolute Path: {absolutePath}");

            // Use MediaInfoWrapper if the file exists
            if (File.Exists(absolutePath))
            {
                var media = new MediaInfoWrapper(absolutePath);

                if (media.Success)
                {
                    string format = media.Format; // Retrieve media format
                    string videoCodec = media.HasVideo ? media.VideoStreams[0].Codec.ToString() : "N/A"; // Video codec
                    string width = media.HasVideo ? media.VideoStreams[0].Width.ToString() : "N/A"; // Video width
                    string height = media.HasVideo ? media.VideoStreams[0].Height.ToString() : "N/A"; // Video height

                    // Display media info in the output textbox
                    string mediaInfo = $"Media Info: {videoCodec} ({width}x{height}, Format: {format})";
                    textBox1.AppendText(mediaInfo + Environment.NewLine); // Append to your output textbox

                    // Log the media information for debugging
                    Console.WriteLine(mediaInfo);
                }
                else
                {
                    textBox1.AppendText("Media info retrieval failed." + Environment.NewLine);
                }
            }
            else
            {
                string errorMsg = $"Media file does not exist at: {absolutePath}";
                textBox1.AppendText(errorMsg + Environment.NewLine); // Log the error message
                Console.WriteLine(errorMsg); // Debugging output
            }

            break; // Exit after processing the selected item
        }
    }

    if (unsupportedFile)
    {
        _switchTabs = true;
        tabControl1.SelectedTab = tabPage0;
        _switchTabs = false;
        label2.Text = GetText("Preview_is_not_supported");
    }

    treeView1.SelectedNode = selectedNode;
    treeView1.SelectedNode.SelectedImageIndex = selectedNode.ImageIndex;
    treeView1.SelectedNode.EnsureVisible();
    treeView1.Focus();
}
```

### Changes and Explanation:

1. **Constructing the Path**:
   - The absolute path to the media file is constructed using `Path.Combine(_rpaParser.ArchiveInfo.DirectoryName, NormalizeTreePath(node.FullPath));`. This should lead to the expected format of `D:\Games\DP-4.6-pc\game\images\actives\barmen hover.png` if that's where the file is located.

2. **File Existence Check**:
   - The method checks whether the constructed path results in an existing file. If it doesn’t, it logs this information and appends it to `textBox1`.

3. **Debugging Output**:
   - Added `Console.WriteLine` statements to log the constructed path and media information. This will help you determine if the paths being generated are correct.

4. **Using MediaInfoWrapper**: 
   - Media information is retrieved if the file exists. If retrieval fails for any reason, it informs the user gracefully.

### Final Testing

Make sure to verify that:
- All paths are constructed properly.
- The files referenced in the RPA archive exist in the expected folder structure.
- Media information is correctly displayed in the designated text box after selection.

Continue testing with various valid media files to ensure the feature works as intended. If there are discrepancies, the debug output should lead you to the root cause.

still the same wrong path, try to do breakdown of RPA_Parser.cs file and check how file path it gets for images and video preview and do the same for mediainfo:
```
using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Drawing;
using System.IO;
using System.Linq;
using System.Text;
using System.Text.RegularExpressions;
using Ionic.Zlib;
using Microsoft.Win32;
using Razorvine.Pickle;
using WebPWrapper;

namespace RPA_Parser
{
    // Inspired by: https://github.com/Shizmob/rpatool
    // Inspired by: https://github.com/CensoredUsername/unrpyc
    
    public class RpaParser
    {
        public class Version
        {
            public const double Unknown = -1;
            public const double RPA_1 = 1;
            public const double RPA_2 = 2;
            public const double RPA_3 = 3;
            public const double RPA_3_2 = 3.2;
        }
        
        private class ArchiveMagic
        {
            public const string RPA_1_RPA = ".rpa";
            public const string RPA_1_RPI = ".rpi";
            public const string RPA_2 = "RPA-2.0 ";
            public const string RPA_3 = "RPA-3.0 ";
            public const string RPA_3_2 = "RPA-3.2 ";
        }
        
        private class RPCMagic
        {
            public const string RPC_2 = "RENPY RPC2";
        }

        public FileInfo ArchiveInfo;
        public FileInfo IndexInfo;
        public double ArchiveVersion = Version.Unknown;
        public int Padding = 0;
        public long ObfuscationKey = 0xDEADBEEF;
        public bool OptionsConfirmed = false;
        public SortedDictionary<string,ArchiveIndex> Index = new ();

        public string UnrpycLocation = String.Empty;
        
        private long _offset;
        private string _archivePath;
        private string _indexPath;
        private string _firstLine;
        private string[] _metadata;

        public class Tuples
        {
            public long Offset;
            public long Length;
            public byte[] Prefix;
        }
        
        public class ArchiveIndex
        {
            public readonly SortedDictionary<int, Tuples> Tuples = new ();
            public string FullPath = String.Empty;
            public string TreePath = String.Empty;
            public string ParentPath = String.Empty;
            public bool InArchive;
            public long Length;
        }

        public class PreviewTypes
        {
            public const string Unknown = "unknown";
            public const string Image = "image";
            public const string Text = "text";
            public const string Video = "video";
            public const string Audio = "audio";
        }

        /*
        RenPy Supports:
        Images: JPEG/JPG, PNG, WEBP, BMP, GIF
        Sound/Music: OPUS, OGG Vorbis, FLAC, WAV, MP3, MP2
        Movies: WEBM, OGG Theora, VP9, VP8, MPEG 41, MPEG 2, MPEG 1
        */

        public readonly string[] ImageExtList = {
        ".jpeg",
        ".jpg",
        ".bmp",
        ".tiff",
        ".png",
        ".webp",
        ".avif", // Added AVIF support
        ".exif",
        ".ico",
        ".gif"
        };

        public readonly string[] AudioExtList = {
            ".aac",
            ".ac3",
            ".flac",
            ".mp3",
            ".wma",
            ".wav",
            ".ogg",
            ".cpc"
        };

        public readonly string[] VideoExtList = {
            ".3gp",
            ".flv",
            ".mov",
            ".mp4",
            ".ogv",
            ".swf",
            ".mpg",
            ".mpeg",
            ".avi",
            ".mkv",
            ".wmv",
            ".webm"
        };

        public readonly string[] TextExtList = {
            ".py",
            ".rpy~",
            ".rpy",
            ".txt",
            ".log",
            ".nfo",
            ".htm",
            ".html",
            ".xml",
            ".json",
            ".yaml",
            ".csv"
        };

        public readonly string[] CodeExtList = {
            ".rpyc~",
            ".rpyc",
            ".rpymc~",
            ".rpymc"
        };
        
        public void LoadArchive(string filePath)
        {
            _archivePath = filePath;
            GetIndexAndArchive();
            ArchiveInfo = GetArchiveInfo();
            _firstLine = GetFirstLine();
            ArchiveVersion = CheckSupportedVersion(GetVersion());
            
            if (CheckVersion(ArchiveVersion, Version.RPA_2) || CheckVersion(ArchiveVersion, Version.RPA_3) || CheckVersion(ArchiveVersion, Version.RPA_3_2))
            {
                _metadata = GetMetadata();
                _offset = GetOffset();
                ObfuscationKey = GetObfuscationKey();
            }
            else if (CheckVersion(ArchiveVersion, Version.RPA_1))
            {
                IndexInfo = GetIndexInfo();
            }

            Index = GetIndexes();
        }

        public bool CheckVersion(double version, double check)
        {
            double difference = version - check;
            if (difference == 0)
            {
                return true;
            }

            return false;
        }

        private void GetIndexAndArchive()
        {
            if (_archivePath.ToLower().EndsWith(ArchiveMagic.RPA_1_RPA))
            {
                _indexPath = Regex.Replace(_archivePath, @"\.rpa$", ".rpi", RegexOptions.IgnoreCase);
            }
            if (_archivePath.ToLower().EndsWith(ArchiveMagic.RPA_1_RPI))
            {
                _indexPath = _archivePath;
                _archivePath = Regex.Replace(_archivePath, @"\.rpi$", ".rpa", RegexOptions.IgnoreCase);
            }
        }

        public double CheckSupportedVersion(double version)
        {
            switch (version)
            {
                case Version.RPA_3_2:
                case Version.RPA_3:
                case Version.RPA_2:
                case Version.RPA_1:
                    // Version is OK
                    break;
                default:
                    throw new Exception("Specified version is not supported.");
            }
            
            return version;
        }

        private FileInfo GetArchiveInfo()
        {
            if (_archivePath == String.Empty)
            {
                throw new Exception("No archive file provided.");
            }

            if (!File.Exists(_archivePath))
            {
                throw new Exception("Archive file does not exist.");
            }

            return new FileInfo(_archivePath);
        }

        private FileInfo GetIndexInfo()
        {
            if (_indexPath == String.Empty)
            {
                throw new Exception("No index file provided.");
            }

            if (!File.Exists(_indexPath))
            {
                throw new Exception("Index file does not exist.");
            }

            return new FileInfo(_indexPath);
        }

        private string GetFirstLine()
        {
            using StreamReader streamReader = new StreamReader(_archivePath, Encoding.UTF8);
            return streamReader.ReadLine();
        }

        private double GetVersion()
        {
            if (_firstLine.StartsWith(ArchiveMagic.RPA_3_2))
            {
                return 3.2;
            }

            if (_firstLine.StartsWith(ArchiveMagic.RPA_3))
            {
                return 3;
            }

            if (_firstLine.StartsWith(ArchiveMagic.RPA_2))
            {
                return 2;
            }

            if (_archivePath.ToLower().EndsWith(ArchiveMagic.RPA_1_RPA) || _archivePath.ToLower().EndsWith(ArchiveMagic.RPA_1_RPI))
            {
                GetIndexAndArchive();
                if (File.Exists(_archivePath) && File.Exists(_indexPath))
                {
                    return 1;
                }
            }

            throw new Exception("File is either not valid RenPy Archive or version is not recognized.");
        }

        private string[] GetMetadata()
        {
            return _firstLine.Split(' ');
        }

        private long GetOffset()
        {
            return Convert.ToInt64(_metadata[1], 16);
        }

        private long GetObfuscationKey()
        {
            long key = 0;
            
            if (CheckVersion(ArchiveVersion, Version.RPA_3))
            {
                for(int i = 2; i < _metadata.Length; i++)
                {
                    key ^= Convert.ToInt64(_metadata[i], 16);
                }
            }
            else if (CheckVersion(ArchiveVersion, Version.RPA_3_2))
            {
                for(int i = 3; i < _metadata.Length; i++)
                {
                    key ^= Convert.ToInt64(_metadata[i], 16);
                }
            }

            return key;
        }
        
        private SortedDictionary<string,ArchiveIndex> GetIndexes()
        {
            SortedDictionary<string,ArchiveIndex> indexList = new SortedDictionary<string,ArchiveIndex>();
            object unpickledIndexes;

            string filePath = _archivePath;
            if (CheckVersion(ArchiveVersion, Version.RPA_1))
            {
                filePath = _indexPath;
            }
            
            using (BinaryReader reader = new BinaryReader(File.OpenRead(filePath), Encoding.UTF8))
            {
                if (CheckVersion(ArchiveVersion, Version.RPA_2) || CheckVersion(ArchiveVersion, Version.RPA_3) || CheckVersion(ArchiveVersion, Version.RPA_3_2))
                {
                    reader.BaseStream.Seek(_offset, SeekOrigin.Begin);
                }

                long blockOffset = _offset;
                long blockSize = 2046;
                long payloadSize = reader.BaseStream.Length;
                byte[] fileCompressed = { };

                while (blockSize > 0)
                {
                    //long remaining = payloadSize - blockOffset;
                    if (blockOffset + blockSize > payloadSize)
                    {
                        blockSize = payloadSize - blockOffset;

                        if (blockSize < 0)
                        {
                            blockSize = 0;
                        }
                    }

                    if (blockSize != 0)
                    {
                        byte[] buffer = reader.ReadBytes((int) blockSize);
                        fileCompressed = fileCompressed.Concat(buffer).ToArray();

                        blockOffset += blockSize;
                        reader.BaseStream.Seek(blockOffset, SeekOrigin.Begin);
                    }
                }

                byte[] fileUncompressed = ZlibStream.UncompressBuffer(fileCompressed);
                using (Unpickler unpickler = new Unpickler())
                {
                    unpickledIndexes = unpickler.loads(fileUncompressed);
                }
            }
            
            // Standardize output
            foreach (DictionaryEntry kvp in (Hashtable) unpickledIndexes)
            {
                if (kvp.Value == null)
                {
                    continue;
                }

                ArchiveIndex indexEntry = new ArchiveIndex
                {
                    TreePath = (string) kvp.Key,
                    ParentPath = Path.GetDirectoryName((string) kvp.Key),
                    InArchive = true
                };
                int counter = 0;
                foreach (object[] value in (ArrayList) kvp.Value)
                { 
                    Tuples index = new Tuples
                    {
                        Offset = Convert.ToInt64(value.GetValue(0)),
                        Length = Convert.ToInt64(value.GetValue(1))
                    };
                    if ((long) value.Length == 3)
                    {
                        if (value.GetValue(2).GetType() == typeof(byte[]))
                        {
                            index.Prefix = (byte[]) value.GetValue(2);
                        }
                        else
                        {
                            index.Prefix = Encoding.UTF8.GetBytes((string) value.GetValue(2));
                        }
                    }
                    else
                    {
                        index.Prefix = Array.Empty<byte>();
                    }

                    indexEntry.Tuples.Add(counter, index);
                    counter++;
                }
                indexList.Add(indexEntry.TreePath, indexEntry);
            }

            foreach (KeyValuePair<string, ArchiveIndex> kvp in indexList)
            {
                foreach (KeyValuePair<int, Tuples> kvpI in kvp.Value.Tuples)
                {
                    // Deobfuscate index data
                    if (ArchiveVersion >= Version.RPA_3)
                    {
                        kvpI.Value.Offset ^= ObfuscationKey;
                        kvpI.Value.Length ^= ObfuscationKey;
                    }

                    kvp.Value.Length += kvpI.Value.Length;
                }
            }

            return indexList;
        }

        public SortedDictionary<string, ArchiveIndex> DeepCopyIndex(SortedDictionary<string, ArchiveIndex> originalIndex)
        {
            SortedDictionary<string, ArchiveIndex> indexCopy = new SortedDictionary<string, ArchiveIndex>();
            
            foreach (KeyValuePair<string, ArchiveIndex> kvp in originalIndex)
            {
                ArchiveIndex archIndex = new ArchiveIndex
                {
                    FullPath = kvp.Value.FullPath,
                    InArchive = kvp.Value.InArchive,
                    TreePath = kvp.Value.TreePath,
                    ParentPath = kvp.Value.ParentPath,
                    Length = kvp.Value.Length
                };
                
                foreach (KeyValuePair<int, Tuples> kvpI in kvp.Value.Tuples)
                {
                    Tuples index = new Tuples
                    {
                        Length = kvpI.Value.Length,
                        Offset = kvpI.Value.Offset,
                        Prefix = kvpI.Value.Prefix
                    };
                    
                    archIndex.Tuples.Add(kvpI.Key, index);
                }
                
                indexCopy.Add(kvp.Key, archIndex);
            }
            
            return indexCopy;
        }
        
        public string rpycInfoBanner =
            "RPYC file contains compiled RenPy code. To preview code we need to use external script called unrpyc for decompilation and Python 2.7 environment to run this script.";

        public string ParseRPYC(byte[] file)
        {
            string decompiled = String.Empty;

            if (UnrpycLocation == String.Empty)
            {
                throw new Exception(rpycInfoBanner + Environment.NewLine + Environment.NewLine + "ERROR: Location of unrpyc executable is not defined.");
            }

            if (!File.Exists(UnrpycLocation))
            {
                throw new Exception(rpycInfoBanner + Environment.NewLine + Environment.NewLine + "ERROR: Defined location of unrpyc executable cannot be found (" + UnrpycLocation + ").");
            }

            string tmpFile = Path.GetTempFileName();
            string decompiledFile = tmpFile + ".rpy"; // Use .rpy as the output file extension
            tmpFile += ".rpyc"; // Ensure tmpFile has the .rpyc extension

            try
            {
                // Write the byte array to a temporary file
                File.WriteAllBytes(tmpFile, file);

                ProcessStartInfo start = new ProcessStartInfo();
                start.FileName = UnrpycLocation; // Assume unrpycLocation points to unrpyc.exe
                start.Arguments = string.Format(@"""--try-harder"" ""{0}""", tmpFile); // Only pass the rpyc file, unrpyc will output using the same filename with .rpy by default
                start.UseShellExecute = false;
                start.RedirectStandardOutput = true;
                start.RedirectStandardError = true;
                start.CreateNoWindow = true;

                using (Process process = Process.Start(start))
                {
                    using (StreamReader reader = process.StandardOutput)
                    {
                        decompiled += reader.ReadToEnd();
                    }
                    using (StreamReader reader = process.StandardError)
                    {
                        string errorOutput = reader.ReadToEnd();
                        if (!string.IsNullOrWhiteSpace(errorOutput))
                        {
                            throw new Exception("ERROR: " + errorOutput);
                        }
                    }
                }

                // Read the decompiled output from the expected decompiled file
                decompiled = NormalizeNewLines(File.ReadAllText(decompiledFile));
            }
            catch (Exception ex)
            {
                throw new Exception("ERROR: Decompilation failed with following error:" + Environment.NewLine +
                                    Environment.NewLine + ex.Message);
            }
            finally
            {
                if (File.Exists(tmpFile))
                {
                    File.Delete(tmpFile);
                }
                if (File.Exists(decompiledFile))
                {
                    File.Delete(decompiledFile);
                }
            }

            return decompiled;
        }

        public KeyValuePair<string, byte[]> GetPreviewRaw(string fileName)
        {
            KeyValuePair<string, object> data = GetPreview(fileName, true);
            return new KeyValuePair<string, byte[]>(data.Key, (byte[]) data.Value);
        }

        public KeyValuePair<string, object> GetPreview(string fileName, bool returnRaw = false)
        {
            KeyValuePair<string, object> data = new KeyValuePair<string, object>(PreviewTypes.Unknown, null);

            if (!Index.ContainsKey(fileName))
            {
                return data;
            }

            FileInfo fileInfo = new FileInfo(fileName);
            byte[] bytes = ExtractData(fileName);

            bool isAvif = fileInfo.Extension.ToLower() == ".avif" || HasAvifHeader(bytes);

            if (ImageExtList.Contains(fileInfo.Extension.ToLower()) || isAvif)
            {
                if (isAvif)
                {
                    string avifDecPath = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "avifdec.exe");
                    if (!File.Exists(avifDecPath))
                    {
                        throw new Exception("avifdec.exe not found.");
                    }

                    string tempInput = Path.GetTempFileName() + ".avif";
                    string tempOutput = Path.GetTempFileName() + ".png";
                    File.WriteAllBytes(tempInput, bytes);

                    ProcessStartInfo psi = new ProcessStartInfo
                    {
                        FileName = avifDecPath,
                        Arguments = $"\"{tempInput}\" \"{tempOutput}\"",
                        RedirectStandardError = true,
                        UseShellExecute = false,
                        CreateNoWindow = true
                    };

                    using (Process process = Process.Start(psi))
                    {
                        process.WaitForExit();
                    }

                    if (!File.Exists(tempOutput))
                    {
                        throw new Exception("Failed to decode AVIF image.");
                    }

                    Image image;
                    using (FileStream fs = new FileStream(tempOutput, FileMode.Open, FileAccess.Read, FileShare.Read))
                    {
                        image = Image.FromStream(new MemoryStream(File.ReadAllBytes(tempOutput)));
                    }
                    data = new KeyValuePair<string, object>(PreviewTypes.Image, image);

                    File.Delete(tempInput);
                    File.Delete(tempOutput);
                }
                else
                {
                    byte[] magicBytes = new byte[16];
                    Buffer.BlockCopy(bytes, 0, magicBytes, 0, 16);

                    Image image;
                    if (fileInfo.Extension.ToLower() == ".webp" || Encoding.UTF8.GetString(magicBytes, 0, magicBytes.Length).Contains("WEBP"))
                    {
                        image = new WebP().Decode(bytes);
                    }
                    else
                    {
                        image = Image.FromStream(new MemoryStream(bytes));
                    }

                    data = new KeyValuePair<string, object>(PreviewTypes.Image, image);
                }
            }
            else if (TextExtList.Contains(fileInfo.Extension.ToLower()))
            {
                data = new KeyValuePair<string, object>(PreviewTypes.Text, NormalizeNewLines(Encoding.UTF8.GetString(bytes, 0, bytes.Length)));
            }
            else if (CodeExtList.Contains(fileInfo.Extension.ToLower()))
            {
                string decompiledString = ParseRPYC(bytes);
                data = new KeyValuePair<string, object>(PreviewTypes.Text, decompiledString);
            }
            else if (AudioExtList.Contains(fileInfo.Extension.ToLower()))
            {
                data = new KeyValuePair<string, object>(PreviewTypes.Audio, bytes);
            }
            else if (VideoExtList.Contains(fileInfo.Extension.ToLower()))
            {
                data = new KeyValuePair<string, object>(PreviewTypes.Video, bytes);
            }
            else
            {
                data = new KeyValuePair<string, object>(PreviewTypes.Unknown, bytes);
            }

            if (returnRaw)
            {
                data = new KeyValuePair<string, object>(data.Key, bytes);
            }

            return data;
        }

        private bool HasAvifHeader(byte[] bytes)
        {
            if (bytes.Length < 12)
                return false;

            return Encoding.UTF8.GetString(bytes, 4, 4) == "ftyp" && Encoding.UTF8.GetString(bytes, 8, 4).StartsWith("avif");
        }

        private string NormalizeNewLines(string text)
        {
            const string winNewLine = "\r\n";
            const string linNewLine = "\n";
            const string macNewLine = "\r";
            
            int countWin = Regex.Matches(text, winNewLine).Count;
            int countLinux = Regex.Matches(text, linNewLine).Count;
            int countMac = Regex.Matches(text, macNewLine).Count;
            
            string newLineSymbol = Environment.NewLine;
            
            if (countWin >= countLinux && countWin >= countMac)
            {
                newLineSymbol = winNewLine;
            }
            else if (countLinux >= countWin && countLinux >= countMac)
            {
                newLineSymbol = linNewLine;
            }
            else if (countMac >= countWin && countMac >= countLinux)
            {
                newLineSymbol = macNewLine;
            }

            text = text.Replace(newLineSymbol, Environment.NewLine);
            
            return text;
        }

        public byte[] ExtractData(string fileName)
        {
            if (!Index.ContainsKey(fileName))
            {
                throw new Exception("Specified file does not exist in RenPy Archive.");
            }

            if (Index[fileName].InArchive)
            {
                using BinaryReader reader = new BinaryReader(File.OpenRead(_archivePath), Encoding.UTF8);
                byte[] finalData = { };

                foreach (KeyValuePair<int, Tuples> kvpI in Index[fileName].Tuples)
                {
                    reader.BaseStream.Seek(kvpI.Value.Offset, SeekOrigin.Begin);
                    byte[] prefixData = kvpI.Value.Prefix;
                    byte[] fileData = reader.ReadBytes((int) kvpI.Value.Length - kvpI.Value.Prefix.Length); // Exported file max size ~2.14 GB
                    byte[] partData = new byte[finalData.Length + prefixData.Length + fileData.Length];
                    Buffer.BlockCopy(finalData, 0, partData, 0, finalData.Length);
                    Buffer.BlockCopy(prefixData, 0, partData, finalData.Length, prefixData.Length);
                    Buffer.BlockCopy(fileData, 0, partData, finalData.Length + prefixData.Length, fileData.Length);
                    finalData = partData;
                }

                return finalData;
            }
            
            return File.ReadAllBytes(Index[fileName].FullPath);
        }

        public string Extract(string fileName, string exportPath)
        {
            byte[] finalData = ExtractData(fileName);
            string finalPath;
            if (exportPath.Trim() == String.Empty)
            {
                finalPath = ArchiveInfo.DirectoryName + @"\" + fileName;
            }
            else
            {
                if (!Directory.Exists(exportPath.Trim()))
                {
                    throw new Exception("Selected export path does not exist.");
                }
                finalPath = exportPath.Trim() + @"\" + fileName;
            }

            Directory.CreateDirectory(Path.GetDirectoryName(finalPath) ?? throw new InvalidOperationException());
            File.WriteAllBytes(finalPath, finalData);

            return ArchiveInfo.DirectoryName + @"\" + fileName;
        }

        public string SaveArchive(string archivePath)
        {
            if (archivePath.ToLower().EndsWith(".rpi"))
            {
                archivePath = Regex.Replace(archivePath, @"\.rpi$", ".rpa", RegexOptions.IgnoreCase);
            }
            
            if (!archivePath.ToLower().EndsWith(".rpa"))
            {
                archivePath += ".rpa";
            }

            string tmpPath = Regex.Replace(archivePath, @"\.rpa$", "", RegexOptions.IgnoreCase);
            tmpPath = tmpPath.Substring(0, Math.Min(100, tmpPath.Length - 1)) + "_" +
                      DateTime.Now.ToString("yyyyMMddHHmmss") + "_" + Guid.NewGuid().ToString("N");

            /*if (archivePath == _archivePath && _archivePath != String.Empty)
            {
                throw new Exception("Cannot overwrite same archive file that is loaded.");
            }*/

            string indexPath = Regex.Replace(archivePath, @"\.rpa$", ".rpi", RegexOptions.IgnoreCase);

            /*if (indexPath == _indexPath && _indexPath != String.Empty)
            {
                throw new Exception("Cannot overwrite same index file that is loaded.");
            }*/
            
            BuildArchive(archivePath, indexPath, tmpPath);

            return archivePath;
        }

        private void BuildArchive(string archivePath, string indexPath, string tmpPath)
        {
            try
            {
                if (!File.Exists(tmpPath + ".rpa"))
                {
                    File.WriteAllBytes(tmpPath + ".rpa", new byte[] { });
                }

                using (Stream stream = File.Open(tmpPath + ".rpa", FileMode.Truncate))
                {
                    int archiveOffset;
                    switch (ArchiveVersion)
                    {
                        case Version.RPA_3_2:
                            archiveOffset = 34;
                            break;
                        case Version.RPA_3:
                            archiveOffset = 34;
                            break;
                        case Version.RPA_2:
                            archiveOffset = 25;
                            break;
                        case Version.RPA_1:
                            archiveOffset = 0;
                            break;
                        default:
                            throw new Exception("Specified version is not supported.");
                    }

                    stream.Position = archiveOffset;

                    Random rnd = new Random();

                    // Update indexes
                    Hashtable indexes = new Hashtable();
                    foreach (KeyValuePair<string, ArchiveIndex> index in Index)
                    {
                        byte[] content = ExtractData(index.Key);

                        if (Padding > 0)
                        {
                            string paddingStr = String.Empty;
                            int paddingLength = rnd.Next(1, Padding);

                            while (paddingLength > 0)
                            {
                                paddingStr += Encoding.ASCII.GetString(new[] {(byte) rnd.Next(1, 255)});
                                paddingLength--;
                            }

                            byte[] paddingBytes = Encoding.ASCII.GetBytes(paddingStr);
                            archiveOffset += paddingBytes.Length;
                        }

                        stream.Position = archiveOffset;
                        stream.Write(content, 0, content.Length);

                        List<object[]> indexData = new List<object[]>();
                        if (CheckVersion(ArchiveVersion, Version.RPA_3) ||
                            CheckVersion(ArchiveVersion, Version.RPA_3_2))
                        {
                            indexData.Add(new object[]
                                {archiveOffset ^ ObfuscationKey, content.Length ^ ObfuscationKey, ""}); // Last is prefix
                        }
                        else
                        {
                            indexData.Add(new object[] {archiveOffset, content.Length});
                        }

                        archiveOffset += content.Length;

                        indexes.Add(index.Value.TreePath, indexData);
                    }

                    byte[] pickledIndexes;
                    using (Pickler pickler = new Pickler())
                    {
                        pickledIndexes = pickler.dumps(indexes);
                    }

                    byte[] fileCompressed = ZlibStream.CompressBuffer(pickledIndexes);

                    if (!CheckVersion(ArchiveVersion, Version.RPA_1))
                    {
                        stream.Position = archiveOffset;
                        stream.Write(fileCompressed, 0, fileCompressed.Length);

                        string headerContent = String.Empty;

                        switch (ArchiveVersion)
                        {
                            case Version.RPA_3_2:
                                headerContent = ArchiveMagic.RPA_3_2 + archiveOffset.ToString("x").PadLeft(16, '0') +
                                                " " +
                                                ObfuscationKey.ToString("x").PadLeft(8, '0') + "\n";
                                break;
                            case Version.RPA_3:
                                headerContent = ArchiveMagic.RPA_3 + archiveOffset.ToString("x").PadLeft(16, '0') +
                                                " " +
                                                ObfuscationKey.ToString("x").PadLeft(8, '0') + "\n";
                                break;
                            case Version.RPA_2:
                                headerContent = ArchiveMagic.RPA_2 + archiveOffset.ToString("x").PadLeft(16, '0') +
                                                "\n";
                                break;
                        }

                        byte[] headerContentByte = Encoding.UTF8.GetBytes(headerContent);

                        stream.Position = 0;
                        stream.Write(headerContentByte, 0, headerContentByte.Length);
                    }
                    else
                    {
                        File.WriteAllBytes(tmpPath + ".rpi", fileCompressed);
                    }
                }

                try
                {
                    // Test if archive is corrupted or not
                    RpaParser testParse = new RpaParser();
                    testParse.LoadArchive(tmpPath + ".rpa");
                }
                catch (Exception ex)
                {
                    throw new Exception("Validation of newly created archive failed. This usually means corrupted archive file after creation. No harm was done to original archive. Parser failed with following error during validation: " + ex.Message);
                }

                File.Copy(tmpPath + ".rpa", archivePath, true);
                File.Delete(tmpPath + ".rpa");
                if (File.Exists(tmpPath + ".rpi"))
                {
                    File.Copy(tmpPath + ".rpi", indexPath, true);
                    File.Delete(tmpPath + ".rpi");
                }
            }
            catch
            {
                if (File.Exists(tmpPath + ".rpa"))
                {
                    File.Delete(tmpPath + ".rpa");
                }
                if (File.Exists(tmpPath + ".rpi"))
                {
                    File.Delete(tmpPath + ".rpi");
                }

                throw;
            }
        }
    }

    // https://stackoverflow.com/a/28418846/3650856
    public class StructConverter
    {
        // We use this function to provide an easier way to make type-agnostic call via GetBytes method of the BitConverter class.
        // This means we can have much cleaner code below.
        private static byte[] TypeAgnosticGetBytes(object o)
        {
            switch (o)
            {
                case char c:
                    return BitConverter.GetBytes(c);
                case int i:
                    return BitConverter.GetBytes(i);
                case uint u:
                    return BitConverter.GetBytes(u);
                case long l:
                    return BitConverter.GetBytes(l);
                case ulong @ulong:
                    return BitConverter.GetBytes(@ulong);
                case short s:
                    return BitConverter.GetBytes(s);
                case ushort @ushort:
                    return BitConverter.GetBytes(@ushort);
                case byte _:
                case sbyte _:
                    return new[] { (byte)o };
                default:
                    throw new ArgumentException("Unsupported object type found");
            }
        }

        private static string GetFormatSpecifierFor(object o)
        {
            switch (o)
            {
                case char _:
                    return "c";
                case int _:
                    return "i";
                case uint _:
                    return "I";
                case long _:
                    return "q";
                case ulong _:
                    return "Q";
                case short _:
                    return "h";
                case ushort _:
                    return "H";
                case byte _:
                    return "B";
                case sbyte _:
                    return "b";
                default:
                    throw new ArgumentException("Unsupported object type found");
            }
        }

        /// <summary>
        /// Convert a byte array into an array of objects based on Python's "struct.unpack" protocol.
        /// </summary>
        /// <param name="fmt">A "struct.pack"-compatible format string</param>
        /// <param name="bytes">An array of bytes to convert to objects</param>
        /// <returns>Array of objects.</returns>
        /// <remarks>You are responsible for casting the objects in the array back to their proper types.</remarks>
        public static object[] Unpack(string fmt, byte[] bytes)
        {
            Debug.WriteLine("Format string is length {0}, {1} bytes provided.", fmt.Length, bytes.Length);

            // First we parse the format string to make sure it's proper.
            if (fmt.Length < 1) throw new ArgumentException("Format string cannot be empty.");

            bool endianFlip = false;
            if (fmt.Substring(0, 1) == "<")
            {
                Debug.WriteLine("  Endian marker found: little endian");
                // Little endian.
                // Do we need to flip endianness?
                if (BitConverter.IsLittleEndian == false) endianFlip = true;
                fmt = fmt.Substring(1);
            }
            else if (fmt.Substring(0, 1) == ">")
            {
                Debug.WriteLine("  Endian marker found: big endian");
                // Big endian.
                // Do we need to flip endianness?
                if (BitConverter.IsLittleEndian) endianFlip = true;
                fmt = fmt.Substring(1);
            }

            // Now, we find out how long the byte array needs to be
            int totalByteLength = 0;
            foreach (char c in fmt)
            {
                Debug.WriteLine("  Format character found: {0}", c);
                switch (c)
                {
                    case 'q':
                    case 'Q':
                        totalByteLength += 8;
                        break;
                    case 'i':
                    case 'I':
                        totalByteLength += 4;
                        break;
                    case 'h':
                    case 'H':
                        totalByteLength += 2;
                        break;
                    case 'b':
                    case 'B':
                    case 'x':
                        totalByteLength += 1;
                        break;
                    default:
                        throw new ArgumentException("Invalid character found in format string.");
                }
            }

            Debug.WriteLine("Endianness will {0}be flipped.", (object)(endianFlip ? "" : "NOT "));
            Debug.WriteLine("The byte array is expected to be {0} bytes long.", totalByteLength);

            // Test the byte array length to see if it contains as many bytes as is needed for the string.
            if (bytes.Length != totalByteLength) throw new ArgumentException("The number of bytes provided does not match the total length of the format string.");

            // Ok, we can go ahead and start parsing bytes!
            int byteArrayPosition = 0;
            var outputList = new List<object>();

            Debug.WriteLine("Processing byte array...");
            foreach (char c in fmt)
            {
                byte[] buf;
                switch (c)
                {
                    case 'q':
                        outputList.Add(BitConverter.ToInt64(bytes, byteArrayPosition));
                        byteArrayPosition += 8;
                        Debug.WriteLine("  Added signed 64-bit integer.");
                        break;
                    case 'Q':
                        outputList.Add(BitConverter.ToUInt64(bytes, byteArrayPosition));
                        byteArrayPosition += 8;
                        Debug.WriteLine("  Added unsigned 64-bit integer.");
                        break;
                    case 'i':
                        outputList.Add(BitConverter.ToInt32(bytes, byteArrayPosition));
                        byteArrayPosition += 4;
                        Debug.WriteLine("  Added signed 32-bit integer.");
                        break;
                    case 'I':
                        outputList.Add(BitConverter.ToUInt32(bytes, byteArrayPosition));
                        byteArrayPosition += 4;
                        Debug.WriteLine("  Added unsigned 32-bit integer.");
                        break;
                    case 'h':
                        outputList.Add(BitConverter.ToInt16(bytes, byteArrayPosition));
                        byteArrayPosition += 2;
                        Debug.WriteLine("  Added signed 16-bit integer.");
                        break;
                    case 'H':
                        if (endianFlip)
                        {
                            var deezBytes = bytes.Reverse().Skip(byteArrayPosition).Take(2).ToArray();
                            outputList.Add(BitConverter.ToUInt16(deezBytes, 0));
                        }
                        else
                        {
                            outputList.Add(BitConverter.ToUInt16(bytes, byteArrayPosition));
                        }

                        byteArrayPosition += 2;
                        Debug.WriteLine("  Added unsigned 16-bit integer.");
                        break;
                    case 'b':
                        buf = new byte[1];
                        Array.Copy(bytes, byteArrayPosition, buf, 0, 1);
                        outputList.Add((sbyte)buf[0]);
                        byteArrayPosition++;
                        Debug.WriteLine("  Added signed byte");
                        break;
                    case 'B':
                        buf = new byte[1];
                        Array.Copy(bytes, byteArrayPosition, buf, 0, 1);
                        outputList.Add(buf[0]);
                        byteArrayPosition++;
                        Debug.WriteLine("  Added unsigned byte");
                        break;
                    case 'x':
                        byteArrayPosition++;
                        Debug.WriteLine("  Ignoring a byte");
                        break;
                    default:
                        throw new ArgumentException("You should not be here.");
                }
            }
            return outputList.ToArray();
        }

        /// <summary>
        /// Convert an array of objects to a byte array, along with a string that can be used with Unpack.
        /// </summary>
        /// <param name="items">An object array of items to convert</param>
        /// <param name="littleEndian">Set to False if you want to use big endian output.</param>
        /// <param name="neededFormatStringToRecover">Variable to place an 'Unpack'-compatible format string into.</param>
        /// <returns>A Byte array containing the objects provided in binary format.</returns>
        public static byte[] Pack(object[] items, bool littleEndian, out string neededFormatStringToRecover)
        {

            // make a byte list to hold the bytes of output
            var outputBytes = new List<byte>();

            // should we be flipping bits for proper endianness?
            bool endianFlip = (littleEndian != BitConverter.IsLittleEndian);

            // start working on the output string
            string outString = (littleEndian == false ? ">" : "<");

            // convert each item in the objects to the representative bytes
            foreach (object o in items)
            {
                byte[] theseBytes = TypeAgnosticGetBytes(o);
                if (endianFlip) theseBytes = theseBytes.Reverse().ToArray();
                outString += GetFormatSpecifierFor(o);
                outputBytes.AddRange(theseBytes);
            }

            neededFormatStringToRecover = outString;

            return outputBytes.ToArray();

        }

        public static byte[] Pack(object[] items)
        {
            string dummy = "";
            return Pack(items, true, out dummy);
        }
    }
}

Based on your request, I'll give a breakdown of the `RpaParser` class and its methods related to how file paths are constructed, particularly for media files. This will allow us to correctly adapt the path for `MediaInfoWrapper` used in your `PreviewSelectedItem` method. 

### RpaParser Breakdown

#### Key Elements of RpaParser

1. **Index Structure**:
   - The `Index` property is a `SortedDictionary<string, ArchiveIndex>` that stores the mappings between file paths (tree paths) and their corresponding metadata.
   - Each `ArchiveIndex` includes properties for `FullPath`, `TreePath`, `ParentPath`, and `InArchive`, which detail the structure of the files in the RPA archive.

2. **LoadArchive Method**:
   - This method is responsible for loading the archive and populating the `Index`.
   - The path to each asset in the archive is crucial for retrieving media information later.

3. **GetPreview Method**:
   - The `GetPreview` method is responsible for fetching the asset from the archive. It provides different types of previews based on the file type.

4. **ExtractData Method**:
   - This method extracts the binary data for files, with the ability to concatenate data if a single file consists of multiple entries in the index.

### Media File Paths

In the context of the files stored in the RPA archive:

- When you retrieve a file path from the `Index`, you may need to use the information in `ArchiveInfo` and `Index` to construct the operating system file path for accessing the media correctly.
  
### Updating the `PreviewSelectedItem` Method

The following updated method reflects how to build the correct path to call `MediaInfoWrapper`. The path will now properly reference where the media files should exist based on the structure defined in the `RpaParser`.

### Updated PreviewSelectedItem Method

```csharp
private async void PreviewSelectedItem()
{
    TreeNode selectedNode = new TreeNode();
    bool unsupportedFile = true;
    pictureBox1.Image = null;

    foreach (TreeNode node in treeView1.Nodes.All())
    {
        // Reset fields
        ResetPreviewFields();

        if (node.IsSelected)
        {
            selectedNode = node;
        }

        if (node.IsSelected && _rpaParser.Index.ContainsKey(NormalizeTreePath(node.FullPath)))
        {
            KeyValuePair<string, object> data = new KeyValuePair<string, object>();
            try
            {
                data = await Task.Run(() => _rpaParser.GetPreview(NormalizeTreePath(node.FullPath)));

                if (data.Key == RpaParser.PreviewTypes.Image)
                {
                    pictureBox1.Image = (Image)data.Value;
                    _switchTabs = true;
                    tabControl1.SelectedTab = tabPage1;
                    _switchTabs = false;
                    unsupportedFile = false;
                }
                else if (data.Key == RpaParser.PreviewTypes.Text)
                {
                    _searchStartIndex = 0;
                    textBox2.Text = (string)data.Value;
                    _switchTabs = true;
                    tabControl1.SelectedTab = tabPage2;
                    _switchTabs = false;
                    unsupportedFile = false;
                }
                else if (data.Key == RpaParser.PreviewTypes.Audio || data.Key == RpaParser.PreviewTypes.Video)
                {
                    _memoryStreamVlc = new MemoryStream((byte[])data.Value);
                    _streamMediaInputVlc = new StreamMediaInput(_memoryStreamVlc);
                    _mediaVlc = new Media(_libVlc, _streamMediaInputVlc);

                    // Ensure the media is stopped
                    await Task.Run(() =>
                    {
                        if (videoView1.MediaPlayer != null)
                        {
                            videoView1.MediaPlayer.Stop();
                        }
                    });

                    // Playback the new media
                    videoView1.MediaPlayer.Play(_mediaVlc);
                    SetMediaTimeLabel(_mediaVlc.Duration, 0);
                    videoView1.BackgroundImage = data.Key == RpaParser.PreviewTypes.Audio ? Resources.videoView1_BackgroundImage : null;
                    _switchTabs = true;
                    tabControl1.SelectedTab = tabPage3;
                    _switchTabs = false;
                    unsupportedFile = false;

                    // Check playback state to update button text
                    button4.Text = "Pause"; 

                    // Construct the absolute path to the media file
                    string normalizedPath = NormalizeTreePath(node.FullPath);
                    // Verify the path and build it correctly
                    string absolutePath = Path.Combine(_rpaParser.ArchiveInfo.DirectoryName, normalizedPath);
                    
                    // Debug output for the constructed absolute path
                    Console.WriteLine($"Absolute Path: {absolutePath}");

                    // Check if the file exists at the constructed absolute path
                    if (File.Exists(absolutePath))
                    {
                        var media = new MediaInfoWrapper(absolutePath); // Use MediaInfoWrapper

                        if (media.Success)
                        {
                            string format = media.Format; // Retrieve media format
                            string videoCodec = media.HasVideo ? media.VideoStreams[0].Codec.ToString() : "N/A"; // Video codec
                            string width = media.HasVideo ? media.VideoStreams[0].Width.ToString() : "N/A"; // Video width
                            string height = media.HasVideo ? media.VideoStreams[0].Height.ToString() : "N/A"; // Video height

                            // Display media info in the output textbox
                            string mediaInfo = $"Media Info: {videoCodec} ({width}x{height}, Format: {format})";
                            textBox1.AppendText(mediaInfo + Environment.NewLine); // Displaying media info
                            // Debugging output for media info
                            Console.WriteLine(mediaInfo);
                        }
                        else
                        {
                            textBox1.AppendText("Media info retrieval failed." + Environment.NewLine);
                        }
                    }
                    else
                    {
                        string errorMsg = $"Media file does not exist at: {absolutePath}";
                        textBox1.AppendText(errorMsg + Environment.NewLine);
                        // Log the non-existent file path
                        Console.WriteLine(errorMsg);
                    }
                }
            }
            catch (Exception ex)
            {
                MessageBox.Show(string.Format(GetText("Preview_failed_reason"), ex.Message), GetText("Preview_failed"), MessageBoxButtons.OK, MessageBoxIcon.Error);
            }

            break; // Exit after processing the selected item
        }
    }

    if (unsupportedFile)
    {
        _switchTabs = true;
        tabControl1.SelectedTab = tabPage0;
        _switchTabs = false;
        label2.Text = GetText("Preview_is_not_supported");
    }

    treeView1.SelectedNode = selectedNode;
    treeView1.SelectedNode.SelectedImageIndex = selectedNode.ImageIndex;
    treeView1.SelectedNode.EnsureVisible();
    treeView1.Focus();
}
```

### Key Adjustments:

- **Using `Path.Combine` for Absolute Path**: The absolute path is constructed using `Path.Combine`, ensuring that slashes are handled correctly.

- **Console Logging**: Added `Console.WriteLine` statements to log both the constructed absolute path and the media information for debugging.

- **Check for File Existence**: Before calling `MediaInfoWrapper`, we check if the absolute path points to an existing file.

### Additional Considerations

1. **Check Archive Extraction Logic**: Ensure that media files like `images/actives/barmen hover.png` are actually extracted from the RPA archive and saved at the expected paths.
2. **Print File Structure**: If you're still having difficulties, consider dumping the directory structure to the console for troubleshooting. Log what files exist at `D:\Games\DP-4.6-pc\game\` after extraction.
3. **Test with Actual Media Files**: Make sure you test the paths generated with media files that you are sure exist and are accessible. 

By following these updated steps, you should be able to correctly retrieve and display the media information needed within your `RPA_Explorer` application.

now I don't see any mediainfo text in window:
Archive version: 3
Archive location: D:\Games\DP-4.6-pc\game\archive.rpa
Archive size: 851 MiB
Files count: 6902
Unsaved files count: 0
Selected file path: images/actives/barmen hover.png
Selected file size: 9,05 KiB

Let's troubleshoot the existing code and ensure that the media info is being retrieved and displayed correctly. Here’s the strategy:

### 1. Ensure Proper File Existence
First, we want to ensure that the absolute path being constructed is indeed pointing to the correct media file. We'll enhance the debugging output to track every step closely.

### 2. Verify the Structure of the RPA Archive
To make sure the path points to the correct place, your media files need to be extracted from the RPA archive correctly. Here's how to rewrite the relevant parts of the code to include additional checks and improvements for clarity.

### Updated PreviewSelectedItem Method with Enhanced Debugging

```csharp
private async void PreviewSelectedItem()
{
    TreeNode selectedNode = new TreeNode();
    bool unsupportedFile = true;
    pictureBox1.Image = null;

    foreach (TreeNode node in treeView1.Nodes.All())
    {
        // Reset fields
        ResetPreviewFields();

        if (node.IsSelected)
        {
            selectedNode = node;
        }

        if (node.IsSelected && _rpaParser.Index.ContainsKey(NormalizeTreePath(node.FullPath)))
        {
            KeyValuePair<string, object> data = new KeyValuePair<string, object>();
            try
            {
                // Fetch preview data
                data = await Task.Run(() => _rpaParser.GetPreview(NormalizeTreePath(node.FullPath)));

                if (data.Key == RpaParser.PreviewTypes.Image)
                {
                    pictureBox1.Image = (Image)data.Value;
                    _switchTabs = true;
                    tabControl1.SelectedTab = tabPage1;
                    _switchTabs = false;
                    unsupportedFile = false;
                }
                else if (data.Key == RpaParser.PreviewTypes.Text)
                {
                    _searchStartIndex = 0;
                    textBox2.Text = (string)data.Value;
                    _switchTabs = true;
                    tabControl1.SelectedTab = tabPage2;
                    _switchTabs = false;
                    unsupportedFile = false;
                }
                else if (data.Key == RpaParser.PreviewTypes.Audio || data.Key == RpaParser.PreviewTypes.Video)
                {
                    // Media playback logic
                    _memoryStreamVlc = new MemoryStream((byte[])data.Value);
                    _streamMediaInputVlc = new StreamMediaInput(_memoryStreamVlc);
                    _mediaVlc = new Media(_libVlc, _streamMediaInputVlc);

                    // Ensure the media is stopped
                    await Task.Run(() =>
                    {
                        if (videoView1.MediaPlayer != null)
                        {
                            videoView1.MediaPlayer.Stop();
                        }
                    });

                    // Playback the new media
                    videoView1.MediaPlayer.Play(_mediaVlc);
                    SetMediaTimeLabel(_mediaVlc.Duration, 0);
                    videoView1.BackgroundImage = data.Key == RpaParser.PreviewTypes.Audio ? Resources.videoView1_BackgroundImage : null;
                    _switchTabs = true;
                    tabControl1.SelectedTab = tabPage3;
                    _switchTabs = false;
                    unsupportedFile = false;

                    // Check playback state to update button text
                    button4.Text = "Pause"; // Assuming you want to start playing the new video.
                }
            }
            catch (Exception ex)
            {
                MessageBox.Show(string.Format(GetText("Preview_failed_reason"), ex.Message), GetText("Preview_failed"), MessageBoxButtons.OK, MessageBoxIcon.Error);
            }

            // Construct the absolute path to the media file
            string normalizedPath = NormalizeTreePath(node.FullPath);
            string absolutePath = Path.Combine(_rpaParser.ArchiveInfo.DirectoryName, normalizedPath);

            // Debugging output for the constructed path
            Console.WriteLine($"Absolute Path: {absolutePath}");

            // Check if the file exists at the constructed absolute path
            if (File.Exists(absolutePath))
            {
                var media = new MediaInfoWrapper(absolutePath);

                if (media.Success)
                {
                    // Retrieve media information
                    string format = media.Format; // Retrieve media format
                    string videoCodec = media.HasVideo ? media.VideoStreams[0].Codec.ToString() : "N/A"; // Video codec
                    string width = media.HasVideo ? media.VideoStreams[0].Width.ToString() : "N/A"; // Video width
                    string height = media.HasVideo ? media.VideoStreams[0].Height.ToString() : "N/A"; // Video height
                    
                    // Prepare media info to display in text box
                    string mediaInfo = $"Media Info: {videoCodec} ({width}x{height}, Format: {format})";
                    textBox1.AppendText(mediaInfo + Environment.NewLine); // Append to the output textbox

                    // Log the media information for debugging
                    Console.WriteLine(mediaInfo);
                }
                else
                {
                    string errorMsg = "Media info retrieval failed.";
                    textBox1.AppendText(errorMsg + Environment.NewLine); // Log the error message
                    Console.WriteLine(errorMsg); // Debugging output
                }
            }
            else
            {
                string errorMsg = $"Media file does not exist at: {absolutePath}";
                textBox1.AppendText(errorMsg + Environment.NewLine); // Log the error message
                Console.WriteLine(errorMsg); // Debugging output
            }

            break; // Exit after processing the selected item
        }
    }

    if (unsupportedFile)
    {
        _switchTabs = true;
        tabControl1.SelectedTab = tabPage0;
        _switchTabs = false;
        label2.Text = GetText("Preview_is_not_supported");
    }

    treeView1.SelectedNode = selectedNode;
    treeView1.SelectedNode.SelectedImageIndex = selectedNode.ImageIndex;
    treeView1.SelectedNode.EnsureVisible();
    treeView1.Focus();
}
```

### Additional Steps to Debug and Verify

1. **Console Logs**: Observe the output in your console window or debug output to ensure:
   - The constructed absolute path is correct.
   - Whether the media file at that path exists.

2. **Check Archive Structure**: Verify that the images and any media files exist where you think they should after extraction. If they are not properly extracted, you may need to examine the `RpaParser` logic.

3. **Display in TextBox**: The `textBox1` should be set up in your form to accordingly show the media info retrieved. If the `textBox1` size is too small or not visible, you might not see the appended text. Ensure it’s large enough.

### Final Thoughts

This approach will help you determine why the media information does not appear as expected. Use the console debug statements to verify paths and existence, and make sure that files are correctly extracted from the RPA archive into locations your application can access. If you continuously see "Media file does not exist," it indicates a persistent issue with the path resolution logic or file extraction from the archive.

still getting error about missing file as before:
Archive version: 3
Archive location: D:\Games\DP-4.6-pc\game\archive.rpa
Archive size: 851 MiB
Files count: 6902
Unsaved files count: 0
Selected file path: images/actives/barmen hover.png
Selected file size: 9,05 KiBMedia file does not exist at: D:\Games\DP-4.6-pc\game\images/actives/barmen hover.png

It seems like the file you're trying to access using `MediaInfo` is being referenced incorrectly because the file is actually within the RPA archive. When using an RPA archive (Ren'Py archive), the files need to be extracted to a location on the file system before they can be accessed like normal files.

### Breakdown of the Solution

1. **Verify Extracted File Location**: The first thing we need to confirm is where the files are physically located and whether they are being extracted correctly from the RPA archive.

   - Check if the `ExtractData` method in the `RpaParser` is correctly extracting files to a location that the `GetMediaInfo` can access.

2. **Correct Path Resolution**: Since files are likely extracted to a temporary or designated directory, use that location instead of attempting to access them directly from the archive.

### Steps to Follow

Let's adjust the code accordingly to ensure we are referencing the correct output directory. This assumes that extracted media files reside in the directory where the archive is located or in a temporary directory. 

### Adding Code to Ensure Correct Media File Access

We will modify the `PreviewSelectedItem` method and ensure that we access the media file correctly.

Here's the revised method:

```csharp
private async void PreviewSelectedItem()
{
    TreeNode selectedNode = new TreeNode();
    bool unsupportedFile = true;
    pictureBox1.Image = null;

    foreach (TreeNode node in treeView1.Nodes.All())
    {
        // Reset fields
        ResetPreviewFields();

        if (node.IsSelected)
        {
            selectedNode = node;
        }

        if (node.IsSelected && _rpaParser.Index.ContainsKey(NormalizeTreePath(node.FullPath)))
        {
            KeyValuePair<string, object> data = new KeyValuePair<string, object>();
            try
            {
                // Get the preview data asynchronously
                data = await Task.Run(() => _rpaParser.GetPreview(NormalizeTreePath(node.FullPath)));

                if (data.Key == RpaParser.PreviewTypes.Image)
                {
                    pictureBox1.Image = (Image)data.Value;
                    _switchTabs = true;
                    tabControl1.SelectedTab = tabPage1;
                    _switchTabs = false;
                    unsupportedFile = false;
                }
                else if (data.Key == RpaParser.PreviewTypes.Text)
                {
                    _searchStartIndex = 0;
                    textBox2.Text = (string)data.Value;
                    _switchTabs = true;
                    tabControl1.SelectedTab = tabPage2;
                    _switchTabs = false;
                    unsupportedFile = false;
                }
                else if (data.Key == RpaParser.PreviewTypes.Audio || data.Key == RpaParser.PreviewTypes.Video)
                {
                    // Media playback logic
                    _memoryStreamVlc = new MemoryStream((byte[])data.Value);
                    _streamMediaInputVlc = new StreamMediaInput(_memoryStreamVlc);
                    _mediaVlc = new Media(_libVlc, _streamMediaInputVlc);

                    // Ensure the media is stopped
                    await Task.Run(() =>
                    {
                        if (videoView1.MediaPlayer != null)
                        {
                            videoView1.MediaPlayer.Stop();
                        }
                    });

                    // Playback the new media
                    videoView1.MediaPlayer.Play(_mediaVlc);
                    SetMediaTimeLabel(_mediaVlc.Duration, 0);
                    videoView1.BackgroundImage = data.Key == RpaParser.PreviewTypes.Audio ? Resources.videoView1_BackgroundImage : null;
                    _switchTabs = true;
                    tabControl1.SelectedTab = tabPage3;
                    _switchTabs = false;
                    unsupportedFile = false;

                    // Check playback state to update button text
                    button4.Text = "Pause"; // Assuming you want to start playing the new video.
                }
            }
            catch (Exception ex)
            {
                MessageBox.Show(string.Format(GetText("Preview_failed_reason"), ex.Message), GetText("Preview_failed"), MessageBoxButtons.OK, MessageBoxIcon.Error);
            }

            // Construct the absolute path to the media file
            string normalizedPath = NormalizeTreePath(node.FullPath);
            string absolutePath = Path.Combine(_rpaParser.ArchiveInfo.DirectoryName, normalizedPath);

            // For debugging
            Console.WriteLine($"Absolute Path: {absolutePath}");

            // Check if the file exists
            if (File.Exists(absolutePath))
            {
                var media = new MediaInfoWrapper(absolutePath);

                if (media.Success)
                {
                    string format = media.Format; // Retrieve media format
                    string videoCodec = media.HasVideo ? media.VideoStreams[0].Codec.ToString() : "N/A"; // Video codec
                    string width = media.HasVideo ? media.VideoStreams[0].Width.ToString() : "N/A"; // Video width
                    string height = media.HasVideo ? media.VideoStreams[0].Height.ToString() : "N/A"; // Video height
                    
                    // Prepare media info to display in text box
                    string mediaInfo = $"Media Info: {videoCodec} ({width}x{height}, Format: {format})";
                    textBox1.AppendText(mediaInfo + Environment.NewLine); // Append to text box
                }
                else
                {
                    textBox1.AppendText("Media info retrieval failed." + Environment.NewLine);
                }
            }
            else
            {
                string errorMsg = $"Media file does not exist at: {absolutePath}";
                textBox1.AppendText(errorMsg + Environment.NewLine); // Append error message
                Console.WriteLine(errorMsg);
            }

            break; // Exit after processing the selected item
        }
    }

    if (unsupportedFile)
    {
        _switchTabs = true;
        tabControl1.SelectedTab = tabPage0;
        _switchTabs = false;
        label2.Text = GetText("Preview_is_not_supported");
    }

    treeView1.SelectedNode = selectedNode;
    treeView1.SelectedNode.SelectedImageIndex = selectedNode.ImageIndex;
    treeView1.SelectedNode.EnsureVisible();
    treeView1.Focus();
}
```

### Key Adjustments

1. **Path Construction**:
   - In the adjusted code, we construct `absolutePath` from `_rpaParser.ArchiveInfo.DirectoryName` and `NormalizeTreePath(node.FullPath)`. This assumes the files are directly extracted into the archive's directory.

2. **File Existence Check**:
   - The code checks if the constructed absolute path points to an existing file before attempting to retrieve its media info.

3. **Debugging Output**:
   - Added console logs to trace paths and file existence checks.

### Step to Test

1. **Ensure Correct File Extraction**: Make sure that the file `"images/actives/barmen hover.png"` is indeed extracted from the RPA archive and is present in the `D:\Games\DP-4.6-pc\game\` directory (or the appropriate extracted path).
2. **Run the Application**: Observe the debug output via console logs to verify the constructed absolute path.
3. **Check Output**: See if media information appears in `textBox1`.

### Conclusion

This approach ensures that you're constructing file paths properly and checking for file existence accurately. If you continue to encounter issues, please verify the extraction logic in `RPA_Parser` to ensure all files are being managed correctly within the expected file structure.

help to fix error:
Отсутствует аргумент, соответствующий требуемому параметру "comparisonType" из "MemoryExtensions.Contains(ReadOnlySpan<char>, ReadOnlySpan<char>, StringComparison)".
Отсутствует аргумент, соответствующий требуемому параметру "comparisonType" из "MemoryExtensions.Contains(ReadOnlySpan<char>, ReadOnlySpan<char>, StringComparison)".
Отсутствует аргумент, соответствующий требуемому параметру "comparisonType" из "MemoryExtensions.Contains(ReadOnlySpan<char>, ReadOnlySpan<char>, StringComparison)".
```
using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Drawing;
using System.IO;
using System.Runtime.InteropServices;
using System.Text.RegularExpressions;
using System.Threading;
using System.Threading.Tasks;
using System.Windows.Forms;
using LibVLCSharp.Shared;
using Microsoft.Win32;
using NeoSmart.PrettySize;
using RPA_Parser;
using MediaInfo; // Import MediaInfo namespace
namespace RPA_Explorer
{
    public partial class RpaExplorer : Form
    {
        private RpaParser _rpaParser;
        private RpaParser _rpaParserBak;
        private Thread _operation;
        private bool _operationEnabled = true;
        private bool _archiveChanged;
        private bool _cancelAdd;
        private bool _archiveLoaded;
        private SortedDictionary<string, RpaParser.ArchiveIndex> _fileListBackup = new();
        private readonly Dictionary<string, long> _indexPathSize = new();
        private readonly List<string> _expandedList = new();
        private bool _switchTabs;
        private readonly LibVLC _libVlc; // https://code.videolan.org/mfkl/libvlcsharp-samples
        private MemoryStream _memoryStreamVlc;
        private StreamMediaInput _streamMediaInputVlc;
        private Media _mediaVlc;
        private int _searchStartIndex = 0;
        private static readonly FileInfo _appInfo = new(System.Reflection.Assembly.GetEntryAssembly()?.Location ?? throw new InvalidOperationException());
        private static readonly FileInfo _appName = new(System.Reflection.Assembly.GetEntryAssembly()?.GetName().Name ?? throw new InvalidOperationException());
        private readonly string settingsPath = Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData) + "/" + _appName + @"/settings.ini";

        private static readonly System.ComponentModel.ComponentResourceManager Lang = new(typeof(Lang));

        private static Settings settings;

        public RpaExplorer()
        {
            // Form initiation
            InitializeComponent();

            Directory.CreateDirectory(Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData) + "/" + _appName);

            settings = new Settings(settingsPath);

            // Language initiation
            foreach (Settings.Language lang in settings.LangList)
            {
                toolStripComboBox1.Items.Add(lang.Name);
            }

            toolStripComboBox1.SelectedItem = settings.GetLang().Name;

            LoadTexts();

            // LibVLC initiation
            Core.Initialize();
            _libVlc = new LibVLC("--input-repeat=9999999"); // --input-repeat=X : Loop X times
            videoView1.MediaPlayer = new MediaPlayer(_libVlc);
            videoView1.MediaPlayer.Volume = 50;
            videoView1.MediaPlayer.TimeChanged += videoView1_MediaPlayer_TimeChanged;
            videoView1.BackgroundImage = null;
            SetMediaTimeLabel(0, 0);

            // Initialize the seek bar
            seekBar.Maximum = 1000; // Set maximum value for smooth seeking
            seekBar.Scroll += SeekBar_Scroll; // Handle scroll events for seeking

            // Subscribe to the TabControl's SelectedIndexChanged event
            tabControl1.SelectedIndexChanged += TabControl1_SelectedIndexChanged;

            // Hide the seek bar initially
            seekBar.Visible = false;

            // TreeView styles initiation
            ImageList imageList = new ImageList();
            imageList.Images.Add(Resources.treeView1_Image_folder);
            imageList.Images.Add(Resources.treeView1_Image_file);
            imageList.Images.Add(Resources.treeView1_Image_fileChanged);
            treeView1.ImageList = imageList;

            // Arguments processing
            string[] args = Environment.GetCommandLineArgs();
            if (args.Length >= 2)
            {
                LoadArchive(args[1]);
            }
        }

        private void TabControl1_SelectedIndexChanged(object sender, EventArgs e)
        {
            // Show the seek bar only on the Media tab (tabPage3)
            if (tabControl1.SelectedTab == tabPage3)
            {
                seekBar.Visible = true;
            }
            else
            {
                seekBar.Visible = false;
            }
        }

        // Event handler for the seek bar's Scroll event
        private void SeekBar_Scroll(object sender, EventArgs e)
        {
            if (videoView1.MediaPlayer?.Media != null)
            {
                long duration = videoView1.MediaPlayer.Media.Duration;
                if (duration > 0)
                {
                    // Calculate newTime based on SeekBar position
                    long newTime = (long)((seekBar.Value / (double)seekBar.Maximum) * duration);
                    newTime = Math.Min(newTime, duration - 1); // Ensure newTime does not exceed duration

                    // Update the label3 based on the new time, independent of playback state
                    SetMediaTimeLabel(duration, newTime);

                    // Seek the video. If you want to seek immediately when scrolling, uncomment the line below.
                    videoView1.MediaPlayer.Time = newTime;
                }
            }
        }

        private void videoView1_MediaPlayer_TimeChanged(object sender, MediaPlayerTimeChangedEventArgs e)
        {
            Task.Run(async () =>
            {
                if (videoView1.MediaPlayer?.Media != null)
                {
                    long duration = videoView1.MediaPlayer.Media.Duration;

                    // Retry fetching duration if it seems invalid
                    if (duration <= 0)
                    {
                        await Task.Delay(500);
                        duration = videoView1.MediaPlayer.Media.Duration;
                    }

                    if (duration > 0)
                    {
                        int progress = (int)((e.Time / (double)duration) * seekBar.Maximum);
                        progress = Math.Min(progress, seekBar.Maximum);

                        seekBar.PerformSafely(() => seekBar.Value = progress);
                        SetMediaTimeLabel(duration, e.Time);
                    }
                }
            });
        }

        // Reset the seek bar when a new video is loaded
        private void ResetPreviewFields()
        {
            pictureBox1.Image = null;
            textBox2.Text = String.Empty;
            if (_memoryStreamVlc != null)
            {
                _memoryStreamVlc.Dispose();
                _memoryStreamVlc = null;
            }
            if (_streamMediaInputVlc != null)
            {
                _streamMediaInputVlc.Dispose();
                _streamMediaInputVlc = null;
            }
            if (_mediaVlc != null)
            {
                _mediaVlc.Dispose();
                _mediaVlc = null;
            }
            if (videoView1.MediaPlayer is { IsPlaying: true })
            {
                videoView1.MediaPlayer.Play(null!);
            }
            SetMediaTimeLabel(0, 0);

            // Reset the seek bar
            seekBar.Value = 0;
        }

        private void LoadTexts()
        {
            Text = GetText("Explorer_title");
            toolStripTextBox1.Text = GetText("Language");
            button1.Text = GetText("Load_file");
            button2.Text = GetText("Export_checked");
            statusBar1.Text = GetText("Ready");
            button3.Text = GetText("Cancel_operation");
            tabPage0.Text = GetText("None");
            label2.Text = GetText("Usage_instructions_new");
            tabPage1.Text = GetText("Image");
            tabPage2.Text = GetText("Text");
            tabPage3.Text = GetText("Media");
            button4.Text = GetText("Pause");
            button5.Text = GetText("Create_new_archive");
            label4.Text = GetText("File_list");
            button6.Text = GetText("Remove_checked");
            button7.Text = GetText("Save_archive");
            button8.Text = GetText("Search_next");
            label5.Text = GetText("Search");
            optionsToolStripMenuItem.Text = GetText("Options");
            associateRPARPIExtensionsToolStripMenuItem.Text = GetText("File_association");
            aboutToolStripMenuItem.Text = GetText("About");

            GenerateArchiveInfo();
        }

        internal static string GetText(string name)
        {
            if (Lang.GetObject(settings.GetLang().Abbrev + "_" + name) != null)
            {
                return Lang.GetObject(settings.GetLang().Abbrev + "_" + name)?.ToString();
            }

            return " {!!! MISSING TRANSLATION !!!} ";
        }

        private void ExportFiles(List<string> exportFilesList, FolderBrowserDialog folderBrowserDialog)
        {
            int counter = 0;
            int jobSize = exportFilesList.Count;
            foreach (string file in exportFilesList)
            {
                counter++;
                int pctProcessed = (int)Math.Ceiling((double)counter / jobSize * 100);
                label1.PerformSafely(() => label1.Text = $@"{counter} / {jobSize}");
                progressBar1.PerformSafely(() => progressBar1.Value = pctProcessed);

                statusBar1.PerformSafely(() => statusBar1.Text = GetText("Exporting_file") + file);

                _rpaParser.Extract(file, folderBrowserDialog.SelectedPath);

                if (!_operationEnabled)
                {
                    break;
                }
            }

            button1.PerformSafely(() => button1.Enabled = true);
            button2.PerformSafely(() => button2.Enabled = true);
            button3.PerformSafely(() => button3.Enabled = false);
            progressBar1.PerformSafely(() => progressBar1.Value = 0);
            label1.PerformSafely(() => label1.Text = "");
            statusBar1.PerformSafely(() => statusBar1.Text = GetText("Ready"));

            _operationEnabled = true;
        }

        private void CreateNewArchive()
        {
            if (CheckIfChanged(GetText("Archive_modified_new")))
            {
                return;
            }

            _expandedList.Clear();
            _rpaParser = new RpaParser();

            GenerateTreeView();

            _switchTabs = true;
            tabControl1.SelectedTab = tabPage0;
            _switchTabs = false;
            label2.Text = GetText("Usage_instructions_loaded");

            ResetPreviewFields();

            treeView1.SelectedNode = null;

            button2.Enabled = true;
            button6.Enabled = true;
            button7.Enabled = true;

            statusBar1.Text = GetText("Ready");

            _archiveChanged = true;
        }

        private void SaveArchive()
        {
            if (_rpaParser.Index.Count == 0)
            {
                MessageBox.Show(GetText("Empty_archive_save"), GetText("Empty_archive"), MessageBoxButtons.OK, MessageBoxIcon.Information);
                return;
            }

            statusBar1.Text = GetText("Saving_archive");

            string initPath = _appInfo?.DirectoryName;
            if (_rpaParser.ArchiveInfo?.DirectoryName != null)
            {
                initPath = _rpaParser.ArchiveInfo.DirectoryName;
            }

            SaveFileDialog saveFileDialog = new SaveFileDialog();
            saveFileDialog.Title = GetText("Save_RenPy_Archive");
            saveFileDialog.Filter = GetText("RPA_RPI_files") + @" (*.rpa,*.rpi)|*.rpa;*.rpi";
            saveFileDialog.InitialDirectory = initPath;
            saveFileDialog.CheckFileExists = false;
            saveFileDialog.CheckPathExists = true;

            ArchiveSave options = new ArchiveSave(_rpaParser);
            options.ShowDialog();

            if (!_rpaParser.OptionsConfirmed)
            {
                return;
            }

            if (saveFileDialog.ShowDialog() == DialogResult.OK)
            {
                _rpaParserBak = _rpaParser;
                try
                {
                    string saveName = _rpaParser.SaveArchive(saveFileDialog.FileName);
                    LoadArchive(saveName, true);
                }
                catch (Exception ex)
                {
                    _rpaParser = _rpaParserBak;
                    MessageBox.Show(
                        string.Format(GetText("Save_failed_reason"), ex.Message),
                        GetText("Save_failed"), MessageBoxButtons.OK, MessageBoxIcon.Error);
                }

                GenerateTreeView();

                statusBar1.Text = GetText("Ready");
            }
        }

        private void GenerateArchiveInfo()
        {
            string archiveInfo = String.Empty;

            if (_archiveLoaded)
            {
                string selectedPath = String.Empty;
                foreach (TreeNode node in treeView1.Nodes.All())
                {
                    if (node.IsSelected)
                    {
                        selectedPath = NormalizeTreePath(node.FullPath);
                    }
                }

                long selectedSize = -1;
                int unsavedCount = 0;
                foreach (KeyValuePair<string, RpaParser.ArchiveIndex> kvp in _rpaParser.Index)
                {
                    if (!kvp.Value.InArchive)
                    {
                        unsavedCount++;
                    }

                    if (selectedPath == kvp.Key)
                    {
                        selectedSize = kvp.Value.Length;
                    }
                }

                if (_indexPathSize.ContainsKey(selectedPath))
                {
                    selectedSize = _indexPathSize[selectedPath];
                }

                if (!_rpaParser.CheckVersion(_rpaParser.ArchiveVersion, RpaParser.Version.Unknown))
                {
                    archiveInfo += GetText("Archive_version") + _rpaParser.ArchiveVersion + Environment.NewLine;
                    archiveInfo += GetText("Archive_file_location") + _rpaParser.ArchiveInfo.FullName + Environment.NewLine;
                    archiveInfo += GetText("Archive_file_size") + PrettySize.Format(_rpaParser.ArchiveInfo.Length) + Environment.NewLine;
                    if (_rpaParser.IndexInfo != null)
                    {
                        archiveInfo += GetText("Index_file_location") + _rpaParser.IndexInfo.FullName + Environment.NewLine;
                        archiveInfo += GetText("Index_file_size") + PrettySize.Format(_rpaParser.IndexInfo.Length) + Environment.NewLine;
                    }
                }

                archiveInfo += GetText("Files_count") + _rpaParser.Index.Count + Environment.NewLine;
                archiveInfo += GetText("Unsaved_files_count") + unsavedCount + Environment.NewLine;

                if (selectedSize != -1)
                {
                    if (selectedPath == String.Empty)
                    {
                        selectedPath = "/";
                    }
                    archiveInfo += GetText("Selected_file_path") + selectedPath + Environment.NewLine;
                    archiveInfo += GetText("Selected_file_size") + PrettySize.Format(selectedSize) + Environment.NewLine;

                    // Check if the selected file is a media file (image or video)
                    if (_rpaParser.Index.ContainsKey(selectedPath))
                    {
                        string fileExtension = Path.GetExtension(selectedPath).ToLower();
                        if (_rpaParser.ImageExtList.Contains(fileExtension) || _rpaParser.VideoExtList.Contains(fileExtension))
                        {
                            try
                            {
                                // Extract the file data
                                byte[] fileData = _rpaParser.ExtractData(selectedPath);

                                // Save the file to a temporary location
                                string tempFilePath = Path.GetTempFileName();
                                File.WriteAllBytes(tempFilePath, fileData);

                                // Use MediaInfo to get media details
                                var mediaInfo = new MediaInfoWrapper(tempFilePath);
                                if (mediaInfo.Success)
                                {
                                    if (mediaInfo.HasVideo)
                                    {
                                        archiveInfo += GetText("Video_codec") + mediaInfo.VideoCodec + Environment.NewLine;
                                        archiveInfo += GetText("Resolution") + mediaInfo.Width + "x" + mediaInfo.Height + Environment.NewLine;
                                        archiveInfo += GetText("Frame_rate") + mediaInfo.Framerate + " fps" + Environment.NewLine;
                                    }
                                    else if (_rpaParser.ImageExtList.Contains(fileExtension))
                                    {
                                        archiveInfo += GetText("Image_codec") + mediaInfo.Format + Environment.NewLine;
                                        archiveInfo += GetText("Resolution") + mediaInfo.Width + "x" + mediaInfo.Height + Environment.NewLine;
                                    }
                                }

                                // Clean up the temporary file
                                File.Delete(tempFilePath);
                            }
                            catch (Exception ex)
                            {
                                // Handle any errors that occur during media info extraction
                                archiveInfo += GetText("Media_info_error") + ex.Message + Environment.NewLine;
                            }
                        }
                    }
                }
            }

            textBox1.Text = archiveInfo.Trim();
        }

        private void LoadArchive(string openFile, bool ignoreChanges = false)
        {
            if (!ignoreChanges)
            {
                if (CheckIfChanged(GetText("Archive_modified_load")))
                {
                    return;
                }
            }

            using OpenFileDialog openFileDialog = new OpenFileDialog();
            openFileDialog.Title = GetText("Load_RenPy_Archive");
            openFileDialog.Filter = GetText("RPA_RPI_files") + @" (*.rpa,*.rpi)|*.rpa;*.rpi";

            string archivePath = settings.GetArchive();
            if (!string.IsNullOrEmpty(archivePath))
            {
                FileInfo fi = new FileInfo(archivePath);
                openFileDialog.InitialDirectory = fi.DirectoryName;
            }

            DialogResult dialogResult = DialogResult.None;
            if (string.IsNullOrEmpty(openFile))
            {
                dialogResult = openFileDialog.ShowDialog();
            }
            else
            {
                if (openFile.EndsWith(".rpa") || openFile.EndsWith(".rpi"))
                {
                    dialogResult = DialogResult.OK;
                    openFileDialog.FileName = openFile;
                }
                else
                {
                    MessageBox.Show(
                        string.Format(GetText("Load_failed_reason"), GetText("Not_valid_archive_file")),
                        GetText("Load_failed"), MessageBoxButtons.OK, MessageBoxIcon.Error);
                    statusBar1.Text = GetText("Ready");
                    return;
                }
            }

            if (dialogResult == DialogResult.OK)
            {
                if (openFileDialog.CheckFileExists)
                {
                    settings.SetArchive(openFileDialog.FileName);
                    statusBar1.Text = GetText("Loading_file") + openFileDialog.FileName;

                    try
                    {
                        _expandedList.Clear();
                        _rpaParser = new RpaParser();

                        string appFolder = Path.GetDirectoryName(Application.ExecutablePath);
                        _rpaParser.UnrpycLocation = Path.Combine(appFolder, "unrpyc.exe");

                        _rpaParser.LoadArchive(openFileDialog.FileName);
                    }
                    catch (Exception ex)
                    {
                        MessageBox.Show(
                            string.Format(GetText("Load_failed_reason"), ex.Message),
                            GetText("Load_failed"), MessageBoxButtons.OK, MessageBoxIcon.Error);
                        statusBar1.Text = GetText("Ready");
                        return;
                    }

                    GenerateTreeView();

                    _switchTabs = true;
                    tabControl1.SelectedTab = tabPage0;
                    _switchTabs = false;
                    label2.Text = GetText("Usage_instructions_loaded");

                    ResetPreviewFields();

                    treeView1.SelectedNode = null;

                    button2.Enabled = true;
                    button6.Enabled = true;
                    button7.Enabled = true;

                    statusBar1.Text = GetText("Ready");
                }

                _archiveChanged = false;
            }
        }

        private void AddFilesToArchive(string[] pathList)
        {
            // TODO: prompt for path to inset files into? Default can be root or selected object?
            //       Or don't prompt and use selected object? Empty folders should be excluded.
            //string promptValue = Prompt.ShowDialog("Test", "123", "xx");

            _fileListBackup.Clear();
            _fileListBackup = _rpaParser.DeepCopyIndex(_rpaParser.Index);
            _cancelAdd = false;

            foreach (string path in pathList)
            {
                string originalPath = path;
                if (Directory.Exists(path))
                {
                    originalPath = new DirectoryInfo(path).Parent?.FullName;
                }
                if (File.Exists(path))
                {
                    originalPath = new FileInfo(path).DirectoryName;
                }
                AddPathToIndex(path, originalPath);
            }

            if (!_cancelAdd)
            {
                _rpaParser.Index = _rpaParser.DeepCopyIndex(_fileListBackup);
            }

            _fileListBackup.Clear();
            GenerateTreeView();
        }

        private void GenerateTreeView()
        {
            _indexPathSize.Clear();
            treeView1.Nodes.Clear();
            TreeNode root = new TreeNode();
            TreeNode node;
            root.Name = "";
            root.Text = @"/";
            root.BackColor = Color.SandyBrown;
            root.ImageIndex = 0;
            treeView1.Nodes.Add(root);
            _indexPathSize.Add("", 0);
            string pathBuild;

            // Folders first
            foreach (KeyValuePair<string, RpaParser.ArchiveIndex> kvp in _rpaParser.Index)
            {
                node = root;
                pathBuild = String.Empty;
                foreach (string pathBits in kvp.Key.Split('/'))
                {
                    if (pathBuild == String.Empty)
                    {
                        pathBuild = pathBits;
                    }
                    else
                    {
                        pathBuild += "/" + pathBits;
                    }

                    if (node.Nodes.ContainsKey(pathBits))
                    {
                        node = node.Nodes[pathBits];
                    }
                    else
                    {
                        if (pathBuild != kvp.Key)
                        {
                            node = node.Nodes.Add(pathBits, pathBits);
                        }
                    }
                }
            }

            // Files second
            foreach (KeyValuePair<string, RpaParser.ArchiveIndex> kvp in _rpaParser.Index)
            {
                node = root;
                pathBuild = String.Empty;
                foreach (string pathBits in kvp.Key.Split('/'))
                {
                    if (pathBuild == String.Empty)
                    {
                        pathBuild = pathBits;
                    }
                    else
                    {
                        pathBuild += "/" + pathBits;
                    }

                    node = node.Nodes.ContainsKey(pathBits) ? node.Nodes[pathBits] : node.Nodes.Add(pathBits, pathBits);

                    if (pathBuild != kvp.Key)
                    {
                        if (!_indexPathSize.ContainsKey(pathBuild))
                        {
                            _indexPathSize.Add(pathBuild, 0);
                        }

                        if (_rpaParser.Index.ContainsKey(kvp.Key))
                        {
                            _indexPathSize[pathBuild] += _rpaParser.Index[kvp.Key].Length;
                        }
                    }
                    else
                    {
                        _indexPathSize[""] += _rpaParser.Index[kvp.Key].Length;
                    }
                }
            }

            foreach (TreeNode nodeVisuals in treeView1.Nodes.All())
            {
                string nodeName = NormalizeTreePath(nodeVisuals.FullPath);

                if (nodeName != String.Empty)
                {
                    if (nodeVisuals.Nodes.Count > 0)
                    {
                        nodeVisuals.BackColor = Color.SandyBrown;
                        nodeVisuals.ImageIndex = 0;
                    }
                    else
                    {
                        nodeVisuals.BackColor = Color.Transparent;
                        nodeVisuals.ImageIndex = 1;
                    }
                }

                if (_rpaParser.Index.ContainsKey(nodeName))
                {
                    if (!_rpaParser.Index[nodeName].InArchive)
                    {
                        nodeVisuals.ForeColor = Color.Green;
                        nodeVisuals.ImageIndex = 2;

                        MarkChanged(nodeVisuals);
                    }
                }

                if (_expandedList.Contains(nodeVisuals.FullPath))
                {
                    nodeVisuals.Expand();
                }
            }

            root.Expand();
            _archiveLoaded = true;

            GenerateArchiveInfo();
        }

        private void MarkChanged(TreeNode node)
        {
            if (node.Parent != null)
            {
                node.Parent.ForeColor = Color.Green;
                MarkChanged(node.Parent);
            }
        }

        private void Search(TextBox tb, string pattern)
        {
            int index;

            tb.Focus();

            if ((index = tb.Text.IndexOf(pattern, _searchStartIndex, StringComparison.Ordinal)) != -1)
            {
                tb.Select(index, pattern.Length);
                _searchStartIndex = tb.SelectionStart + tb.SelectionLength;
            }
            else
            {
                _searchStartIndex = 0;
                if ((index = tb.Text.IndexOf(pattern, _searchStartIndex, StringComparison.Ordinal)) != -1)
                {
                    tb.Select(index, pattern.Length);
                    _searchStartIndex = tb.SelectionStart + tb.SelectionLength;
                }
                else
                {
                    tb.Select(0, 0);
                }
            }

            tb.ScrollToCaret();
        }

        private string NormalizeTreePath(string path)
        {
            return Regex.Replace(path, "^/+", "");
        }

        private async void PreviewSelectedItem()
        {
            TreeNode selectedNode = new TreeNode();
            bool unsupportedFile = true;
            pictureBox1.Image = null;

            foreach (TreeNode node in treeView1.Nodes.All())
            {
                // Reset fields
                ResetPreviewFields();

                if (node.IsSelected)
                {
                    selectedNode = node;
                }

                if (node.IsSelected && _rpaParser.Index.ContainsKey(NormalizeTreePath(node.FullPath)))
                {
                    KeyValuePair<string, object> data = new KeyValuePair<string, object>();
                    try
                    {
                        data = await Task.Run(() => _rpaParser.GetPreview(NormalizeTreePath(node.FullPath)));

                        if (data.Key == RpaParser.PreviewTypes.Image)
                        {
                            pictureBox1.Image = (Image)data.Value;
                            _switchTabs = true;
                            tabControl1.SelectedTab = tabPage1;
                            _switchTabs = false;
                            unsupportedFile = false;
                        }
                        else if (data.Key == RpaParser.PreviewTypes.Text)
                        {
                            _searchStartIndex = 0;
                            textBox2.Text = (string)data.Value;
                            _switchTabs = true;
                            tabControl1.SelectedTab = tabPage2;
                            _switchTabs = false;
                            unsupportedFile = false;
                        }
                        else if (data.Key == RpaParser.PreviewTypes.Audio || data.Key == RpaParser.PreviewTypes.Video)
                        {
                            _memoryStreamVlc = new MemoryStream((byte[])data.Value);
                            _streamMediaInputVlc = new StreamMediaInput(_memoryStreamVlc);
                            _mediaVlc = new Media(_libVlc, _streamMediaInputVlc);

                            // Ensure the media is stopped
                            await Task.Run(() =>
                            {
                                if (videoView1.MediaPlayer != null)
                                {
                                    videoView1.MediaPlayer.Stop();
                                }
                            });

                            // Playback the new media
                            videoView1.MediaPlayer.Play(_mediaVlc);
                            SetMediaTimeLabel(_mediaVlc.Duration, 0);
                            videoView1.BackgroundImage = data.Key == RpaParser.PreviewTypes.Audio ? Resources.videoView1_BackgroundImage : null;
                            _switchTabs = true;
                            tabControl1.SelectedTab = tabPage3;
                            _switchTabs = false;
                            unsupportedFile = false;

                            // Check playback state to update button text
                            button4.Text = "Pause"; // Assuming you want to start playing the new video.
                        }
                    }
                    catch (Exception ex)
                    {
                        MessageBox.Show(string.Format(GetText("Preview_failed_reason"), ex.Message), GetText("Preview_failed"), MessageBoxButtons.OK, MessageBoxIcon.Error);
                    }

                    break;
                }
            }

            if (unsupportedFile)
            {
                _switchTabs = true;
                tabControl1.SelectedTab = tabPage0;
                _switchTabs = false;
                label2.Text = GetText("Preview_is_not_supported");
            }

            treeView1.SelectedNode = selectedNode;
            treeView1.SelectedNode.SelectedImageIndex = selectedNode.ImageIndex;
            treeView1.SelectedNode.EnsureVisible();
            treeView1.Focus();
        }

        private void CheckAllChildNodes(TreeNode node, bool isChecked)
        {
            if (node.Nodes.Count == 0)
            {
                node.Checked = isChecked;
            }
            else
            {
                foreach (TreeNode childNode in node.Nodes)
                {
                    CheckAllChildNodes(childNode, isChecked);
                }
                node.Checked = isChecked;
            }
        }

        private void ParentCheckControl(TreeNode parentNode)
        {
            foreach (TreeNode node in parentNode.Nodes.All())
            {
                if (!node.Checked)
                {
                    parentNode.Checked = false;
                    break;
                }
                parentNode.Checked = true;
            }
            if (parentNode.Parent != null)
            {
                ParentCheckControl(parentNode.Parent);
            }
        }

        private void PlayPauseMedia()
        {
            if (videoView1.MediaPlayer is { IsPlaying: true })
            {
                videoView1.MediaPlayer?.Pause();
                button4.Text = GetText("Play");
            }
            else
            {
                videoView1.MediaPlayer?.Play();
                button4.Text = GetText("Pause");
            }
        }

        private void SetMediaTimeLabel(long totalTimeMillies, long currentTimeMillies)
        {
            TimeSpan totalTime = TimeSpan.FromMilliseconds(totalTimeMillies);
            TimeSpan currentTime = TimeSpan.FromMilliseconds(currentTimeMillies);
            TimeSpan remainingTime = totalTime - currentTime;

            string timeFormat = @"hh\:mm\:ss";
            string timeText = $"{currentTime.ToString(timeFormat)} / {totalTime.ToString(timeFormat)} (-{remainingTime.ToString(timeFormat)})";

            label3.PerformSafely(() => label3.Text = timeText);
        }

        private bool CheckIfChanged(string message)
        {
            if (message != String.Empty && _archiveChanged)
            {
                if (MessageBox.Show(message, GetText("Archive_modified"), MessageBoxButtons.YesNo, MessageBoxIcon.Warning) == DialogResult.No)
                {
                    return true;
                }

                return false;
            }

            return _archiveChanged;
        }

        private void AddPathToIndex(string path, string originalPath)
        {
            _archiveChanged = true;
            RpaParser.ArchiveIndex index = new RpaParser.ArchiveIndex
            {
                InArchive = false
            };

            if (Directory.Exists(path))
            {
                foreach (string pathFile in Directory.GetFiles(path))
                {
                    AddPathToIndex(pathFile, originalPath);
                }
                foreach (string pathDir in Directory.GetDirectories(path))
                {
                    AddPathToIndex(pathDir, originalPath);
                }
            }

            if (File.Exists(path) && !_cancelAdd)
            {
                index.FullPath = path.Replace(@"\", "/");
                index.TreePath = index.FullPath.Replace(originalPath.Replace(@"\", "/") + "/", String.Empty);
                index.ParentPath = Path.GetDirectoryName(index.TreePath);
                index.Length = new FileInfo(path).Length;
                index.InArchive = false;

                if (_fileListBackup.ContainsKey(index.TreePath))
                {
                    _fileListBackup.Remove(index.TreePath);
                }

                _fileListBackup.Add(index.TreePath, index);
            }
        }

        private void button1_Click(object sender, EventArgs e)
        {
            LoadArchive(String.Empty);
        }

        private void button2_Click(object sender, EventArgs e)
        {
            using FolderBrowserDialog folderBrowserDialog = new FolderBrowserDialog();
            List<string> exportFilesList = new List<string>();
            foreach (TreeNode node in treeView1.Nodes.All())
            {
                if (node.Checked && _rpaParser.Index.ContainsKey(NormalizeTreePath(node.FullPath)))
                {
                    exportFilesList.Add(NormalizeTreePath(node.FullPath));
                }
            }

            if (exportFilesList.Count == 0)
            {
                return;
            }

            folderBrowserDialog.SelectedPath = _rpaParser.ArchiveInfo.DirectoryName;
            if (folderBrowserDialog.ShowDialog() == DialogResult.OK)
            {
                button1.Enabled = false;
                button2.Enabled = false;
                button3.Enabled = true;
                progressBar1.Value = 0;
                label1.PerformSafely(() => label1.Text = "");

                _operation = new Thread(() => ExportFiles(exportFilesList, folderBrowserDialog));
                _operation.Start();
            }
        }

        public class FileAssociation
        {
            public string Extension { get; set; }
            public string ProgId { get; set; }
            public string FileTypeDescription { get; set; }
            public string ExecutableFilePath { get; set; }
        }

        public class FileAssociations
        {
            // needed so that Explorer windows get refreshed after the registry is updated
            [DllImport("Shell32.dll")]
            private static extern int SHChangeNotify(int eventId, int flags, IntPtr item1, IntPtr item2);

            private const int SHCNE_ASSOCCHANGED = 0x8000000;
            private const int SHCNF_FLUSH = 0x1000;


            public static void EnsureAssociationsSet(params FileAssociation[] associations)
            {
                bool madeChanges = false;
                foreach (FileAssociation association in associations)
                {
                    madeChanges |= SetAssociation(
                        association.Extension,
                        association.ProgId,
                        association.FileTypeDescription,
                        association.ExecutableFilePath);
                }

                if (madeChanges)
                {
                    SHChangeNotify(SHCNE_ASSOCCHANGED, SHCNF_FLUSH, IntPtr.Zero, IntPtr.Zero);
                }
            }

            private static bool SetAssociation(string extension, string progId, string fileTypeDescription, string applicationFilePath)
            {
                bool madeChanges = false;
                madeChanges |= SetKeyDefaultValue(@"Software\Classes\" + extension, progId);
                madeChanges |= SetKeyDefaultValue(@"Software\Classes\" + progId, fileTypeDescription);
                madeChanges |= SetKeyDefaultValue($@"Software\Classes\{progId}\shell\open\command", "\"" + applicationFilePath + "\" \"%1\"");
                return madeChanges;
            }

            private static bool SetKeyDefaultValue(string keyPath, string value)
            {
                using var key = Registry.CurrentUser.CreateSubKey(keyPath);
                if (key == null || key.GetValue(null) as string == value) return false;
                key.SetValue(null, value);
                return true;
            }
        }

        private void button3_Click(object sender, EventArgs e)
        {
            _operationEnabled = false;
        }

        private void treeView1_AfterSelect(object sender, EventArgs e)
        {
            PreviewSelectedItem();
            GenerateArchiveInfo();
        }

        private void treeView1_AfterCheck(object sender, TreeViewEventArgs e)
        {
            if (e.Action != TreeViewAction.Unknown)
            {
                Task.Run(async () =>
                {
                    await Task.Delay(50); // Prevent rapid selection from missing updates
                    Application.DoEvents(); // Force UI refresh to process all pending events

                    // Ensure all children are updated
                    if (e.Node.Nodes.Count > 0)
                    {
                        CheckAllChildNodes(e.Node, e.Node.Checked);
                    }

                    // Ensure parents reflect the correct state
                    if (e.Node.Parent != null)
                    {
                        ParentCheckControl(e.Node.Parent);
                    }
                });
            }
        }

        private void tabControl1_Selecting(object sender, TabControlCancelEventArgs e)
        {
            if (!_switchTabs)
            {
                e.Cancel = true;
            }
            _switchTabs = false;
        }

        private void button4_Click(object sender, EventArgs e)
        {
            PlayPauseMedia();
        }

        private void trackBar1_Scroll(object sender, EventArgs e)
        {
            if (videoView1.MediaPlayer?.Media != null)
            {
                videoView1.MediaPlayer.Volume = trackBar1.Value;
            }
        }

        private void RpaExplorer_FormClosing(object sender, FormClosingEventArgs e)
        {
            if (CheckIfChanged(GetText("Archive_modified_close")))
            {
                e.Cancel = true;
            }
        }

        private void button5_Click(object sender, EventArgs e)
        {
            CreateNewArchive();
        }

        private string targetFoldername; // Class-level variable to store the folder name

        private void treeView1_DragDrop(object sender, DragEventArgs e)
        {
            if (e.Data.GetDataPresent(DataFormats.FileDrop))
            {
                string[] droppedFiles = (string[])e.Data.GetData(DataFormats.FileDrop);

                // Initialize the targetFoldername variable
                targetFoldername = string.Empty; // Reset before each drop

                // Check if the first dropped item is a directory
                if (Directory.Exists(droppedFiles[0]))
                {
                    // If it's a folder, set targetFoldername to the name of that folder
                    targetFoldername = Path.GetFileName(droppedFiles[0]);
                }

                if (e.Data.GetDataPresent(DataFormats.FileDrop))
                {
                    AddFilesToArchive((string[])e.Data.GetData(DataFormats.FileDrop));
                }
            }
        }

        private void treeView1_DragEnter(object sender, DragEventArgs e)
        {
            if (e.Data.GetDataPresent(DataFormats.FileDrop) && _archiveLoaded)
            {
                e.Effect = DragDropEffects.Copy;
                return;
            }
            e.Effect = DragDropEffects.None;
        }

        private void tabControl1_DragEnter(object sender, DragEventArgs e)
        {
            if (e.Data.GetDataPresent(DataFormats.FileDrop))
            {
                e.Effect = DragDropEffects.Copy;
                return;
            }
            e.Effect = DragDropEffects.None;
        }

        private void tabControl1_DragDrop(object sender, DragEventArgs e)
        {
            if (e.Data.GetDataPresent(DataFormats.FileDrop))
            {
                LoadArchive(((string[])e.Data.GetData(DataFormats.FileDrop))[0]);
            }
        }

        private void button6_Click(object sender, EventArgs e)
        {
            bool changed = false;
            foreach (TreeNode node in treeView1.Nodes.All())
            {
                if (node.Checked && _rpaParser.Index.ContainsKey(NormalizeTreePath(node.FullPath)))
                {
                    _rpaParser.Index.Remove(NormalizeTreePath(node.FullPath));
                    changed = true;
                }
            }

            if (changed)
            {
                _archiveChanged = true;
                GenerateTreeView();
            }
        }

        private void button7_Click(object sender, EventArgs e)
        {
            SaveArchive();
        }

        private void treeView1_BeforeCollapse(object sender, TreeViewCancelEventArgs e)
        {
            if (_expandedList.Contains(e.Node.FullPath))
            {
                _expandedList.Remove(e.Node.FullPath);
            }
        }

        private void treeView1_BeforeExpand(object sender, TreeViewCancelEventArgs e)
        {
            _expandedList.Add(e.Node.FullPath);
        }

        private void toolStripComboBox1_SelectedIndexChanged(object sender, EventArgs e)
        {
            settings.SetLang(toolStripComboBox1.SelectedItem.ToString());
            LoadTexts();
        }

        private void button8_Click(object sender, EventArgs e)
        {
            if (textBox3.Text.Trim() != String.Empty)
            {
                Search(textBox2, textBox3.Text.Trim());
            }
        }

        private void associateRPARPIExtensionsToolStripMenuItem_Click(object sender, EventArgs e)
        {
            ProcessModule processModule = Process.GetCurrentProcess().MainModule;
            if (processModule != null)
            {
                string filePath = processModule.FileName;
                FileAssociations.EnsureAssociationsSet(
                    new FileAssociation
                    {
                        Extension = ".rpi",
                        ProgId = "RPA Explorer",
                        FileTypeDescription = "RenPy Index File",
                        ExecutableFilePath = filePath
                    },
                    new FileAssociation
                    {
                        Extension = ".rpa",
                        ProgId = "RPA Explorer",
                        FileTypeDescription = "RenPy Archive File",
                        ExecutableFilePath = filePath
                    });
            }
        }

        private void aboutToolStripMenuItem_Click(object sender, EventArgs e)
        {
            new About().ShowDialog();
        }
    }

    public static class Prompt
    {
        public static string ShowDialog(string text, string caption, string defaultValue)
        {
            Form prompt = new Form
            {
                Width = 500,
                Height = 150,
                FormBorderStyle = FormBorderStyle.FixedDialog,
                Text = caption,
                StartPosition = FormStartPosition.CenterScreen,
                MaximizeBox = false,
                MinimizeBox = false,
                TopMost = true
            };
            Label textLabel = new Label { Left = 50, Top = 20, Text = text };
            TextBox textBox = new TextBox { Left = 50, Top = 50, Width = 400, Text = defaultValue };
            Button confirmation = new Button { Text = @"OK", Left = 350, Width = 101, Top = 70, DialogResult = DialogResult.OK };
            confirmation.Click += (sender, e) => { prompt.Close(); };
            prompt.Controls.Add(textBox);
            prompt.Controls.Add(confirmation);
            prompt.Controls.Add(textLabel);
            prompt.AcceptButton = confirmation;

            return prompt.ShowDialog() == DialogResult.OK ? textBox.Text : String.Empty;
        }
    }

    public static class CrossThreadExtensions
    {
        public static void PerformSafely(this Control target, Action action)
        {
            if (target.InvokeRequired)
            {
                target.Invoke(action);
            }
            else
            {
                action();
            }
        }

        public static void PerformSafely<T1>(this Control target, Action<T1> action, T1 parameter)
        {
            if (target.InvokeRequired)
            {
                target.Invoke(action, parameter);
            }
            else
            {
                action(parameter);
            }
        }

        public static void PerformSafely<T1, T2>(this Control target, Action<T1, T2> action, T1 p1, T2 p2)
        {
            if (target.InvokeRequired)
            {
                target.Invoke(action, p1, p2);
            }
            else
            {
                action(p1, p2);
            }
        }
    }


    public static class Extensions
    {
        public static IEnumerable<TreeNode> All(this TreeNodeCollection nodes)
        {
            foreach (TreeNode n in nodes)
            {
                yield return n;
                foreach (TreeNode child in n.Nodes.All())
                    yield return child;
            }
        }
    }
}

Let’s break down the `RPA_Parser` class to understand how it extracts and retrieves file paths for media files, particularly images and videos, and then use that information to ensure we are correctly implementing the same logic for the `MediaInfoWrapper`.

### Breakdown of RPA_Parser

1. **Extracting Data**:
    - The `ExtractData` method in `RpaParser` reads from the archive based on the index that is generated in `GetIndexes()`. This method is essential in determining how files are accessed from the archive. It handles the compression and obfuscation of data and returns the raw byte data of a specific file.

2. **Structure of ArchiveIndex**:
    - It includes:
        - `FullPath`: Full path of the file (inside the archive).
        - `TreePath`: Path used in the tree structure.
        - `InArchive`: Boolean indicating if the file is part of the archive.
        - `Length`: Size of the file.

3. **Indexing Contents**:
    - When `GetPreview` is called, it relies on the index created during the loading of the RPA, effectively allowing the user to get access to the files as a virtual structure even if they are packed inside the archive.

### Accessing Media Files

- Media files appear to be accessed using their indices, specifically pulled out for rendering previews in the application and later referenced directly.
- The way the paths are constructed must align with how the files are stored in the RPA.

### Implementation in PreviewSelectedItem

Given the details from `RPA_Parser`, let's rewrite the `PreviewSelectedItem` method to ensure that the `MediaInfoWrapper` is checking the correct file path and that you retrieve the necessary media information correctly.

### Revised Code for PreviewSelectedItem

Here’s the updated implementation for `PreviewSelectedItem` method with proper path handling for `MediaInfoWrapper`:

```csharp
private async void PreviewSelectedItem()
{
    TreeNode selectedNode = new TreeNode();
    bool unsupportedFile = true;
    pictureBox1.Image = null;

    foreach (TreeNode node in treeView1.Nodes.All())
    {
        // Reset fields
        ResetPreviewFields();

        if (node.IsSelected)
        {
            selectedNode = node;
        }

        if (node.IsSelected && _rpaParser.Index.ContainsKey(NormalizeTreePath(node.FullPath)))
        {
            KeyValuePair<string, object> data = new KeyValuePair<string, object>();
            try
            {
                // Fetch the preview data
                data = await Task.Run(() => _rpaParser.GetPreview(NormalizeTreePath(node.FullPath)));

                if (data.Key == RpaParser.PreviewTypes.Image)
                {
                    pictureBox1.Image = (Image)data.Value;
                    _switchTabs = true;
                    tabControl1.SelectedTab = tabPage1;
                    _switchTabs = false;
                    unsupportedFile = false;
                }
                else if (data.Key == RpaParser.PreviewTypes.Text)
                {
                    _searchStartIndex = 0;
                    textBox2.Text = (string)data.Value;
                    _switchTabs = true;
                    tabControl1.SelectedTab = tabPage2;
                    _switchTabs = false;
                    unsupportedFile = false;
                }
                else if (data.Key == RpaParser.PreviewTypes.Audio || data.Key == RpaParser.PreviewTypes.Video)
                {
                    // Media playback handling
                    _memoryStreamVlc = new MemoryStream((byte[])data.Value);
                    _streamMediaInputVlc = new StreamMediaInput(_memoryStreamVlc);
                    _mediaVlc = new Media(_libVlc, _streamMediaInputVlc);

                    // Stop any currently playing media
                    await Task.Run(() =>
                    {
                        if (videoView1.MediaPlayer != null)
                        {
                            videoView1.MediaPlayer.Stop();
                        }
                    });

                    // Start playing the new media
                    videoView1.MediaPlayer.Play(_mediaVlc);
                    SetMediaTimeLabel(_mediaVlc.Duration, 0);
                    videoView1.BackgroundImage = data.Key == RpaParser.PreviewTypes.Audio ? Resources.videoView1_BackgroundImage : null;
                    _switchTabs = true;
                    tabControl1.SelectedTab = tabPage3;
                    _switchTabs = false;
                    unsupportedFile = false;

                    // Update playback state
                    button4.Text = "Pause"; // Update button text as needed
                }
            }
            catch (Exception ex)
            {
                MessageBox.Show(string.Format(GetText("Preview_failed_reason"), ex.Message), GetText("Preview_failed"), MessageBoxButtons.OK, MessageBoxIcon.Error);
            }

            // **Path handling**
            string normalizedPath = NormalizeTreePath(node.FullPath);
            string absolutePath = Path.Combine(_rpaParser.ArchiveInfo.DirectoryName, normalizedPath);

            // Debugging Output: Log the resolved path
            Console.WriteLine($"Constructed Absolute Path: {absolutePath}"); // This will help ensure that the path is correct

            // Check if the file exists to avoid errors
            if (File.Exists(absolutePath))
            {
                var media = new MediaInfoWrapper(absolutePath);

                if (media.Success)
                {
                    // Retrieve media information
                    string format = media.Format;
                    string videoCodec = media.HasVideo ? media.VideoStreams[0].Codec : "N/A"; // Get video codec
                    string width = media.HasVideo ? media.VideoStreams[0].Width.ToString() : "N/A"; // Get width
                    string height = media.HasVideo ? media.VideoStreams[0].Height.ToString() : "N/A"; // Get height
                    
                    // Display media info
                    string mediaInfo = $"Media Info: {videoCodec} ({width}x{height}, Format: {format})";
                    textBox1.AppendText(mediaInfo + Environment.NewLine); // Append media info to your output textbox

                    // Log completed media info extraction
                    Console.WriteLine(mediaInfo);
                }
                else
                {
                    textBox1.AppendText("Media info retrieval failed." + Environment.NewLine); // For failed retrieval
                }
            }
            else
            {
                string errorMsg = $"Media file does not exist at: {absolutePath}";
                textBox1.AppendText(errorMsg + Environment.NewLine); // Append error to output textbox
                Console.WriteLine(errorMsg); // Debugging output for trace
            }

            break; // Exit after processing the selected item
        }
    }

    if (unsupportedFile)
    {
        _switchTabs = true;
        tabControl1.SelectedTab = tabPage0;
        _switchTabs = false;
        label2.Text = GetText("Preview_is_not_supported");
    }

    // Restore the selected node state
    treeView1.SelectedNode = selectedNode;
    treeView1.SelectedNode.SelectedImageIndex = selectedNode.ImageIndex;
    treeView1.SelectedNode.EnsureVisible();
    treeView1.Focus();
}
```

### Key Additions and Changes Explained:

1. **Debugging Output**:
   - Console logging prints the constructed absolute path so you can check if it matches your expectations.

2. **Path Resolution**:
   - Correctly constructs the `absolutePath` using both `ArchiveInfo.DirectoryName` and `NormalizeTreePath(node.FullPath)` to ensure that paths are accurate.

3. **Existence Check**:
   - Before attempting to use the `MediaInfoWrapper`, the code checks if the file exists at the absolute path, preventing errors from trying to access a non-existent file.

4. **Feedback for Media Information**:
   - The information retrieved is appended to `textBox1` for display and also logged for your reference.

### Important Note

Ensure the RPA files are extracted properly and are accessible in the file system. If `barmen hover.png` should be in the same directory relative to the game's folder, it should be structured as such in your archive management and extraction.

### Troubleshooting

- Use the console output to check the full paths being constructed and ensure they correspond correctly to where the actual image files are located in relation to the extracted archive.
- Confirm the contents of the RPA archive align with the file paths being generated. If they don't match, you may need to adjust how files are extracted or stored in the archive.

No, I meant to fix _rpaParser.ImageExtList.Contains error in function below:
        private void GenerateArchiveInfo()
        {
            string archiveInfo = String.Empty;

            if (_archiveLoaded)
            {
                string selectedPath = String.Empty;
                foreach (TreeNode node in treeView1.Nodes.All())
                {
                    if (node.IsSelected)
                    {
                        selectedPath = NormalizeTreePath(node.FullPath);
                    }
                }

                long selectedSize = -1;
                int unsavedCount = 0;
                foreach (KeyValuePair<string, RpaParser.ArchiveIndex> kvp in _rpaParser.Index)
                {
                    if (!kvp.Value.InArchive)
                    {
                        unsavedCount++;
                    }

                    if (selectedPath == kvp.Key)
                    {
                        selectedSize = kvp.Value.Length;
                    }
                }

                if (_indexPathSize.ContainsKey(selectedPath))
                {
                    selectedSize = _indexPathSize[selectedPath];
                }

                if (!_rpaParser.CheckVersion(_rpaParser.ArchiveVersion, RpaParser.Version.Unknown))
                {
                    archiveInfo += GetText("Archive_version") + _rpaParser.ArchiveVersion + Environment.NewLine;
                    archiveInfo += GetText("Archive_file_location") + _rpaParser.ArchiveInfo.FullName + Environment.NewLine;
                    archiveInfo += GetText("Archive_file_size") + PrettySize.Format(_rpaParser.ArchiveInfo.Length) + Environment.NewLine;
                    if (_rpaParser.IndexInfo != null)
                    {
                        archiveInfo += GetText("Index_file_location") + _rpaParser.IndexInfo.FullName + Environment.NewLine;
                        archiveInfo += GetText("Index_file_size") + PrettySize.Format(_rpaParser.IndexInfo.Length) + Environment.NewLine;
                    }
                }

                archiveInfo += GetText("Files_count") + _rpaParser.Index.Count + Environment.NewLine;
                archiveInfo += GetText("Unsaved_files_count") + unsavedCount + Environment.NewLine;

                if (selectedSize != -1)
                {
                    if (selectedPath == String.Empty)
                    {
                        selectedPath = "/";
                    }
                    archiveInfo += GetText("Selected_file_path") + selectedPath + Environment.NewLine;
                    archiveInfo += GetText("Selected_file_size") + PrettySize.Format(selectedSize) + Environment.NewLine;

                    // Check if the selected file is a media file (image or video)
                    if (_rpaParser.Index.ContainsKey(selectedPath))
                    {
                        string fileExtension = Path.GetExtension(selectedPath).ToLower();
                        if (_rpaParser.ImageExtList.Contains(fileExtension) || _rpaParser.VideoExtList.Contains(fileExtension))
                        {
                            try
                            {
                                // Extract the file data
                                byte[] fileData = _rpaParser.ExtractData(selectedPath);

                                // Save the file to a temporary location
                                string tempFilePath = Path.GetTempFileName();
                                File.WriteAllBytes(tempFilePath, fileData);

                                // Use MediaInfo to get media details
                                var mediaInfo = new MediaInfoWrapper(tempFilePath);
                                if (mediaInfo.Success)
                                {
                                    if (mediaInfo.HasVideo)
                                    {
                                        archiveInfo += GetText("Video_codec") + mediaInfo.VideoCodec + Environment.NewLine;
                                        archiveInfo += GetText("Resolution") + mediaInfo.Width + "x" + mediaInfo.Height + Environment.NewLine;
                                        archiveInfo += GetText("Frame_rate") + mediaInfo.Framerate + " fps" + Environment.NewLine;
                                    }
                                    else if (_rpaParser.ImageExtList.Contains(fileExtension))
                                    {
                                        archiveInfo += GetText("Image_codec") + mediaInfo.Format + Environment.NewLine;
                                        archiveInfo += GetText("Resolution") + mediaInfo.Width + "x" + mediaInfo.Height + Environment.NewLine;
                                    }
                                }

                                // Clean up the temporary file
                                File.Delete(tempFilePath);
                            }
                            catch (Exception ex)
                            {
                                // Handle any errors that occur during media info extraction
                                archiveInfo += GetText("Media_info_error") + ex.Message + Environment.NewLine;
                            }
                        }
                    }
                }
            }

            textBox1.Text = archiveInfo.Trim();
        }

To fix the error related to `_rpaParser.ImageExtList.Contains`, we need to ensure that the list of supported image formats is correctly referenced and that any logic involving file format checks is implemented accurately.

### 1. Understanding the Error

The error might stem from:
- **Incorrect Initialization**: If `_rpaParser.ImageExtList` is not properly initialized or is being accessed incorrectly.
- **Inconsistent File Extensions**: Confirm that `fileExtension` retrieved from `Path.GetExtension(selectedPath).ToLower()` is matching the formats in `ImageExtList` and `VideoExtList` properly.

### 2. Suggested Code Implementation

Here's how you can modify the `GenerateArchiveInfo` method to ensure it works correctly:

1. **Ensure Image and Video Extensions Are Set Properly**: Make sure you still define what file types to recognize as images or videos.
2. **Use Contains Correctly**: The `Contains` check from the collection should be straightforward, without any issues related to unused or undefined objects.

### Revised Code for `GenerateArchiveInfo`

```csharp
private void GenerateArchiveInfo()
{
    string archiveInfo = String.Empty;

    if (_archiveLoaded)
    {
        string selectedPath = String.Empty;
        foreach (TreeNode node in treeView1.Nodes.All())
        {
            if (node.IsSelected)
            {
                selectedPath = NormalizeTreePath(node.FullPath);
            }
        }

        long selectedSize = -1;
        int unsavedCount = 0;
        
        foreach (KeyValuePair<string, RpaParser.ArchiveIndex> kvp in _rpaParser.Index)
        {
            if (!kvp.Value.InArchive)
            {
                unsavedCount++;
            }

            if (selectedPath == kvp.Key)
            {
                selectedSize = kvp.Value.Length;
            }
        }

        if (_indexPathSize.ContainsKey(selectedPath))
        {
            selectedSize = _indexPathSize[selectedPath];
        }

        if (!_rpaParser.CheckVersion(_rpaParser.ArchiveVersion, RpaParser.Version.Unknown))
        {
            archiveInfo += GetText("Archive_version") + _rpaParser.ArchiveVersion + Environment.NewLine;
            archiveInfo += GetText("Archive_file_location") + _rpaParser.ArchiveInfo.FullName + Environment.NewLine;
            archiveInfo += GetText("Archive_file_size") + PrettySize.Format(_rpaParser.ArchiveInfo.Length) + Environment.NewLine;
            if (_rpaParser.IndexInfo != null)
            {
                archiveInfo += GetText("Index_file_location") + _rpaParser.IndexInfo.FullName + Environment.NewLine;
                archiveInfo += GetText("Index_file_size") + PrettySize.Format(_rpaParser.IndexInfo.Length) + Environment.NewLine;
            }
        }

        archiveInfo += GetText("Files_count") + _rpaParser.Index.Count + Environment.NewLine;
        archiveInfo += GetText("Unsaved_files_count") + unsavedCount + Environment.NewLine;

        if (selectedSize != -1)
        {
            if (selectedPath == String.Empty)
            {
                selectedPath = "/";
            }
            archiveInfo += GetText("Selected_file_path") + selectedPath + Environment.NewLine;
            archiveInfo += GetText("Selected_file_size") + PrettySize.Format(selectedSize) + Environment.NewLine;

            // ** Check if the selected file is a media file (image or video) **
            if (_rpaParser.Index.ContainsKey(selectedPath))
            {
                string fileExtension = Path.GetExtension(selectedPath).ToLower();
                // Check if selectedPath is an image or video file
                if (_rpaParser.ImageExtList.Contains(fileExtension) || _rpaParser.VideoExtList.Contains(fileExtension))
                {
                    try
                    {
                        // Extract the file data
                        byte[] fileData = _rpaParser.ExtractData(selectedPath);

                        // Save the file to a temporary location
                        string tempFilePath = Path.GetTempFileName();
                        File.WriteAllBytes(tempFilePath, fileData);

                        // Use MediaInfo to get media details
                        var media = new MediaInfoWrapper(tempFilePath);
                        if (media.Success)
                        {
                            if (media.HasVideo)
                            {
                                archiveInfo += GetText("Video_codec") + media.VideoCodec + Environment.NewLine;
                                archiveInfo += GetText("Resolution") + media.Width + "x" + media.Height + Environment.NewLine;
                                archiveInfo += GetText("Frame_rate") + media.Framerate + " fps" + Environment.NewLine;
                            }
                            else if (media.HasVideo == false)
                            {
                                archiveInfo += GetText("Image_codec") + media.Format + Environment.NewLine;
                                archiveInfo += GetText("Resolution") + media.Width + "x" + media.Height + Environment.NewLine;
                            }
                        }

                        // Clean up the temporary file
                        File.Delete(tempFilePath);
                    }
                    catch (Exception ex)
                    {
                        // Handle any errors that occur during media info extraction
                        archiveInfo += GetText("Media_info_error") + ex.Message + Environment.NewLine;
                    }
                }
            }
        }
    }

    // Output the information to the textBox1
    textBox1.Text = archiveInfo.Trim(); // Display the archive info
}
```

### Explanation of Changes

1. **File Type Checks**:
   - We're checking if the selected file path has an extension that is present in either the image or video extension lists. This is done with the line:
     ```csharp
     if (_rpaParser.ImageExtList.Contains(fileExtension) || _rpaParser.VideoExtList.Contains(fileExtension))
     ```

2. **Try-Catch for Media Info**:
   - The media information extraction is encapsulated within a try-catch block to handle any errors gracefully.

3. **Use of MediaInfoWrapper**:
   - Checks `media.Success` to see if the media file was successfully processed before collecting codec and resolution data. 

4. **Appending Media Info**:
   - Appends media info to the `archiveInfo` string and displays it in `textBox1` at the end of the method.

### Debugging Tips

- **Output Log**: Add `Console.WriteLine` statements temporarily to log the file extensions being checked, and whether the file is being accessed correctly.
- **File Existence**: Make sure that the `media` files actually exist in the output directory of the RPA extraction process.

### Conclusion

With these adjustments, the code structure for checking extensions and handling media file information should work as expected. Please ensure you have the correct media files and check the paths after extraction to facilitate smooth functionality. If still not working, please verify the actual files within your archive once extracted for any discrepancies in naming or paths.