FormFuncs.cs

using SimpleRIFF.Interfaces;
using SimpleRIFF.RIFF_Objects;
using SimpleRIFF.Streams;
#pragma warning disable CS8602

namespace FSB5BankParser
{
    public partial class MainForm
    {
        #region Bank Loading Funcs
        private void LoadFSB5Files()
        {
            using FolderBrowserDialog dialog = new();
            dialog.Description = "Select Folder with FSB5 files";
            dialog.UseDescriptionForTitle = true;

            if (dialog.ShowDialog() == DialogResult.OK && !string.IsNullOrWhiteSpace(dialog.SelectedPath))
            {
                UnloadFSB5Files();
                BankFolder = dialog.SelectedPath;

                Console.WriteLine($"Selected Path: {BankFolder}" +
                    $"\nLoading Bank Files...");

                // Get all files in the folder, and make sure that Master.strings.bank is loaded first
                // (this is actually no longer needed, but i'll keep it anyways)
                var FolderFiles = Directory.GetFiles(BankFolder, "*.bank")
                    .OrderByDescending(f => Path.GetFileName(f).Equals("Master.strings.bank", StringComparison.OrdinalIgnoreCase));

                #region Idiot Proof Checks
                if (Directory.GetFiles(BankFolder, "*.fsb").Length > 0)
                {
                    // prevent user from using FSB4 files, since this tool obviously doesn't support that
                    Console.WriteLine("ERROR: Input is unsupported (FSB4)");
                    MessageBox.Show("FSB4 files (.fsb) are unsupported by this tool" +
                        "\nPlease use FSB5 files (.bank) instead", "Error");

                    BankFolder = string.Empty;
                    return;
                }
                if (!FolderFiles.Any())
                {
                    // prevent user from using FSB4 files, since this tool obviously doesn't support that
                    Console.WriteLine("ERROR: No .bank files were found");
                    MessageBox.Show("No .bank files were found in the selected directory" +
                        "\nPlease check the selected directory and try again", "Error");

                    BankFolder = string.Empty;
                    return;
                }
                if (!File.Exists($"{BankFolder}/Master.strings.bank"))
                {
                    Console.WriteLine("ERROR: Master.strings.bank is not present!");
                    MessageBox.Show("Master.strings.bank is not present!" +
                        "\nPlease ensure that it's within the selected folder", "Error");

                    BankFolder = string.Empty;
                    return;
                }
                #endregion

                // Get Paths from Master.strings.bank
                if (File.Exists($"{BankFolder}/Master.strings.bank"))
                    GetStringPaths($"{BankFolder}/Master.strings.bank");

                // Load every bank file
                foreach (string bankFilePath in FolderFiles)
                {
                    var bankname = Path.GetFileName(bankFilePath);
                    using FileStream fs = new(bankFilePath, FileMode.Open, FileAccess.Read);
                    using (RIFFStream rs = new(fs))
                    {
                        // Create RIFF Object
                        RIFFObject? riffObject = new();

                        // Parse it
                        riffObject?.Read(rs);
                        rs.Close();

                        // Keep track of all RIFF Objects through these
                        BankFiles.Add(bankname);
                        RIFFObjects[bankname] = riffObject;
                        Console.WriteLine($"Loaded Bank: {bankname}");
                    }
                    fs.Close();
                }

                Console.WriteLine("Loading TreeView...");
                LoadTreeView();
            }
        }
        private void UnloadFSB5Files()
        {
            if (BankFiles.Count == 0) return; // if empty

            Console.WriteLine("Unloading Bank Files...");
            // Get every loaded RIFF Object and clear it
            foreach (string bank in BankFiles)
            {
                RIFFObjects?[bank]?.Children.Clear();
                Console.WriteLine($"Unloaded Bank File {bank}");
            }

            // Clear these vars
            FMODSystem = new();
            BankFolder = string.Empty;
            OutputDir = string.Empty;
            BankFiles = [];
            RIFFObjects = [];
            Console.WriteLine("Unloaded System Data");

            ClearMasterGUIDs();
            UnloadTreeView();

            Console.WriteLine("Unloaded TreeView");
            GC.Collect();
        }
        #endregion

        #region TreeView
        void LoadTreeView()
        {
            UnloadTreeView();

            foreach (string bank in BankFiles)
            {
                // Get RIFF Object
                RIFFObject? BankRIFF = RIFFObjects?[bank];

                // Add Bank File to Tree
                if (BankRIFF != null)
                {
                    var BankNode = bankTreeView.Nodes.Add(bank);
                    BankNode.ToolTipText = getBankTooltip(bank);

                    addChildrenToNode(BankNode, BankRIFF, bank);
                }
            }

            // because why not
            GC.Collect();
            Console.WriteLine($"Loaded TreeView");

            return;

            void addChildrenToNode(TreeNode node, IContainerChunk chunk, string bankfile)
            {
                foreach (IGenericChunk item in chunk.Children)
                {
                    cCode = item.CharacterCode.Code;
                    ItemAsObj = item as RIFFGenericDataObject;
                    ItemAsList = item as RIFFListObject;

                    switch (cCode)
                    {
                        case "LIST": // Chunk is a List
                            var listType = ItemAsList.ListType;
                            string displayName = getFullNameFromNodeName(listType.Code) ?? $"{cCode} - TYPE: {listType}";

                            var newNode = node.Nodes.Add(displayName);
                            newNode.ToolTipText = getTooltipInfo(listType.Code);

                            addChildrenToNode(newNode, ItemAsList, bankfile);
                            CheckEmptyChunk(newNode);
                            break;

                        case "LCNT": // List Count Chunk Header (comes after LIST)
                            node.Nodes.Add($"List Count: ({BitConverter.ToInt32(ItemAsObj.Data)})");
                            break;

                        default: // Parse any other chunk
                            string DisplayName = getFullNameFromNodeName(cCode) ?? cCode;

                            // node stuffs
                            latestNode = node.Nodes.Add($"{DisplayName} - ({ItemAsObj.Data.Length})");
                            latestNode.ToolTipText = getTooltipInfo(cCode);
                            latestNode.Tag = ItemAsObj;
                            latestNode.ContextMenuStrip = blockContextMenuStrip;

                            // Parse Chunks and add chunk info to node
                            ParseChunk(item, bankfile);
                            CheckEmptyChunk(latestNode);
                            break;
                    }

                    // clean this shit
                    cCode = null;
                    ItemAsObj = null;
                    ItemAsList = null;
                    latestNode = null;

                    // thing to remove empty nodes
                    void CheckEmptyChunk(TreeNode newNode)
                    {
                        if (!ShowEmptyChunks && newNode.Nodes.Count == 0)
                            node.Nodes.Remove(newNode);
                    }
                }
            }
        }
        void UnloadTreeView() {
            bankTreeView.Nodes.Clear();
        }

        #region Parse Chunk Resolver
        void ParseChunk(IGenericChunk item, string bankfile)
        {
            switch (cCode)
            {
                // Sounds
                case "SND ": ParseChunkSND($"{BankFolder}/{bankfile}"); break;

                // Events
                case "EVTB": ParseChunkEVTB(bankfile); break;

                // Timelines
                case "TLNB": ParseChunkTLNB(); break;

                // Sound Modules (Point to Sound Files, used in Timelines and Action)
                case "WAIB": ParseChunkWAIB(); break;

                // SubChunk
                case "INST": ParseChunkINST(); break;

                // Action Only Chunk
                // Replaces Timeline if Event is Action, and is connected to MUIB
                case "PLST": ParseChunkPLST(); break;

                // VCA's
                case "VCAB": ParseChunkVCAB(); break;

                // Parameters
                case "PRMB": ParseChunkPRMB(); break;

                // Properties (Can be used by different chunks)
                case "PROP": ParseChunkPROP(item); break;

                // Master.strings.bank only chunk
                // Has ALL GUIDs and String Paths
                case "STDT": ParseChunkSTDT(bankfile); break;

                case "HASH": ParseChunkHASH(); break;

                // Bank File Info Chunk
                case "BNKI": ParseChunkBNKI(bankfile); break;

                // MixerMaster
                case "MBSB": ParseChunkMBSB(); break;

                case "RBSB": // MixerReturn
                case "IBSB": // MixerInput
                case "GBSB": // MixerGroup
                    ParseMixerChunks();
                    break;

                // Parameter Settings?
                case "PMLB": ParseChunkPMLB(); break;

                // idk needs research
                case "CTRL": ParseChunkCTRL(); break;

                // idk needs research
                case "CURV": ParseChunkCURV(); break;

                // Effects
                case "BEFB": ParseChunkBEFB(); break;

                // Snapshot
                case "SNAB": ParseChunkSNAB(); break;

                // Transitions
                // basically markers and shit in timelines
                case "TRNB": ParseChunkTRNB(); break;
                // connects GBSB, MBSB, CURVs
                case "TRTL": ParseChunkTRTL(); break;
                // connects Transitions to CURV/CTRL (sometimes empty)
                case "CTRO": ParseChunkCTRO(); break;

                // Generic Buses idk
                case "BUS ": ParseChunkBUS(); break;

                // Modules
                case "MODB": ParseChunkMODB(); break;

                // Command
                case "CMDB": ParseChunkCMDB(); break;

                // Nested Events
                case "EVIB": ParseChunkEVIB(); break;

                // Chunks that just have their own GUID
                // (although there might be unknown vals)

                case "PLAT": ParseChunkPLAT(); break; // Platform

                case "MUIB": // MultiSound (in action events)
                case "WAV ": // Sound files
                case "SLNB": // SilenceSound
                case "MAP ": // Manages PROP GUIDs

                case "SCEF": // idk
                    ParseChunkGeneric();
                    break;
            }
        }
        #endregion

        #region Node Name Strings
        string? getFullNameFromNodeName(string nodeName)
        {
            return nodeName switch
            {
                "PROJ" => $"Project ({nodeName})",
                "FMT " => $"Format ({nodeName})",
                "BNKI" => $"Bank Info ({nodeName})",

                "PRPS" => $"Properties ({nodeName})",
                "PROP" => $"Property ({nodeName})",

                "BUS " => $"Generic Bus ({nodeName})",

                "GBSS" => $"MixerGroup Buses ({nodeName})",
                "GBUS" => $"MixerGroup Bus ({nodeName})",
                "GBSB" => $"MixerGroup Bus Binary ({nodeName})",

                "RBSS" => $"MixerReturn Buses ({nodeName})",
                "RBUS" => $"MixerReturn Bus ({nodeName})",
                "RBSB" => $"MixerReturn Bus Binary ({nodeName})",

                "MBSS" => $"MixerMaster Buses ({nodeName})",
                "MBUS" => $"MixerMaster Bus ({nodeName})",
                "MBSB" => $"MixerMaster Bus Binary ({nodeName})",

                "IBSS" => $"MixerInput Buses ({nodeName})",
                "IBUS" => $"MixerInput Bus ({nodeName})",
                "IBSB" => $"MixerInput Bus Binary ({nodeName})",

                "EVTS" => $"Events ({nodeName})",
                "EVNT" => $"Event ({nodeName})",
                "EVTB" => $"Event Binary ({nodeName})",

                "EVIS" => $"Nested Events ({nodeName})",
                "EVIT" => $"Nested Event ({nodeName})",
                "EVIB" => $"Nested Event Binary ({nodeName})",

                "TLNS" => $"Timelines ({nodeName})",
                "TMLN" => $"Timeline ({nodeName})",
                "TLNB" => $"Timeline Binary ({nodeName})",
                "INST" => $"Timeline Instance ({nodeName})",

                "TRNS" => $"Tranisitions ({nodeName})",
                "TRAN" => $"Tranisition ({nodeName})",
                "TRNB" => $"Tranisition Binary ({nodeName})",

                "MUIS" => $"MultiSounds ({nodeName})",
                "MUIT" => $"MultiSound ({nodeName})",
                "MUIB" => $"MultiSound Binary ({nodeName})",

                "PLST" => $"Sound List ({nodeName})",

                "PRMS" => $"Parameters ({nodeName})",
                "PARM" => $"Parameter ({nodeName})",
                "PRMB" => $"Parameter Binary ({nodeName})",

                "PMLS" => $"Event Parameters ({nodeName})",
                "PMLO" => $"Event Parameter ({nodeName})",
                "PMLB" => $"Event Parameter Binary ({nodeName})",

                "CTRS" => $"Fade Curves ({nodeName})",
                "CTRL" => $"Fade Curve ({nodeName})",
                "CRVS" => $"Transition Curves ({nodeName})",
                "CURV" => $"Transition Curve ({nodeName})",

                "CMDS" => $"Commands ({nodeName})",
                "CMDI" => $"Command ({nodeName})",
                "CMDB" => $"Command Binary ({nodeName})",

                "MODS" => $"Modules ({nodeName})",
                "MODU" => $"Module ({nodeName})",
                "MODB" => $"Module Binary ({nodeName})",

                "BEFX" => $"Effects ({nodeName})",
                "BEFF" => $"Effect ({nodeName})",
                "BEFB" => $"Effect Binary ({nodeName})",

                "WAVS" => $"WAV Files ({nodeName})",
                "WAV " => $"WAV File ({nodeName})",

                "WAIS" => $"WAV Instances ({nodeName})",
                "WAIT" => $"WAV Instance ({nodeName})",
                "WAIB" => $"WAV Instance Binary ({nodeName})",

                "VCAS" => $"VCAs ({nodeName})",
                "VCA " => $"VCA ({nodeName})",
                "VCAB" => $"VCA Binary ({nodeName})",

                "SNAS" => $"Snapshots ({nodeName})",
                "SNAP" => $"Snapshot ({nodeName})",
                "SNAB" => $"Snapshot Binary ({nodeName})",

                "SLNS" => $"SilenceSounds ({nodeName})",
                "SLNI" => $"SilenceSound ({nodeName})",
                "SLNB" => $"SilenceSound Binary ({nodeName})",

                "MPGS" => $"Managed Properties ({nodeName})",
                "MAP " => $"Managed Property ({nodeName})",

                "HASH" => $"Hash ({nodeName})",
                "SND " => $"Sound ({nodeName})",
                "PLAT" => $"Platform ({nodeName})",

                "STDT" => $"String Data Table ({nodeName})",
                _ => null,
            };
        }
        #endregion
        #region ToolTip Strings
        // TODO - make better and more informative tooltips
        // aka use current research to explain what these chunks are used for
        string getTooltipInfo(string nodeName)
        {
            return nodeName switch
            {
                "PROJ" => "Project Information",
                "FMT " => "Format Information",
                "BNKI" => "Bank File Information",

                "PRPS" => "List of all Chunk Property Entries",
                "PROP" => "Chunk Property Entry",

                "BUS " => "Generic Bus Entry",

                "GBSS" => "List of all Group Bus Entries",
                "GBUS" => "Group Bus Entry",
                "GBSB" => "Group Bus Entry Information",

                "RBSS" => "List of all Return Bus Entries",
                "RBUS" => "Return Bus Entry",
                "RBSB" => "Return Bus Entry Information",

                "MBSS" => "List of all Master Bus Entries",
                "MBUS" => "Master Bus Entry",
                "MBSB" => "Master Bus Entry Information",

                "IBSS" => "List of all Input Bus Entries",
                "IBUS" => "Input Bus Entry",
                "IBSB" => "Input Bus Entry Information",

                "EVTS" => "List of all Event Entries",
                "EVNT" => "Event Entry",
                "EVTB" => "Event Entry Information",

                "EVIS" => "List of all Nested Events",
                "EVIT" => "Nested Event Entry",
                "EVIB" => "Nested Event Entry Information",

                "TLNS" => "List of all Timeline Entries",
                "TMLN" => "Timeline Entry",
                "TLNB" => "Timeline Entry Information",
                "INST" => "A Reference to a Timeline Instance",

                "TRNS" => "List of all Tranisition Entries",
                "TRAN" => "Tranisition Entry",
                "TRNB" => "Tranisition Entry Information",

                "MUIS" => "List of all MultiSound Module Entries",
                "MUIT" => "MultiSound Module Entry",
                "MUIB" => "MultiSound Module Entry Information",

                "PLST" => "Alongside MultiSounds\n" +
                            "List of Sound WAV GUIDs referenced\n" +
                            "As well as info on what instrument the MultiSound is",

                "PRMS" => "List of all Parameter Entries",
                "PARM" => "Parameter Entry",
                "PRMB" => "Parameter Entry Information",

                "PMLS" => "List of all Parameters references in Events",
                "PMLO" => "Parameter reference",
                "PMLB" => "Parameter reference Information",

                "CTRS" => "List of all Fade Curve Entries",
                "CTRL" => "Fade Curve Entry",
                "CRVS" => "List of all Transition Curve Entries",
                "CURV" => "Transition Curve Entry",

                "CMDS" => "List of all Command Entries",
                "CMDI" => "Command Entry",
                "CMDB" => "Command Entry Information",

                "MODS" => "List of all Module Entries",
                "MODU" => "Module Entry",
                "MODB" => "Module Entry Information",

                "BEFX" => "List of all Event/Bus Effect Entries",
                "BEFF" => "Event/Bus Effect Entry",
                "BEFB" => "Event/Bus Effect Entry Information",

                "WAVS" => "List of all WAV File Entries\n(Only provides their GUIDs)",
                "WAV " => "WAV File Entry\n(Only provides their GUIDs)",

                "WAIS" => "List of all WAV Instance Entries\n(Every seperate instance of a sound being used)",
                "WAIT" => "WAV Instance Entry\n(Every seperate instance of a sound being used)",
                "WAIB" => "WAV Instance Entry Information",

                "VCAS" => "List of all VCA Entries",
                "VCA " => "VCA Entry",
                "VCAB" => "VCA Entry Information",

                "SNAS" => "List of all Snapshot Entries",
                "SNAP" => "Snapshot Entry",
                "SNAB" => "Snapshot Entry Information",

                "SLNS" => "List of all SilenceSound Entries",
                "SLNI" => "SilenceSound Entry",
                "SLNB" => "SilenceSound Entry Information",

                "MPGS" => "List of all Managed Property Entries",
                "MAP " => "Managed Property Entry",

                "HASH" => "Contains all GUIDs in the Bank File",
                "SND " => "List of all Sound Files in the Bank File",
                "PLAT" => "Platform Information",

                "STDT" => "A Table that contains all Paths and their GUIDs",

                _ => string.Empty
            };
        }
        #endregion
        #region Bank File Tooltip
        string getBankTooltip(string bank)
        {
            return bank switch
            {
                "Master.strings.bank" => 
                    "The main bank file that links all the other bank files together",

                // TODO - see if including Master.bank is really always required
                //"Master.bank" => "The default bank file that is always included along side Master.strings",

                // default
                _ => "An additional bank file containing most of the important data"
            };
        }
        #endregion
        #endregion

        #region Export Chunk
        private void ExportSelectedChunk()
        {
            // check tag type
            switch (bankTreeView.SelectedNode.Tag)
            {
                // if type string
                case string text:
                    // copy to clipboard
                    Clipboard.SetText(text);
                    break;

                // if sound file, save as .wav/.ogg/whatever extension
                case AudioConstructor snd:
                    SaveFile("Sound", snd.Name, snd.Ext, snd.Data);
                    break;

                // if just binary file
                case RIFFGenericDataObject bin:
                    SaveFile("Binary", bankTreeView.SelectedNode.Text, "bin", bin.Data);
                    break;
            }

            static void SaveFile(string Name, string FileName, string FileExt, byte[] Data) 
            {
                using SaveFileDialog dlg = new();
                dlg.Title = $"Choose where to save the {Name} File";
                dlg.Filter = $"{Name} files (*.{FileExt})|*.{FileExt}|All files (*.*)|*.*";
                dlg.DefaultExt = FileExt;
                dlg.FileName = $"{FileName}.{FileExt}";

                if (dlg.ShowDialog() == DialogResult.OK)
                    File.WriteAllBytes(dlg.FileName, Data);
            }
        }
        #endregion
    }
}