using Fluid;
using System.Text;

namespace refl
{
    internal class Gen
    {
        public static Dictionary<string, StringBuilder> FileList = new Dictionary<string, StringBuilder>();
        public static StringBuilder Output = new StringBuilder();

        private GenMeta meta = new GenMeta();
        private GenMultyMeta multyMeta = new GenMultyMeta();
        public Gen() { }

        public static bool InitTemplate(string dir)
        {
            string meta_file = Path.Combine(dir, "meta.liquid");
            string multy_meta_file = Path.Combine(dir, "meta.liquid");
            var parser = new FluidParser();
            return GenMeta.InitTemplate(meta_file, parser) && GenMultyMeta.InitTemplate(multy_meta_file, parser);
        }
        public void CheckDir(string? dir)
        {
            if (dir != null && !Directory.Exists(dir))
            {
                Directory.CreateDirectory(dir);
            }
        }
        public void InitFile(string file_name)
        {
            Output.AppendLine("#pragma once");
            foreach (var name in ModuleMeta.NameSet)
            {
                var build = new StringBuilder();
                build.AppendLine("#pragma once");
                FileList.Add(name, build);
                if (name == "Meta")
                {
                    string path = $"Meta_{file_name}".ToLower();
                    Output.AppendLine($"#include \"{path}\"");
                }
            }
        }
        public void GenCppMeta(ModuleMeta module, string target)
        {
            string file_name = Path.GetFileName(target);
            string? dir = Path.GetDirectoryName(target);
            CheckDir(dir);
            InitFile(file_name);
            GenModuleMeta(module, null);
            OutFile(file_name, dir, target);
        }
        public void OutFile(string file_name, string? dir,string target)
        {
            foreach (var pair in FileList)
            {
                string path = $"{pair.Key}_{file_name}".ToLower();
                if (dir != null)
                {
                    path = Path.Combine(dir, path);
                }
                File.WriteAllText(path, pair.Value.ToString());
            }
            File.WriteAllText(target, Output.ToString());
        }
        public void GenModuleMeta(ModuleMeta module, string? prefix)
        {
            if (!module.HasMeta())
            {
                return;
            }
            var data = new ClassMetaData(prefix + "", module.NameSpace);
            if (prefix != null)
            {
                GenNamespaceBegin(data.Indent, data.NameSpace);
            }
            foreach (var cls in module.ClassList)
            {
                GenClassMeta(cls, data);
            }
            string new_prefix = prefix == null ? "" : "\t";
            foreach (var child in module.ChildList)
            {
                GenModuleMeta(child, new_prefix);
            }
            if (prefix != null)
            {
                GenNamespaceEnd(data.Indent);
            }
        }
        public void GenClassMeta(ClassMeta cls, ClassMetaData data)
        {
            meta.GenClassMeta(cls, data);
            if (cls.Fields.Count > 0)
            {
                multyMeta.GenClassMeta(cls, data);
            }
        }
        public static void GenNamespaceBegin(string indent, string name_space)
        {
            foreach (var name in ModuleMeta.NameSet)
            {
                string line = $"{indent}namespace {name_space} {{";
                FileList[name].AppendLine(line);
            }
        }
        public static void GenNamespaceEnd(string indent)
        {
            foreach (var name in ModuleMeta.NameSet)
            {
                FileList[name].AppendLine($"{indent}}}");
            }
        }
        public static void Append(string name, string res)
        {
            FileList[name].Append(res);
        }
    }
}