public static TagInstance ParseTagName(OpenTagCache info, string name)
        {
            if (name.Length == 0 || !char.IsLetter(name[0]) || !name.Contains('.'))
                throw new Exception($"Invalid tag name: {name}");

            var namePieces = name.Split('.');

            var groupTag = ParseGroupTag(info.StringIDs, namePieces[1]);
            if (groupTag == Tag.Null)
                throw new Exception($"Invalid tag name: {name}");

            var tagName = namePieces[0];
            
            foreach (var nameEntry in info.TagNames)
            {
                if (nameEntry.Value == tagName)
                {
                    var instance = info.Cache.Tags[nameEntry.Key];

                    if (instance.Group.Tag == groupTag)
                        return instance;
                }
            }

            Console.WriteLine($"Invalid tag name: {name}");
            return null;
        }

 public static CommandContext Create(CommandContext parent, OpenTagCache info, HaloTag tag, Model model)
 {
     var context = new CommandContext(parent, string.Format("{0:X8}.hlmt", tag.Index));
     context.AddCommand(new HlmtListVariantsCommand(info, model));
     context.AddCommand(new HlmtExtractModeCommand(info, model));
     return context;
 }

 public static CommandContext Create(CommandContextStack stack, OpenTagCache info)
 {
     var context = new CommandContext(null, info.CacheFile.Name);
     context.AddCommand(new HelpCommand(stack));
     context.AddCommand(new DependencyCommand(info));
     context.AddCommand(new FixupCommand(info));
     context.AddCommand(new ExtractCommand(info));
     context.AddCommand(new ImportCommand(info));
     context.AddCommand(new InfoCommand(info));
     context.AddCommand(new InsertCommand(info));
     context.AddCommand(new ListCommand(info));
     context.AddCommand(new MapCommand());
     context.AddCommand(new EditCommand(stack, info));
     context.AddCommand(new DuplicateTagCommand(info));
     context.AddCommand(new AddressCommand());
     context.AddCommand(new ExtractBitmapsCommand(info));
     context.AddCommand(new ResourceDataCommand());
     context.AddCommand(new TagBlockCommand(info));
     if (info.StringIds != null)
     {
         context.AddCommand(new StringIdCommand(info));
         context.AddCommand(new ListStringsCommand(info));
         context.AddCommand(new GenerateLayoutsCommand(info));
         context.AddCommand(new ModelTestCommand(info));
     }
     return context;
 }

 public static CommandContext Create(CommandContextStack stack, OpenTagCache info)
 {
     var context = new CommandContext(null, info.CacheFile.Name);
     context.AddCommand(new HelpCommand(stack));
     context.AddCommand(new ClearCommand());
     context.AddCommand(new DumpLogCommand());
     context.AddCommand(new EchoCommand());
     context.AddCommand(new DependencyCommand(info));
     context.AddCommand(new ExtractCommand(info));
     context.AddCommand(new ImportCommand(info));
     context.AddCommand(new InfoCommand(info));
     context.AddCommand(new ListCommand(info));
     context.AddCommand(new MapCommand());
     context.AddCommand(new DuplicateTagCommand(info));
     context.AddCommand(new AddressCommand());
     context.AddCommand(new ResourceDataCommand());
     if (info.StringIds != null)
     {
         context.AddCommand(new EditCommand(stack, info));
         context.AddCommand(new ExtractBitmapsCommand(info));
         context.AddCommand(new ImportBitmapCommand(info));
         context.AddCommand(new CollisionGeometryTestCommand(info));
         context.AddCommand(new PhysicsModelTestCommand(info));
         context.AddCommand(new StringIdCommand(info));
         context.AddCommand(new ListStringsCommand(info));
         context.AddCommand(new GenerateLayoutsCommand(info));
         context.AddCommand(new ModelTestCommand(info));
         context.AddCommand(new ConvertPluginsCommand(info));
         context.AddCommand(new GenerateTagNamesCommand(info));
         context.AddCommand(new MatchTagsCommand(info));
         context.AddCommand(new ConvertCommand(info));
     }
     return context;
 }

        public static void Populate(CommandContext context, OpenTagCache info, TagInstance tag)
        {
            RenderMethod renderMethod = null;

            using (var cacheStream = info.OpenCacheReadWrite())
            {
                var tagContext = new TagSerializationContext(cacheStream, info.Cache, info.StringIds, tag);

                switch (tag.Group.Tag.ToString())
                {
                    case "rm  ": // render_method
                        renderMethod = info.Deserializer.Deserialize<RenderMethod>(tagContext);
                        break;

                    case "rmsh": // shader
                        renderMethod = info.Deserializer.Deserialize<Shader>(tagContext);
                        break;

                    case "rmd ": // shader_decal
                        renderMethod = info.Deserializer.Deserialize<ShaderDecal>(tagContext);
                        break;

                    case "rmfl": // shader_foliage
                        renderMethod = info.Deserializer.Deserialize<ShaderFoliage>(tagContext);
                        break;

                    case "rmhg": // shader_halogram
                        renderMethod = info.Deserializer.Deserialize<ShaderHalogram>(tagContext);
                        break;

                    case "rmss": // shader_screen
                        renderMethod = info.Deserializer.Deserialize<ShaderScreen>(tagContext);
                        break;

                    case "rmtr": // shader_terrain
                        renderMethod = info.Deserializer.Deserialize<ShaderTerrain>(tagContext);
                        break;

                    case "rmw ": // shader_water
                        renderMethod = info.Deserializer.Deserialize<ShaderWater>(tagContext);
                        break;

                    case "rmzo": // shader_zonly
                        renderMethod = info.Deserializer.Deserialize<ShaderZonly>(tagContext);
                        break;

                    case "rmcs": // shader_custom
                        renderMethod = info.Deserializer.Deserialize<ShaderCustom>(tagContext);
                        break;

                    default:
                        throw new NotImplementedException();
                }
            }
            
            context.AddCommand(new ListArgumentsCommand(info, tag, renderMethod));
            context.AddCommand(new ListBitmapsCommand(info, tag, renderMethod));
            context.AddCommand(new SpecifyBitmapsCommand(info, tag, renderMethod));
        }

        public static void Populate(CommandContext context, OpenTagCache info, TagInstance tag, MultilingualUnicodeStringList unic)
        {
            if (info.StringIds == null)
                return;

            context.AddCommand(new ListCommand(info, unic));
            context.AddCommand(new SetCommand(info, tag, unic));
        }

 public static CommandContext Create(CommandContext parent, OpenTagCache info, CacheBase blamCache)
 {
     var context = new CommandContext(parent, blamCache.Build);
     context.AddCommand(new PortShaderCommand(info, blamCache));
     context.AddCommand(new PortModelCommand(info, blamCache));
     context.AddCommand(new ListBitmapsCommand(info, blamCache));
     return context;
 }

 public static void Populate(CommandContext context, OpenTagCache info, TagInstance tag, VFilesList vfsl)
 {
     context.AddCommand(new ListCommand(vfsl));
     context.AddCommand(new ExtractCommand(vfsl));
     context.AddCommand(new ExtractAllCommand(vfsl));
     context.AddCommand(new ImportCommand(info, tag, vfsl));
     context.AddCommand(new ImportAllCommand(info, tag, vfsl));
 }

 public NullTagCommand(OpenTagCache info)
     : base(CommandFlags.None,
           "nulltag",
           "Nulls a tag in the current tag cache.",
           "nulltag <tag index>",
           "Nulls a tag in the current tag index. The tag's data will be removed from cache.")
 {
     Info = info;
 }

 public GenerateCacheCommand(OpenTagCache info)
     : base(CommandFlags.Inherit,
           "generatecache",
           "Generates an empty set of cache files.",
           "generatecache <output directory>",
           "Generates an empty set of cache files.")
 {
     Info = info;
 }

 public NewTagCommand(OpenTagCache info)
     : base(CommandFlags.Inherit,
           "newtag",
           "Creates a new tag of the specified tag group in the current tag cache.",
           "newtag <group tag>",
           "Creates a new tag of the specified tag group in the current tag cache.")
 {
     Info = info;
 }

 public ListUnreferencedTagsCommand(OpenTagCache info)
     : base(CommandFlags.None,
           "listunreferencedtags",
           "Lists all unreferenced tags in the current tag cache",
           "listunreferencedtags",
           "Lists all unreferenced tags in the current tag cache")
 {
     Info = info;
 }

 public ListNullTagsCommand(OpenTagCache info)
     : base(CommandFlags.None,
           "listnulltags",
           "Lists all null tag indices in the current tag cache",
           "listnulltags",
           "Lists all null tag indices in the current tag cache")
 {
     Info = info;
 }

 public GenerateTagNamesCommand(OpenTagCache info)
     : base(CommandFlags.Inherit,
           "gentagnames",
           "Generates tag names into a csv file (overwriting existing entries).",
           "gentagnames <csv file>",
           "Generates tag names into a csv file (overwriting existing entries).")
 {
     Info = info;
 }

 public SetVarCommand(OpenTagCache info)
     : base(CommandFlags.Inherit,
           "setvar",
           "Assigns a value to a variable.",
           "setvar <name> <value>",
           "Assigns a value to a tag tool global variable, which can be accessed via $name")
 {
     Info = info;
 }

 public ExtractCommand(OpenTagCache info)
     : base(CommandFlags.Inherit,
           "extract",
           "",
           "extract [all] <index|group> <path>",
           "")
 {
     Info = info;
 }

 public ExportTagsCommand(OpenTagCache info)
     : base(CommandFlags.None,
           "exporttags",
           "Exports all tags in the current tag cache to a specific directory.",
           "exporttags <output directory>",
           "Exports all tags in the current tag cache to a specific directory.")
 {
     Info = info;
 }

        public static CommandContext Create(CommandContext parent, OpenTagCache info, TagInstance tag, VFilesList vfsl)
        {
            var groupName = info.StringIds.GetString(tag.GroupName);

            var context = new CommandContext(parent,
                string.Format("{0:X8}.{1}", tag.Index, groupName));

            return context;
        }

 public ImportCommand(OpenTagCache info)
     : base(CommandFlags.None,
           "import",
           "",
           "import [all] <index> <path>",
           "")
 {
     Info = info;
 }

 public ListVariantsCommand(OpenTagCache info, Model model)
     : base(CommandFlags.Inherit,
     "listvariants",
     "List available variants of the current model definition.",
     "listvariants",
     "Lists available variants of the current model definition which can be used with \"extractmodel\".")
 {
     Info = info;
     Definition = model;
 }