AssetRipper_AssetRipper/Source/AssetRipper.IO.Files/FileContainer.cs

using AssetRipper.IO.Files.ResourceFiles;
using AssetRipper.IO.Files.SerializedFiles;

namespace AssetRipper.IO.Files;

public abstract class FileContainer : FileBase
{
	public IEnumerable<SerializedFile> FetchSerializedFiles()
	{
		foreach (SerializedFile file in SerializedFiles)
		{
			yield return file;
		}
		foreach (FileContainer list in FileLists)
		{
			foreach (SerializedFile file in list.FetchSerializedFiles())
			{
				yield return file;
			}
		}
	}

	public void AddFile(FileBase file)
	{
		switch (file)
		{
			case SerializedFile serializedFile:
				AddSerializedFile(serializedFile);
				return;
			case ResourceFile resourceFile:
				AddResourceFile(resourceFile);
				return;
			case FileContainer fileList:
				AddFileContainer(fileList);
				return;
			case FailedFile failedFile:
				AddFailedFile(failedFile);
				return;
			default:
				throw new NotSupportedException(file.GetType().ToString());
		}
	}

	public void AddSerializedFile(SerializedFile file)
	{
		if (m_serializedFiles is null)
		{
			m_serializedFiles = [file];
		}
		else
		{
			m_serializedFiles.Add(file);
		}
		OnSerializedFileAdded(file);
	}

	public void AddFileContainer(FileContainer container)
	{
		if (m_fileLists is null)
		{
			m_fileLists = [container];
		}
		else
		{
			m_fileLists.Add(container);
		}
		OnFileContainerAdded(container);
	}

	public void AddResourceFile(ResourceFile resource)
	{
		if (m_resourceFiles is null)
		{
			m_resourceFiles = [resource];
		}
		else
		{
			m_resourceFiles.Add(resource);
		}
		OnResourceFileAdded(resource);
	}

	public void AddFailedFile(FailedFile file)
	{
		if (m_failedFiles is null)
		{
			m_failedFiles = [file];
		}
		else
		{
			m_failedFiles.Add(file);
		}
	}

	protected virtual void OnSerializedFileAdded(SerializedFile file) { }

	protected virtual void OnFileContainerAdded(FileContainer container) { }

	protected virtual void OnResourceFileAdded(ResourceFile resource) { }

	public override void ReadContents()
	{
		if (m_resourceFiles is { Count: > 0 })
		{
			ResourceFile[] resourceFiles = m_resourceFiles.ToArray();
			m_resourceFiles.Clear();
			for (int i = 0; i < resourceFiles.Length; i++)
			{
				AddFile(SchemeReader.ReadFile(resourceFiles[i]));
			}
		}
	}

	public override void ReadContentsRecursively()
	{
		ReadContents();
		foreach (FileContainer container in FileLists)
		{
			container.ReadContentsRecursively();
		}
	}

	public IReadOnlyList<SerializedFile> SerializedFiles => m_serializedFiles ?? [];
	public IReadOnlyList<FileContainer> FileLists => m_fileLists ?? [];
	public IReadOnlyList<ResourceFile> ResourceFiles => m_resourceFiles ?? [];
	public IReadOnlyList<FailedFile> FailedFiles => m_failedFiles ?? [];

	public IEnumerable<FileBase> AllFiles
	{
		get
		{
			foreach (ResourceFile resource in ResourceFiles)
			{
				yield return resource;
			}
			foreach (SerializedFile file in SerializedFiles)
			{
				yield return file;
			}
			foreach (FileContainer container in FileLists)
			{
				yield return container;
			}
			foreach (FailedFile file in FailedFiles)
			{
				yield return file;
			}
		}
	}

	private List<SerializedFile>? m_serializedFiles;
	private List<FileContainer>? m_fileLists;
	private List<ResourceFile>? m_resourceFiles;
	private List<FailedFile>? m_failedFiles;
}