using Bright.Time;
using CommandLine;
using Luban.Common.Protos;
using Luban.Common.Utils;
using Luban.Job.Cfg.Defs;
using Luban.Job.Cfg.Generate;
using Luban.Job.Cfg.RawDefs;
using Luban.Job.Cfg.Utils;
using Luban.Job.Common;
using Luban.Job.Common.Defs;
using Luban.Job.Common.Utils;
using Luban.Server.Common;
using System;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Text.Json;
using System.Threading.Tasks;
using FileInfo = Luban.Common.Protos.FileInfo;

namespace Luban.Job.Cfg
{
    [Controller("cfg")]
    public class JobController : IJobController
    {
        private static readonly NLog.Logger s_logger = NLog.LogManager.GetCurrentClassLogger();

        class GenArgs
        {
            [Option('d', "define_file", Required = true, HelpText = "define file")]
            public string DefineFile { get; set; }

            [Option("input_data_dir", Required = true, HelpText = "input data dir")]
            public string InputDataDir { get; set; }

            [Option('v', "validate_root_dir", Required = false, HelpText = "validate root directory")]
            public string ValidateRootDir { get; set; }

            [Option("output_code_dir", Required = false, HelpText = "output code directory")]
            public string OutputCodeDir { get; set; }

            [Option("output_data_dir", Required = true, HelpText = "output data directory")]
            public string OutputDataDir { get; set; }

            [Option("output_data_resource_list_file", Required = false, HelpText = "output resource list file")]
            public string OutputDataResourceListFile { get; set; }

            [Option("output_data_json_monolithic_file", Required = false, HelpText = "output monolithic json file")]
            public string OutputDataJsonMonolithicFile { get; set; }

            [Option("gen_types", Required = true, HelpText = "code_cs_bin,code_cs_json,code_lua_bin,data_bin,data_lua,data_json,data_json_monolithic . can be multi")]
            public string GenType { get; set; }

            [Option('s', "service", Required = true, HelpText = "service")]
            public string Service { get; set; }

            [Option("export_test_data", Required = false, HelpText = "export test data")]
            public bool ExportTestData { get; set; } = false;

            [Option('t', "l10n_timezone", Required = false, HelpText = "timezone")]
            public string TimeZone { get; set; }

            [Option("input_l10n_text_files", Required = false, HelpText = "input l10n text table files. can be multi, sep by ','")]
            public string InputTextTableFiles { get; set; }

            [Option("l10n_text_field_name", Required = false, HelpText = "text value field name of text table files. default is text")]
            public string TextValueFieldName { get; set; }

            [Option("output_l10n_not_converted_text_file", Required = false, HelpText = "the file save not converted l10n texts.")]
            public string OutputNotConvertTextFile { get; set; }

            [Option("branch", Required = false, HelpText = "branch name")]
            public string BranchName { get; set; }

            [Option("branch_input_data_dir", Required = false, HelpText = "branch input data root dir")]
            public string BranchInputDataDir { get; set; }
        }

        private ICodeRender CreateCodeRender(string genType)
        {
            switch (genType)
            {
                case "code_cs_bin": return new CsBinCodeRender();
                case "code_cs_json": return new CsJsonCodeRender();
                case "code_java_bin": return new JavaBinCodeRender();
                case "code_cpp_bin": return new CppBinCodeRender();
                default: throw new ArgumentException($"not support gen type:{genType}");
            }
        }

        private ELanguage GetLanguage(string genType)
        {
            switch (genType)
            {
                case "code_cs_bin":
                case "code_cs_json": return ELanguage.CS;
                case "code_java_bin": return ELanguage.JAVA;
                case "code_cpp_bin": return ELanguage.CPP;
                case "code_go_bin": return ELanguage.GO;
                case "code_lua_bin": return ELanguage.LUA;
                default: throw new ArgumentException($"not support output data type:{genType}");
            }
        }


        private static bool TryParseArg(List<string> args, out GenArgs options, out string errMsg)
        {
            var helpWriter = new StringWriter();
            var parser = new Parser(ps =>
            {
                ps.HelpWriter = helpWriter;
            }); ;
            var parseResult = parser.ParseArguments<GenArgs>(args);
            if (parseResult.Tag == ParserResultType.NotParsed)
            {
                errMsg = helpWriter.ToString();
                options = null;
                return false;
            }
            else
            {
                options = (parseResult as Parsed<GenArgs>).Value;
                errMsg = null;

                string inputDataDir = options.InputDataDir;
                string outputCodeDir = options.OutputCodeDir;
                string outputDataDir = options.OutputDataDir;

                var genTypes = options.GenType.Split(',').Select(s => s.Trim()).ToList();

                if (genTypes.Any(t => t.StartsWith("code_", StringComparison.Ordinal)) && string.IsNullOrWhiteSpace(outputCodeDir))
                {
                    errMsg = "--outputcodedir missing";
                    return false;
                }
                if (genTypes.Any(t => t.StartsWith("data_", StringComparison.Ordinal)))
                {
                    if (string.IsNullOrWhiteSpace(inputDataDir))
                    {
                        errMsg = "--inputdatadir missing";
                        return false;
                    }
                    if (string.IsNullOrWhiteSpace(outputDataDir))
                    {
                        errMsg = "--outputdatadir missing";
                        return false;
                    }
                    if (genTypes.Contains("data_resources") && string.IsNullOrWhiteSpace(options.OutputDataResourceListFile))
                    {
                        errMsg = "--output_data_resource_list_file missing";
                        return false;
                    }
                    if (genTypes.Contains("data_json_monolithic") && string.IsNullOrWhiteSpace(options.OutputDataJsonMonolithicFile))
                    {
                        errMsg = "--output_data_json_monolithic_file missing";
                        return false;
                    }

                    if (string.IsNullOrWhiteSpace(options.InputTextTableFiles) ^ string.IsNullOrWhiteSpace(options.OutputNotConvertTextFile))
                    {
                        errMsg = "--input_l10n_text_files must be provided with --output_l10n_not_converted_text_file";
                        return false;
                    }
                }

                if (string.IsNullOrWhiteSpace(options.BranchName) ^ string.IsNullOrWhiteSpace(options.BranchInputDataDir))
                {
                    errMsg = "--branch must be provided with --branch_input_data_dir";
                    return false;
                }

                return true;
            }
        }

        public async Task GenAsync(RemoteAgent agent, GenJob rpc)
        {
            var res = new GenJobRes()
            {
                ErrCode = Luban.Common.EErrorCode.OK,
                ErrMsg = "succ",
                FileGroups = new List<FileGroup>(),
            };

            if (!TryParseArg(rpc.Arg.JobArguments, out GenArgs args, out string errMsg))
            {
                res.ErrCode = Luban.Common.EErrorCode.JOB_ARGUMENT_ERROR;
                res.ErrMsg = errMsg;
                agent.Session.ReplyRpc<GenJob, GenJobArg, GenJobRes>(rpc, res);
                return;
            }

            var timer = new ProfileTimer();
            timer.StartPhase("= gen_all =");
            try
            {
                string inputDataDir = args.InputDataDir;
                string outputCodeDir = args.OutputCodeDir;
                string outputDataDir = args.OutputDataDir;

                var genTypes = args.GenType.Split(',').Select(s => s.Trim()).ToList();

                timer.StartPhase("build defines");
                var loader = new CfgDefLoader(agent);
                await loader.LoadAsync(args.DefineFile);
                timer.EndPhaseAndLog();

                var rawDefines = loader.BuildDefines();

                TimeZoneInfo timeZoneInfo = string.IsNullOrEmpty(args.TimeZone) ? null : TimeZoneInfo.FindSystemTimeZoneById(args.TimeZone);

                var ass = new DefAssembly(args.BranchName, timeZoneInfo, args.ExportTestData, agent);

                ass.Load(args.Service, rawDefines);

                var targetService = ass.CfgTargetService;


                List<DefTable> exportTables = ass.GetExportTables();
                List<DefTypeBase> exportTypes = ass.GetExportTypes();

                bool hasLoadCfgData = false;

                bool needL10NTextConvert = !string.IsNullOrWhiteSpace(args.InputTextTableFiles);

                async Task CheckLoadCfgDataAsync()
                {
                    if (!hasLoadCfgData)
                    {
                        hasLoadCfgData = true;
                        var timer = new ProfileTimer();
                        timer.StartPhase("load config data");
                        await DataLoaderUtil.LoadCfgDataAsync(agent, ass, args.InputDataDir, args.BranchName, args.BranchInputDataDir, args.ExportTestData);
                        timer.EndPhaseAndLog();

                        if (needL10NTextConvert)
                        {
                            ass.InitL10n(args.TextValueFieldName);
                            await DataLoaderUtil.LoadTextTablesAsync(agent, ass, ".", args.InputTextTableFiles);
                        }

                        timer.StartPhase("validate");
                        var validateCtx = new ValidatorContext(ass, args.ValidateRootDir);
                        await validateCtx.ValidateTables(exportTables);
                        timer.EndPhaseAndLog();
                    }
                }

                var tasks = new List<Task>();

                var genCodeFilesInOutputCodeDir = new ConcurrentBag<FileInfo>();
                var genDataFilesInOutputDataDir = new ConcurrentBag<FileInfo>();
                var genScatteredFiles = new ConcurrentBag<FileInfo>();

                foreach (var genType in genTypes)
                {
                    switch (genType)
                    {
                        case "code_cs_bin":
                        case "code_cs_json":
                        case "code_java_bin":
                        {
                            ICodeRender render = CreateCodeRender(genType);
                            ELanguage lan = GetLanguage(genType);

                            foreach (var c in exportTypes)
                            {
                                tasks.Add(Task.Run(() =>
                                {
                                    var content = FileHeaderUtil.ConcatAutoGenerationHeader(render.RenderAny(c), lan);
                                    var file = RenderFileUtil.GetDefTypePath(c.FullName, lan);
                                    var md5 = CacheFileUtil.GenMd5AndAddCache(file, content);
                                    genCodeFilesInOutputCodeDir.Add(new FileInfo() { FilePath = file, MD5 = md5 });
                                }));
                            }

                            tasks.Add(Task.Run(() =>
                            {
                                var module = ass.TopModule;
                                var name = targetService.Manager;
                                var content = FileHeaderUtil.ConcatAutoGenerationHeader(render.RenderService(name, module, exportTables), lan);
                                var file = RenderFileUtil.GetDefTypePath(name, lan);
                                var md5 = CacheFileUtil.GenMd5AndAddCache(file, content);
                                genCodeFilesInOutputCodeDir.Add(new FileInfo() { FilePath = file, MD5 = md5 });
                            }));

                            break;
                        }
                        case "code_lua_bin":
                        {
                            tasks.Add(Task.Run(() =>
                            {
                                var render = new LuaRender();
                                var content = FileHeaderUtil.ConcatAutoGenerationHeader(render.RenderAll(ass.Types.Values.ToList()), ELanguage.LUA);
                                var file = "Types.lua";
                                var md5 = CacheFileUtil.GenMd5AndAddCache(file, content);
                                genCodeFilesInOutputCodeDir.Add(new FileInfo() { FilePath = file, MD5 = md5 });
                            }));
                            break;
                        }
                        case "code_go_bin":
                        {
                            var render = new GoCodeRender();
                            foreach (var c in exportTypes)
                            {
                                tasks.Add(Task.Run(() =>
                                {
                                    var content = FileHeaderUtil.ConcatAutoGenerationHeader(render.RenderAny(c), ELanguage.GO);
                                    var file = RenderFileUtil.GetDefTypePath(c.FullName, ELanguage.GO);
                                    var md5 = CacheFileUtil.GenMd5AndAddCache(file, content);
                                    genCodeFilesInOutputCodeDir.Add(new FileInfo() { FilePath = file, MD5 = md5 });
                                }));
                            }

                            tasks.Add(Task.Run(() =>
                            {
                                var module = ass.TopModule;
                                var name = targetService.Manager;
                                var content = FileHeaderUtil.ConcatAutoGenerationHeader(render.RenderService(name, module, exportTables), ELanguage.GO);
                                var file = RenderFileUtil.GetDefTypePath(name, ELanguage.GO);
                                var md5 = CacheFileUtil.GenMd5AndAddCache(file, content);
                                genCodeFilesInOutputCodeDir.Add(new FileInfo() { FilePath = file, MD5 = md5 });
                            }));
                            break;
                        }
                        case "code_cpp_bin":
                        {
                            var render = new CppBinCodeRender();


                            // 将所有 头文件定义 生成到一个文件
                            // 按照 const,enum,bean,table, service 的顺序生成

                            tasks.Add(Task.Run(() =>
                            {
                                var headerFileContent = new List<string>
                                {
                                    @$"
#pragma once
#include <functional>

#include ""bright/serialization/ByteBuf.h""
#include ""bright/CfgBean.hpp""

using ByteBuf = bright::serialization::ByteBuf;

namespace {ass.TopModule}
{{

"
                                };

                                foreach (var type in exportTypes)
                                {
                                    if (type is DefEnum e)
                                    {
                                        headerFileContent.Add(render.Render(e));
                                    }
                                }

                                foreach (var type in exportTypes)
                                {
                                    if (type is DefConst c)
                                    {
                                        headerFileContent.Add(render.Render(c));
                                    }
                                }

                                foreach (var type in exportTypes)
                                {
                                    if (type is DefBean e)
                                    {
                                        headerFileContent.Add(render.RenderForwardDefine(e));
                                    }
                                }

                                foreach (var type in exportTypes)
                                {
                                    if (type is DefBean e)
                                    {
                                        headerFileContent.Add(render.Render(e));
                                    }
                                }

                                foreach (var type in exportTables)
                                {
                                    headerFileContent.Add(render.Render(type));
                                }

                                headerFileContent.Add(render.RenderService("Tables", ass.TopModule, exportTables));

                                headerFileContent.Add("}"); // end of topmodule

                                var content = FileHeaderUtil.ConcatAutoGenerationHeader(string.Join('\n', headerFileContent), ELanguage.CPP);
                                var file = "gen_types.h";
                                var md5 = CacheFileUtil.GenMd5AndAddCache(file, content);
                                genCodeFilesInOutputCodeDir.Add(new FileInfo() { FilePath = file, MD5 = md5 });
                            }));

                            var beanTypes = exportTypes.Where(c => c is DefBean).ToList();

                            int TYPE_PER_STUB_FILE = 100;

                            for (int i = 0, n = (beanTypes.Count + TYPE_PER_STUB_FILE - 1) / TYPE_PER_STUB_FILE; i < n; i++)
                            {
                                int index = i;
                                tasks.Add(Task.Run(() =>
                                {
                                    int startIndex = index * TYPE_PER_STUB_FILE;
                                    var content = FileHeaderUtil.ConcatAutoGenerationHeader(
                                        render.RenderStub(ass.TopModule, beanTypes.GetRange(startIndex, Math.Min(TYPE_PER_STUB_FILE, beanTypes.Count - startIndex))),
                                        ELanguage.CPP);
                                    var file = $"gen_stub_{index}.cpp";
                                    var md5 = CacheFileUtil.GenMd5AndAddCache(file, content);
                                    genCodeFilesInOutputCodeDir.Add(new FileInfo() { FilePath = file, MD5 = md5 });
                                }));
                            }
                            break;
                        }

                        case "code_typescript_json":
                        {
                            var render = new TypeScriptJsonCodeRender();
                            tasks.Add(Task.Run(() =>
                            {
                                var fileContent = new List<string>
                                {
                                    @$"
export namespace {ass.TopModule} {{
",

                                    @"
export class Vector2 {
        x: number
        y: number
        constructor(x: number, y: number) {
            this.x = x
            this.y = y
        }

        static from(_json_: any): Vector2 {
            let x = _json_['x']
            let y = _json_['y']
            if (x == null || y == null) {
                throw new Error()
            }
            return new Vector2(x, y)
        }
    }


    export class Vector3 {
        x: number
        y: number
        z: number
        constructor(x: number, y: number, z: number) {
            this.x = x
            this.y = y
            this.z = z
        }

        static from(_json_: any): Vector3 {
            let x = _json_['x']
            let y = _json_['y']
            let z = _json_['z']
            if (x == null || y == null || z == null) {
                throw new Error()
            }
            return new Vector3(x, y, z)
        }
    }

    export class Vector4 {
        x: number
        y: number
        z: number
        w: number
        constructor(x: number, y: number, z: number, w: number) {
            this.x = x
            this.y = y
            this.z = z
            this.w = w
        }

        static from(_json_: any): Vector4 {
            let x = _json_['x']
            let y = _json_['y']
            let z = _json_['z']
            let w = _json_['w']
            if (x == null || y == null || z == null || w == null) {
                throw new Error()
            }
            return new Vector4(x, y, z, w)
        }
    }

"
                                };

                                foreach (var type in exportTypes)
                                {
                                    if (type is DefEnum e)
                                    {
                                        fileContent.Add(render.Render(e));
                                    }
                                }

                                foreach (var type in exportTypes)
                                {
                                    if (type is DefConst c)
                                    {
                                        fileContent.Add(render.Render(c));
                                    }
                                }

                                foreach (var type in exportTypes)
                                {
                                    if (type is DefBean e)
                                    {
                                        fileContent.Add(render.Render(e));
                                    }
                                }

                                foreach (var type in exportTables)
                                {
                                    fileContent.Add(render.Render(type));
                                }

                                fileContent.Add(render.RenderService("Tables", ass.TopModule, exportTables));

                                fileContent.Add("}"); // end of topmodule

                                var content = FileHeaderUtil.ConcatAutoGenerationHeader(string.Join('\n', fileContent), ELanguage.TYPESCRIPT);
                                var file = "Types.ts";
                                var md5 = CacheFileUtil.GenMd5AndAddCache(file, content);
                                genCodeFilesInOutputCodeDir.Add(new FileInfo() { FilePath = file, MD5 = md5 });
                            }));
                            break;
                        }

                        case "code_typescript_bin":
                        {
                            var render = new TypeScriptBinCodeRender();
                            tasks.Add(Task.Run(() =>
                            {
                                var fileContent = new List<string>
                                {
                                    @$"
import {{Bright}} from 'csharp'

export namespace {ass.TopModule} {{
",

                                    @"
export class Vector2 {
        x: number
        y: number
        constructor(x: number, y: number) {
            this.x = x
            this.y = y
        }

        static from(_buf_: Bright.Serialization.ByteBuf): Vector2 {
            let x = _buf_.ReadFloat()
            let y = _buf_.ReadFloat()
            return new Vector2(x, y)
        }
    }


    export class Vector3 {
        x: number
        y: number
        z: number
        constructor(x: number, y: number, z: number) {
            this.x = x
            this.y = y
            this.z = z
        }

        static from(_buf_: Bright.Serialization.ByteBuf): Vector3 {
            let x = _buf_.ReadFloat()
            let y = _buf_.ReadFloat()
            let z = _buf_.ReadFloat()
            return new Vector3(x, y, z)
        }
    }

    export class Vector4 {
        x: number
        y: number
        z: number
        w: number
        constructor(x: number, y: number, z: number, w: number) {
            this.x = x
            this.y = y
            this.z = z
            this.w = w
        }

        static from(_buf_: Bright.Serialization.ByteBuf): Vector4 {
            let x = _buf_.ReadFloat()
            let y = _buf_.ReadFloat()
            let z = _buf_.ReadFloat()
            let w = _buf_.ReadFloat()
            return new Vector4(x, y, z, w)
        }
    }

"
                                };

                                foreach (var type in exportTypes)
                                {
                                    if (type is DefEnum e)
                                    {
                                        fileContent.Add(render.Render(e));
                                    }
                                }

                                foreach (var type in exportTypes)
                                {
                                    if (type is DefConst c)
                                    {
                                        fileContent.Add(render.Render(c));
                                    }
                                }

                                foreach (var type in exportTypes)
                                {
                                    if (type is DefBean e)
                                    {
                                        fileContent.Add(render.Render(e));
                                    }
                                }

                                foreach (var type in exportTables)
                                {
                                    fileContent.Add(render.Render(type));
                                }

                                fileContent.Add(render.RenderService("Tables", ass.TopModule, exportTables));

                                fileContent.Add("}"); // end of topmodule

                                var content = FileHeaderUtil.ConcatAutoGenerationHeader(string.Join('\n', fileContent), ELanguage.TYPESCRIPT);
                                var file = "Types.ts";
                                var md5 = CacheFileUtil.GenMd5AndAddCache(file, content);
                                genCodeFilesInOutputCodeDir.Add(new FileInfo() { FilePath = file, MD5 = md5 });
                            }));
                            break;
                        }

                        case "code_python27_json":
                        {
                            var render = new Python27JsonCodeRender();

                            tasks.Add(Task.Run(() =>
                            {
                                var fileContent = new List<string>
                                {
                                    @"
class Vector2:
    def __init__(self, x, y):
        self.x = x
        self.y = y
        self.a = Vector4(1,2,3,4)
    def __str__(self):
        return '{%g,%g}' % (self.x, self.y)

    @staticmethod
    def fromJson(_json_):
        x = _json_['x']
        y = _json_['y']
        if (x == None or y == None):
            raise Exception()
        return Vector2(x, y)


class Vector3:
    def __init__(self, x, y, z):
        self.x = x
        self.y = y
        self.z = z
    def __str__(self):
        return '{%f,%f,%f}' % (self.x, self.y, self.z)
    @staticmethod
    def fromJson(_json_):
        x = _json_['x']
        y = _json_['y']
        z = _json_['z']
        if (x == None or y == None or z == None):
            raise Exception()
        return Vector3(x, y, z)

class Vector4:
    def __init__(self, x, y, z, w):
        self.x = x
        self.y = y
        self.z = z
        self.w = w
    def __str__(self):
        return '{%g,%g,%g,%g}' % (self.x, self.y, self.z, self.w)
        
    @staticmethod
    def fromJson(_json_):
        x = _json_['x']
        y = _json_['y']
        z = _json_['z']
        w = _json_['w']
        if (x == None or y == None or z == None or w == None):
            raise Exception()
        return Vector4(x, y, z, w)

"
                                };

                                foreach (var type in exportTypes)
                                {
                                    if (type is DefEnum e)
                                    {
                                        fileContent.Add(render.Render(e));
                                    }
                                }

                                foreach (var type in exportTypes)
                                {
                                    if (type is DefConst c)
                                    {
                                        fileContent.Add(render.Render(c));
                                    }
                                }

                                foreach (var type in exportTypes)
                                {
                                    if (type is DefBean e)
                                    {
                                        fileContent.Add(render.Render(e));
                                    }
                                }

                                foreach (var type in exportTables)
                                {
                                    fileContent.Add(render.Render(type));
                                }

                                fileContent.Add(render.RenderService("Tables", ass.TopModule, exportTables));

                                var content = FileHeaderUtil.ConcatAutoGenerationHeader(string.Join('\n', fileContent), ELanguage.PYTHON);
                                var file = "Types.py";
                                var md5 = CacheFileUtil.GenMd5AndAddCache(file, content);
                                genCodeFilesInOutputCodeDir.Add(new FileInfo() { FilePath = file, MD5 = md5 });


                                {
                                    var moduleInitContent = "";
                                    var initFile = "__init__.py";

                                    var initMd5 = CacheFileUtil.GenMd5AndAddCache(initFile, moduleInitContent);
                                    genCodeFilesInOutputCodeDir.Add(new FileInfo() { FilePath = initFile, MD5 = initMd5 });
                                }
                            }));
                            break;
                        }

                        case "code_python3_json":
                        {
                            var render = new Python3JsonCodeRender();

                            tasks.Add(Task.Run(() =>
                            {
                                var fileContent = new List<string>
                                {
                                    @"
from enum import Enum
import abc

class Vector2:
        def __init__(self, x, y):
            self.x = x
            self.y = y
            self.a = Vector4(1,2,3,4)
        def __str__(self):
            return '{%g,%g}' % (self.x, self.y)

        @staticmethod
        def fromJson(_json_):
            x = _json_['x']
            y = _json_['y']
            if (x == None or y == None):
                raise Exception()
            return Vector2(x, y)


class Vector3:
    def __init__(self, x, y, z):
        self.x = x
        self.y = y
        self.z = z
    def __str__(self):
        return '{%f,%f,%f}' % (self.x, self.y, self.z)
    @staticmethod
    def fromJson(_json_):
        x = _json_['x']
        y = _json_['y']
        z = _json_['z']
        if (x == None or y == None or z == None):
            raise Exception()
        return Vector3(x, y, z)

class Vector4:
    def __init__(self, x, y, z, w):
        self.x = x
        self.y = y
        self.z = z
        self.w = w
    def __str__(self):
        return '{%g,%g,%g,%g}' % (self.x, self.y, self.z, self.w)
        
    @staticmethod
    def fromJson(_json_):
        x = _json_['x']
        y = _json_['y']
        z = _json_['z']
        w = _json_['w']
        if (x == None or y == None or z == None or w == None):
            raise Exception()
        return Vector4(x, y, z, w)

"
                                };

                                foreach (var type in exportTypes)
                                {
                                    if (type is DefEnum e)
                                    {
                                        fileContent.Add(render.Render(e));
                                    }
                                }

                                foreach (var type in exportTypes)
                                {
                                    if (type is DefConst c)
                                    {
                                        fileContent.Add(render.Render(c));
                                    }
                                }

                                foreach (var type in exportTypes)
                                {
                                    if (type is DefBean e)
                                    {
                                        fileContent.Add(render.Render(e));
                                    }
                                }

                                foreach (var type in exportTables)
                                {
                                    fileContent.Add(render.Render(type));
                                }

                                fileContent.Add(render.RenderService("Tables", ass.TopModule, exportTables));

                                var content = FileHeaderUtil.ConcatAutoGenerationHeader(string.Join('\n', fileContent), ELanguage.PYTHON);
                                var file = "Types.py";
                                var md5 = CacheFileUtil.GenMd5AndAddCache(file, content);
                                genCodeFilesInOutputCodeDir.Add(new FileInfo() { FilePath = file, MD5 = md5 });
                            }));
                            break;
                        }

                        case "code_cpp_ue_editor":
                        {
                            var render = new UE4EditorCppRender();

                            var renderTypes = ass.Types.Values.Where(c => c is DefEnum || c is DefBean).ToList();

                            foreach (var c in renderTypes)
                            {
                                tasks.Add(Task.Run(() =>
                                {
                                    var content = FileHeaderUtil.ConcatAutoGenerationHeader(render.RenderAny(c), ELanguage.CPP);
                                    var file = "editor_" + RenderFileUtil.GetUeCppDefTypeHeaderFilePath(c.FullName);
                                    var md5 = CacheFileUtil.GenMd5AndAddCache(file, content);
                                    genCodeFilesInOutputCodeDir.Add(new FileInfo() { FilePath = file, MD5 = md5 });
                                }));
                            }

                            int TYPE_PER_STUB_FILE = 200;

                            for (int i = 0, n = (renderTypes.Count + TYPE_PER_STUB_FILE - 1) / TYPE_PER_STUB_FILE; i < n; i++)
                            {
                                int index = i;
                                tasks.Add(Task.Run(() =>
                                {
                                    int startIndex = index * TYPE_PER_STUB_FILE;
                                    var content = FileHeaderUtil.ConcatAutoGenerationHeader(
                                        render.RenderStub(renderTypes.GetRange(startIndex, Math.Min(TYPE_PER_STUB_FILE, renderTypes.Count - startIndex))),
                                        ELanguage.CPP);
                                    var file = $"stub_{index}.cpp";
                                    var md5 = CacheFileUtil.GenMd5AndAddCache(file, content);
                                    genCodeFilesInOutputCodeDir.Add(new FileInfo() { FilePath = file, MD5 = md5 });
                                }));
                            }
                            break;
                        }
                        case "code_cs_unity_editor":
                        {
                            var render = new EditorCsRender();
                            foreach (var c in ass.Types.Values)
                            {
                                tasks.Add(Task.Run(() =>
                                {
                                    var content = FileHeaderUtil.ConcatAutoGenerationHeader(render.RenderAny(c), ELanguage.CS);
                                    var file = RenderFileUtil.GetDefTypePath(c.FullName, ELanguage.GO);
                                    var md5 = CacheFileUtil.GenMd5AndAddCache(file, content);
                                    genCodeFilesInOutputCodeDir.Add(new FileInfo() { FilePath = file, MD5 = md5 });
                                }));
                            }
                            break;
                        }
                        case "code_cpp_ue_bp":
                        {
                            var render = new UE4BpCppRender();
                            foreach (var c in exportTypes)
                            {
                                if (!(c is DefEnum || c is DefBean))
                                {
                                    continue;
                                }

                                tasks.Add(Task.Run(() =>
                                {
                                    var content = FileHeaderUtil.ConcatAutoGenerationHeader(render.RenderAny(c), ELanguage.CPP);
                                    var file = "bp_" + RenderFileUtil.GetUeCppDefTypeHeaderFilePath(c.FullName);
                                    var md5 = CacheFileUtil.GenMd5AndAddCache(file, content);
                                    genCodeFilesInOutputCodeDir.Add(new FileInfo() { FilePath = file, MD5 = md5 });
                                }));
                            }
                            break;
                        }
                        case "data_bin":
                        case "data_json":
                        {
                            await CheckLoadCfgDataAsync();
                            foreach (var c in exportTables)
                            {
                                tasks.Add(Task.Run(() =>
                                {
                                    var content = DataExporterUtil.ToOutputData(c, ass.GetTableExportDataList(c), genType);
                                    var file = genType.EndsWith("json") ? c.JsonOutputDataFile : c.OutputDataFile;
                                    var md5 = FileUtil.CalcMD5(content);
                                    CacheManager.Ins.AddCache(file, md5, content);
                                    genDataFilesInOutputDataDir.Add(new FileInfo() { FilePath = file, MD5 = md5 });
                                }));
                            }
                            break;
                        }
                        case "data_json_monolithic":
                        {
                            await CheckLoadCfgDataAsync();
                            List<Task<byte[]>> allJsonTask = new List<Task<byte[]>>();
                            foreach (var c in exportTables)
                            {
                                allJsonTask.Add(Task.Run(() =>
                                {
                                    return DataExporterUtil.ToOutputData(c, ass.GetTableExportDataList(c), "data_json");
                                }));
                            }
                            await Task.WhenAll(allJsonTask);

                            int estimatedCapacity = allJsonTask.Sum(t => t.Result.Length + 100);
                            var sb = new MemoryStream(estimatedCapacity);
                            sb.Write(System.Text.Encoding.UTF8.GetBytes("{\n"));
                            for (int i = 0; i < exportTables.Count; i++)
                            {
                                if (i != 0)
                                {
                                    sb.Write(System.Text.Encoding.UTF8.GetBytes((",\n")));
                                }
                                sb.Write(System.Text.Encoding.UTF8.GetBytes("\"" + exportTables[i].Name + "\":"));
                                sb.Write(allJsonTask[i].Result);
                            }
                            sb.Write(System.Text.Encoding.UTF8.GetBytes("\n}"));

                            var content = sb.ToArray();
                            s_logger.Debug("estimated size:{0} actual size:{1}", estimatedCapacity, content.Length);
                            var md5 = FileUtil.CalcMD5(content);
                            var outputFile = args.OutputDataJsonMonolithicFile;
                            CacheManager.Ins.AddCache(outputFile, md5, content);
                            genScatteredFiles.Add(new FileInfo() { FilePath = outputFile, MD5 = md5 });
                            break;
                        }
                        case "data_lua":
                        {
                            await CheckLoadCfgDataAsync();

                            tasks.Add(Task.Run(() =>
                            {
                                var render = new LuaRender();
                                var content = FileHeaderUtil.ConcatAutoGenerationHeader(render.RenderDefines(ass.Types.Values.ToList()), ELanguage.LUA);
                                var file = "Types.lua";
                                var md5 = CacheFileUtil.GenMd5AndAddCache(file, content);
                                genDataFilesInOutputDataDir.Add(new FileInfo() { FilePath = file, MD5 = md5 });

                            }));

                            foreach (var c in exportTables)
                            {
                                tasks.Add(Task.Run(() =>
                                {
                                    var content = DataExporterUtil.ToOutputData(c, ass.GetTableExportDataList(c), genType);
                                    var file = $"{c.Name}.lua";
                                    var md5 = FileUtil.CalcMD5(content);
                                    CacheManager.Ins.AddCache(file, md5, content);
                                    genDataFilesInOutputDataDir.Add(new FileInfo() { FilePath = file, MD5 = md5 });
                                }));
                            }
                            break;
                        }
                        case "data_resources":
                        {
                            await CheckLoadCfgDataAsync();
                            var genDataTasks = new List<Task<List<ResourceInfo>>>();
                            foreach (var c in exportTables)
                            {
                                genDataTasks.Add(Task.Run(() =>
                                {
                                    return DataExporterUtil.ExportResourceList(ass.GetTableExportDataList(c));
                                }));
                            }

                            tasks.Add(Task.Run(async () =>
                            {
                                var ress = new HashSet<(string, string)>(10000);
                                var resourceLines = new List<string>(10000);
                                foreach (var task in genDataTasks)
                                {
                                    foreach (var ri in await task)
                                    {
                                        if (ress.Add((ri.Resource, ri.Tag)))
                                        {
                                            resourceLines.Add($"{ri.Resource},{ri.Tag}");
                                        }
                                    }
                                }
                                var file = args.OutputDataResourceListFile;
                                var contents = System.Text.Encoding.UTF8.GetBytes(string.Join("\n", resourceLines));
                                var md5 = FileUtil.CalcMD5(contents);
                                CacheManager.Ins.AddCache(file, md5, contents);

                                genScatteredFiles.Add(new FileInfo() { FilePath = file, MD5 = md5 });
                            }));
                            break;
                        }

                        default:
                        {
                            s_logger.Error("unknown gentype:{gentype}", genType);
                            break;
                        }
                    }
                }
                await Task.WhenAll(tasks.ToArray());

                if (needL10NTextConvert)
                {
                    var notConvertTextList = DataExporterUtil.GenNotConvertTextList(ass.NotConvertTextSet);
                    var md5 = FileUtil.CalcMD5(notConvertTextList);
                    string outputNotConvertTextFile = args.OutputNotConvertTextFile;
                    CacheManager.Ins.AddCache(outputNotConvertTextFile, md5, notConvertTextList);

                    genScatteredFiles.Add(new FileInfo() { FilePath = outputNotConvertTextFile, MD5 = md5 });
                }

                if (!genCodeFilesInOutputCodeDir.IsEmpty)
                {
                    res.FileGroups.Add(new FileGroup() { Dir = outputCodeDir, Files = genCodeFilesInOutputCodeDir.ToList() });
                }
                if (!genDataFilesInOutputDataDir.IsEmpty)
                {
                    res.FileGroups.Add(new FileGroup() { Dir = outputDataDir, Files = genDataFilesInOutputDataDir.ToList() });
                }
                if (!genScatteredFiles.IsEmpty)
                {
                    res.ScatteredFiles.AddRange(genScatteredFiles);
                }
            }
            catch (Exception e)
            {
                res.ErrCode = Luban.Common.EErrorCode.JOB_EXCEPTION;
                res.ErrMsg = $"{e.Message} \n {e.StackTrace}";
            }
            timer.EndPhaseAndLog();

            agent.Session.ReplyRpc<GenJob, GenJobArg, GenJobRes>(rpc, res);
        }
    }
}