Pf2eDataScrapper/Pf2eDataScrapper/Importers/Implementations/Pf2eFoundry/Compendium/CompendiumSchemaBuilder.cs

using Konsole;
using Newtonsoft.Json.Linq;
using Pf2eDataScrapper.SchemaBuilder;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace Pf2eDataScrapper.Importers.Implementations.Pf2eFoundry.Compendium
{
    internal class CompendiumSchemaBuilder(CompendiumLoader loader)
    {
        public CompendiumLoader Loader = loader;

        public CompendiumFolderCollection Collection = loader.Collection;

        public CompendiumSchemaTypeResolver Resolver = new();

        public Dictionary<CompendiumFolder, SchemaNode> PackSchemas = [];

        public Dictionary<string, SchemaNode> TypeSchemas = [];

        
        protected List<SchemaNode> GetItemSchemas(CompendiumFolder folder, string? itemType)
        {
            if (!PackSchemas.ContainsKey(folder))
            {
                PackSchemas[folder] = new SchemaNode()
                {
                    Resolver = Resolver,
                    Path = folder.Name
                };
            }

            var key = folder.Type.ToString() + (itemType is not null ? $".{itemType}" : "");

            if (!TypeSchemas.ContainsKey(key))
            {
                TypeSchemas[key] = new SchemaNode()
                {
                    Resolver = Resolver,
                    Path = key
                };
            }

            return [PackSchemas[folder], TypeSchemas[key]];
        }

        public void BuildSchemas()
        {
            Console.WriteLine("Building schemas...");

            var bar = new ProgressBar(Loader.ItemCount);
            var i = 0;

            foreach (var folder in Collection.FindAll(f => f.Path is not null))
            {
                var dirPath = Path.Combine(Loader.Importer.Dir, folder.Path!);
                
                foreach (var filePath in Directory.GetFiles(dirPath, "*.json", SearchOption.AllDirectories))
                {
                    bar.Refresh(i++, folder.Name);

                    var file = new FileInfo(filePath);
                
                    if (file.Name == "_folders.json")
                    {
                        continue;
                    }
                
                    using var reader = new StreamReader(file.FullName);
                    var itemJson = JObject.Parse(reader.ReadToEnd());

                    var itemFolder = folder;
                    if (itemJson.TryGetValue("folder", out var itemJsonFolder))
                    {
                        itemFolder = Collection.GetById(itemJsonFolder.ToString());
                    }

                    var schemas = GetItemSchemas(itemFolder ?? folder, itemJson["type"]?.ToString());

                    foreach (var schema in schemas)
                    {
                        schema.AddValue(itemJson);
                    }
                }
            }

            bar.Refresh(Loader.ItemCount, "Done!");
        }

        public void Save(string targetDir)
        {
            Console.WriteLine("Dumping schemas...");

            var bar = new ProgressBar(PackSchemas.Count + TypeSchemas.Count);
            var i = 0;

            targetDir = Path.Combine(targetDir, "pf2e");

            if (!Directory.Exists(targetDir))
            {
                Directory.CreateDirectory(targetDir);
            }
            Array.ForEach(Directory.GetFiles(@targetDir), File.Delete);

            // Packs
            var packsDir = Path.Combine(targetDir, "packs");
            Directory.CreateDirectory(packsDir);

            foreach (var pair in PackSchemas)
            {
                bar.Refresh(i++, pair.Key.Name);
                SaveSchema(packsDir, pair.Key.Name, pair.Value);
            }

            // Types
            var typesDir = Path.Combine(targetDir, "types");
            Directory.CreateDirectory(typesDir);
            foreach (var pair in TypeSchemas)
            {
                bar.Refresh(i++, pair.Key);
                SaveSchema(typesDir, pair.Key, pair.Value);
            }

            Console.WriteLine("Done!");
        }

        protected void SaveSchema(string dir, string name, SchemaNode schema)
        {
            var invalids = System.IO.Path.GetInvalidFileNameChars();
            var fileName = string.Join("_", schema.Path.Split(invalids, StringSplitOptions.RemoveEmptyEntries)).TrimEnd('.');

            var path = Path.Combine(dir, fileName + ".txt");


            var dirPath = Path.GetDirectoryName(path);

            if (!Directory.Exists(dirPath))
            {
                Directory.CreateDirectory(dirPath);
            }

            using var writer = new StreamWriter(path);

            schema.Beautify();

            writer.WriteLine(name);
            writer.WriteLine($"Different values: {schema.Values}");
            writer.WriteLine("=====================================");
            writer.Write(schema.ToString());
        }
    }
}