package main

import (
	"bytes"
	"encoding/json"
	"flag"
	"fmt"
	"github.com/oylshe1314/framework/errors"
	"github.com/oylshe1314/framework/log"
	"github.com/oylshe1314/framework/util"
	"github.com/xuri/excelize/v2"
	"os"
	"path"
	"path/filepath"
	"reflect"
	"sort"
	"strconv"
	"strings"
	"time"
)

type codeField struct {
	sort uint32
	name string
	tags string
	desc string

	sourceType string
	golangType string
	csharpType string
	formatName string
}

var goTypeMap = map[string]string{
	"bool":       "bool",
	"bool[]":     "[]bool",
	"int":        "int",
	"int[]":      "[]int",
	"long":       "int64",
	"long[]":     "[]int64",
	"float":      "float64",
	"float[]":    "[]float64",
	"double":     "float64",
	"double[]":   "[]float64",
	"string":     "string",
	"string[]":   "[]string",
	"date":       "int64",
	"date[]":     "[]int64",
	"time":       "int64",
	"time[]":     "[]int64",
	"datetime":   "int64",
	"datetime[]": "[]int64",
	"Vector3":    "[3]float64",
	"Vector3[]":  "[][3]float64",
}

var csTypeMap = map[string]string{
	"bool":       "bool",
	"bool[]":     "bool[]",
	"int":        "int",
	"int[]":      "int[]",
	"long":       "long",
	"long[]":     "long[]",
	"float":      "float",
	"float[]":    "float[]",
	"double":     "double",
	"double[]":   "double[]",
	"string":     "string",
	"string[]":   "string[]",
	"date":       "long",
	"date[]":     "long[]",
	"time":       "long",
	"time[]":     "long[]",
	"datetime":   "long",
	"datetime[]": "long[]",
	"Vector3":    "Vector3",
	"Vector3[]":  "Vector3[]",
}

type exportResult struct {
	codeFields  map[string]*codeField
	jsonObjects []map[string]interface{}
}

func printUsage() {
	var cmdLine = flag.CommandLine
	var order = []string{"in", "out", "tag", "go", "cs", "clear", "format"}

	fmt.Printf("Usage of %s:\n", os.Args[0])
	for _, s := range order {
		var f = cmdLine.Lookup(s)
		if f != nil {
			name, usage := flag.UnquoteUsage(f)
			if len(name) > 0 {
				fmt.Printf("    -%s %s\n", f.Name, name)
				fmt.Printf("        %s\n\n", usage)
			} else {
				fmt.Printf("    -%s %s\n\n", f.Name, usage)
			}
		}
	}
}

func main() {

	var clrJson, fmtJson bool
	var inDir, outDir, jsonTag, goDir, csDir string

	flag.StringVar(&inDir, "in", "", "Specify the input directory of configuration files")
	flag.StringVar(&outDir, "out", "", "Specify the output directory for the exported json files")
	flag.StringVar(&jsonTag, "tag", "", "Specify the tag 'server' or 'client' for the exported json files")
	flag.StringVar(&goDir, "go", "", "Specify an output directory if it's going to generate go code files")
	flag.StringVar(&csDir, "cs", "", "Specify an output directory if it's going to generate csharp code files")
	flag.BoolVar(&clrJson, "clear", false, "Specify if clear the output directory")
	flag.BoolVar(&fmtJson, "format", false, "Specify if format the output json files")

	flag.Usage = printUsage
	flag.Parse()

	if inDir == "" || outDir == "" || (jsonTag != "" && jsonTag != "server" && jsonTag != "client") {
		flag.Usage()
		return
	}

	des, err := os.ReadDir(outDir)
	if err != nil {
		log.DefaultLogger.Error(err)
		return
	}

	if clrJson {
		log.DefaultLogger.Info("Clearing the output directory...")
		for _, de := range des {
			if de.IsDir() {
				continue
			}

			if !strings.HasSuffix(de.Name(), ".json") {
				continue
			}

			err = os.Remove(path.Join(outDir, de.Name()))
			if err != nil {
				log.DefaultLogger.Error(err)
				return
			}
		}
	}

	dirs, err := os.ReadDir(inDir)
	if err != nil {
		log.DefaultLogger.Error(err)
		return
	}

	log.DefaultLogger.Info("Reading all configuration tables...")

	var b = time.Now().Unix()
	var tables []string
	var tableFiles = make(map[string][]string)
	for _, dir := range dirs {
		files, err := readFiles(inDir, dir)
		if err != nil {
			log.DefaultLogger.Error(err)
			return
		}

		tables = append(tables, dir.Name())
		tableFiles[dir.Name()] = files
	}

	//readTables(inDir)

	var goTables []string
	var csTables []string
	for _, table := range tables {
		files := tableFiles[table]
		if files == nil {
			continue
		}

		table = util.UpperCamelCase(table)
		log.DefaultLogger.Infof("Exporting %s...", table)
		if len(files) == 0 {
			log.DefaultLogger.Warn("Empty file list")
			continue
		}

		result, err := exportFiles(inDir, files)
		if err != nil {
			log.DefaultLogger.Errorf("Export failed, %v", err)
			continue
		}

		if len(result.jsonObjects) == 0 {
			log.DefaultLogger.Warn("Empty object list")
			continue
		}

		err = writeJsonFile(table, outDir, jsonTag, fmtJson, result)
		if err != nil {
			log.DefaultLogger.Errorf("Write %s.json, %v", table, err)
			continue
		}

		if goDir != "" {
			err = writeGoTable(table, goDir, result)
			if err == nil {
				goTables = append(goTables, table)
				log.DefaultLogger.Infof("Done")
			} else {
				log.DefaultLogger.Errorf("Write %s.go failed, %v", table, err)
			}
		}

		if csDir != "" {
			log.DefaultLogger.Infof("Writing %s.cs...", table)
			err = writeCsTable(table, csDir, result)
			if err == nil {
				csTables = append(csTables, table)
				log.DefaultLogger.Infof("Done")
			} else {
				log.DefaultLogger.Errorf("Write %s.cs failed, %v", table, err)
			}
		}
	}

	if goDir != "" {
		log.DefaultLogger.Info("Generating go tables")
		err = writeGoTables(goTables, goDir)
		if err == nil {
			log.DefaultLogger.Infof("Done")
		} else {
			log.DefaultLogger.Errorf("Generate tables.go failed, %v", err)
		}
	}

	if csDir != "" {
		log.DefaultLogger.Info("Generating c-sharp tables")
		err = writeCsTables(csTables, csDir)
		if err == nil {
			log.DefaultLogger.Infof("Done")
		} else {
			log.DefaultLogger.Errorf("Generate Tables.cs failed, %v", err)
		}
	}

	var e = time.Now().Unix()
	log.DefaultLogger.Infof("All configuration tables export finished, times: %ds", e-b)
}

func filterFields(jsonTag string, doSort bool, result *exportResult) (fields []*codeField) {
	if jsonTag == "" {
		fields = util.MapValues(result.codeFields)
	} else {
		for _, field := range result.codeFields {
			if strings.Contains(field.tags, jsonTag) {
				fields = append(fields, field)
			}
		}
	}

	if doSort {
		sort.Slice(fields, func(i, j int) bool {
			return fields[i].sort < fields[j].sort
		})
	}
	return
}

// toStructSlice 这个函数用于把一个map slice(既是JSON Object Array)转为一个动态struct pointer slice
// 因为map的key顺序不是固定的，JSON序列化时也无法排序，导致每次输出的JSON文件会有变化，版本控制提交更新时容易冲突
// 但是JSON序列化结构体的字段时是有序的，所以把JSON对象map转成了一个动态的结构体再序列化(!!!绝对是馊主意)
// 或者自己写个函数序列化JSON字符串.
func toStructSlice(jsonTag string, result *exportResult) (any, error) {
	var fields = filterFields(jsonTag, true, result)
	if len(fields) == 0 {
		return nil, nil
	}

	var sfs []reflect.StructField
	for _, field := range fields {
		var tipe reflect.Type
		switch field.golangType {
		case "bool":
			tipe = reflect.TypeOf(true)
		case "[]bool":
			tipe = reflect.TypeOf([]bool{})
		case "int":
			tipe = reflect.TypeOf(int(0))
		case "[]int":
			tipe = reflect.TypeOf([]int{})
		case "int64":
			tipe = reflect.TypeOf(int64(0))
		case "[]int64":
			tipe = reflect.TypeOf([]int64{})
		case "float64":
			tipe = reflect.TypeOf(float64(0))
		case "[]float64":
			tipe = reflect.TypeOf([]float64{})
		case "string":
			tipe = reflect.TypeOf("")
		case "[]string":
			tipe = reflect.TypeOf([]string{})
		case "[3]float64":
			tipe = reflect.TypeOf([3]float64{})
		case "[][3]float64":
			tipe = reflect.TypeOf([][3]float64{})
		}
		sfs = append(sfs, reflect.StructField{Name: field.formatName, Type: tipe, Tag: reflect.StructTag(fmt.Sprintf(`json:"%s,omitempty"`, field.name))})
	}

	var spt = reflect.PointerTo(reflect.StructOf(sfs))
	var spsv = reflect.MakeSlice(reflect.SliceOf(spt), len(result.jsonObjects), len(result.jsonObjects))

	for si, jsonObject := range result.jsonObjects {
		var spv, err = util.NewReflectValueFromJson(jsonObject, spt)
		if err != nil {
			return nil, err
		}
		spsv.Index(si).Set(spv)
	}
	return spsv.Interface(), nil
}

// toJsonString 写的直接序列化JSON字符串的函数
func toJsonString(jsonTag string, result *exportResult) ([]byte, error) {
	var fields = filterFields(jsonTag, true, result)
	if len(fields) == 0 {
		return nil, nil
	}

	var buf bytes.Buffer

	buf.WriteString("[")
	for oi, jo := range result.jsonObjects {
		if oi > 0 {
			buf.WriteString(",")
		}

		buf.WriteString("{")
		for fi, field := range fields {
			var jv = jo[field.name]
			if jv != nil {
				if fi > 0 {
					buf.WriteString(",")
				}
				buf.WriteString("\"")
				buf.WriteString(field.name)
				buf.WriteString("\":")
				vs, err := json.Marshal(jv)
				if err != nil {
					return nil, err
				}

				buf.WriteString(string(vs))
			}
		}
		buf.WriteString("}")
	}
	buf.WriteString("]\n")

	return buf.Bytes(), nil
}

func writeJsonFile(table, outDir, jsonTag string, fmtJson bool, result *exportResult) error {

	//---------------------- one --------------------------
	//var newObjs []map[string]interface{}
	//if jsonTag == "" {
	//	newObjs = result.jsonObjects
	//} else {
	//	var fields = filterFields(jsonTag, true, result)
	//	if len(fields) == 0 {
	//		return nil
	//	}
	//
	//	for _, jsonObj := range result.jsonObjects {
	//		var newObj = map[string]interface{}{}
	//		for _, field := range fields {
	//			var v, ok = jsonObj[field.name]
	//			if ok {
	//				newObj[field.name] = v
	//			}
	//		}
	//		if len(newObj) > 0 {
	//			newObjs = append(newObjs, newObj)
	//		}
	//	}
	//}
	//
	//var jsonFile = filepath.Join(outDir, table+".json")
	//log.DefaultLogger.Infof("Writing %s...", jsonFile)
	//
	//file, err := os.OpenFile(jsonFile, os.O_WRONLY|os.O_TRUNC|os.O_CREATE, 0666)
	//if err != nil {
	//	return err
	//}
	//
	//defer file.Close()
	//
	//var encoder = json.NewEncoder(file)
	//if fmtJson {
	//	encoder.SetIndent("", "    ")
	//}
	//
	//return encoder.Encode(newObjs)
	//-----------------------------------------------------

	//---------------------- two --------------------------
	//sps, err := toStructSlice(jsonTag, result)
	//if err != nil {
	//	return err
	//}
	//
	//if sps == nil {
	//	return nil
	//}
	//
	//var jsonFile = filepath.Join(outDir, table+".json")
	//log.DefaultLogger.Infof("Writing %s...", jsonFile)
	//
	//file, err := os.OpenFile(jsonFile, os.O_WRONLY|os.O_TRUNC|os.O_CREATE, 0666)
	//if err != nil {
	//	return err
	//}
	//
	//defer file.Close()
	//
	//var encoder = json.NewEncoder(file)
	//if fmtJson {
	//	encoder.SetIndent("", "    ")
	//}
	//
	//return encoder.Encode(sps)
	//-----------------------------------------------------

	//---------------------- thr --------------------------
	js, err := toJsonString(jsonTag, result)
	if err != nil {
		return err
	}

	if js == nil {
		return nil
	}

	if fmtJson {
		var buf bytes.Buffer
		err = json.Indent(&buf, js, "", "    ")
		if err != nil {
			return err
		}

		js = buf.Bytes()
	}

	var jsonFile = filepath.Join(outDir, table+".json")
	log.DefaultLogger.Infof("Writing %s...", jsonFile)

	file, err := os.OpenFile(jsonFile, os.O_WRONLY|os.O_TRUNC|os.O_CREATE, 0666)
	if err != nil {
		return err
	}

	defer file.Close()

	_, err = file.Write(js)
	if err != nil {
		return err
	}

	return nil
	//-----------------------------------------------------
}

func writeGoTables(tables []string, goDir string) error {
	var tablesFile = filepath.Join(goDir, "tables.go")

	log.DefaultLogger.Infof("Writing %s...", tablesFile)
	var buf bytes.Buffer

	var maxTableNameLength = 0
	for _, table := range tables {
		if len(table) > maxTableNameLength {
			maxTableNameLength = len(table)
		}
	}

	var fmtStr = fmt.Sprintf("\t%%-%ds %%sTable\n", maxTableNameLength)

	buf.WriteString("package data\n")
	buf.WriteRune('\n')
	buf.WriteString("type tables struct {\n")
	for _, table := range tables {
		buf.WriteString(fmt.Sprintf(fmtStr, table, table))
	}
	buf.WriteString("}\n")

	return os.WriteFile(tablesFile, buf.Bytes(), 0666)
}

func writeGoTable(table, goDir string, result *exportResult) error {
	var goFile = filepath.Join(goDir, util.LowerSnakeCase(table)+".go")
	log.DefaultLogger.Infof("Writing %s...", goFile)

	var buf bytes.Buffer

	var structName = table

	var idFieldName = "id"
	var idField *codeField
	var maxNameLength = 0
	var maxTypeLength = 0
	var maxSrcNameLength = 0
	var serverFields []*codeField
	for _, field := range result.codeFields {
		if !strings.Contains(field.tags, "server") {
			continue
		}

		if len(field.formatName) > maxNameLength {
			maxNameLength = len(field.formatName)
		}
		if len(field.golangType) > maxTypeLength {
			maxTypeLength = len(field.golangType)
		}
		if len(field.name) > maxSrcNameLength {
			maxSrcNameLength = len(field.name)
		}
		if field.name == idFieldName {
			idField = field
			switch idField.golangType {
			case "int":
			case "int64":
			case "string":
			default:
				return errors.Error("the type of id field just can be int, long, float, double, or string")
			}
		}

		serverFields = append(serverFields, field)
	}

	if len(serverFields) == 0 {
		return errors.Error("the table does not have any fields for server")
	}

	if idField == nil {
		return errors.Error("the table should have an id field")
	}

	sort.Slice(serverFields, func(i, j int) bool {
		return serverFields[i].sort < serverFields[j].sort
	})

	var fmtStr = fmt.Sprintf("\t%%-%ds %%-%ds `json:\"%%s\"`", maxNameLength, maxTypeLength)

	buf.WriteString("package data\n")
	buf.WriteRune('\n')
	buf.WriteString(fmt.Sprintf("type %s struct {\n", structName))
	for _, field := range serverFields {
		buf.WriteString(fmt.Sprintf(fmtStr, field.formatName, field.golangType, field.name))
		var spaces = maxSrcNameLength - len(field.name) + 1
		for i := 0; i < spaces; i++ {
			buf.WriteByte(' ')
		}
		buf.WriteString(fmt.Sprintf("//%s\n", field.desc))
	}
	buf.WriteString("}\n")
	buf.WriteRune('\n')

	buf.WriteString(fmt.Sprintf("func (data *%s) id() %s {\n", structName, idField.golangType))
	buf.WriteString(fmt.Sprintf("\treturn data.%s\n", idField.formatName))
	buf.WriteString("}\n")
	buf.WriteRune('\n')

	buf.WriteString(fmt.Sprintf("type %sTable struct {\n", structName))
	buf.WriteString(fmt.Sprintf("\ttable[%s, *%s]\n", idField.golangType, structName))
	buf.WriteString("}\n")

	return os.WriteFile(goFile, buf.Bytes(), 0666)
}

func writeCsTables(tables []string, csDir string) error {
	var tablesFile = filepath.Join(csDir, "Tables.cs")
	log.DefaultLogger.Infof("Writing %s...", tablesFile)

	var buf bytes.Buffer

	buf.WriteString("namespace DataTables\n")
	buf.WriteString("{\n")
	buf.WriteString("\tpublic static class Tables\n")
	buf.WriteString("\t{\n")
	for _, table := range tables {
		buf.WriteString(fmt.Sprintf("\t\tpublic static %sTable %s\n", table, table))
		buf.WriteString("\t\t{\n")
		buf.WriteString("\t\t\tprivate set { }\n")
		buf.WriteString("\t\t\tget\n")
		buf.WriteString("\t\t\t{\n")
		buf.WriteString(fmt.Sprintf("\t\t\t\tif (%s == null)\n", table))
		buf.WriteString("\t\t\t\t{\n")
		buf.WriteString(fmt.Sprintf("\t\t\t\t\t%s = new %sTable();\n", table, table))
		buf.WriteString("\t\t\t\t}\n")
		buf.WriteString(fmt.Sprintf("\t\t\t\treturn %s;\n", table))
		buf.WriteString("\t\t\t}\n")
		buf.WriteString("\t\t}\n")
		buf.WriteString("\n")
	}
	buf.WriteString("\t}\n")
	buf.WriteString("}\n")

	return os.WriteFile(tablesFile, buf.Bytes(), 0666)
}

func writeCsTable(table, csDir string, result *exportResult) error {

	var structName = table
	var filename = util.UpperCamelCase(table) + ".cs"

	var idFieldName = "id"
	var idField *codeField
	var clientFields []*codeField
	for _, field := range result.codeFields {
		if !strings.Contains(field.tags, "client") {
			continue
		}

		if field.name == idFieldName {
			idField = field
			switch idField.csharpType {
			case "int":
			case "long":
			case "string":
			default:
				return errors.Error("the field type of id should be int, float32, float64, or string")
			}
		}

		clientFields = append(clientFields, field)
	}

	if len(clientFields) == 0 {
		return errors.Error("the table does not have a field for client")
	}

	if idField == nil {
		return errors.Error("the table should have an id field")
	}

	sort.Slice(clientFields, func(i, j int) bool {
		return clientFields[i].sort < clientFields[j].sort
	})

	var buf bytes.Buffer

	buf.WriteString("using UnityEngine;\n")
	buf.WriteString("using System.Collections.Generic;\n")
	buf.WriteRune('\n')
	buf.WriteString("namespace DataTables\n")
	buf.WriteString("{\n")
	buf.WriteString(fmt.Sprintf("\tpublic class %s\n", structName))
	buf.WriteString("\t{\n")
	for i, field := range clientFields {
		if i > 0 {
			buf.WriteRune('\n')
		}
		buf.WriteString("\t\t/// <summary>\n")
		buf.WriteString(fmt.Sprintf("\t\t/// %s\n", field.desc))
		buf.WriteString("\t\t/// </summary>\n")
		buf.WriteString(fmt.Sprintf("\t\tpublic %s %s;\n", field.csharpType, field.formatName))
	}
	buf.WriteString("\t}\n")
	buf.WriteRune('\n')
	buf.WriteString(fmt.Sprintf("\tpublic class %sTable : Table<%s, %s>\n", structName, idField.csharpType, structName))
	buf.WriteString("\t{\n")
	//buf.WriteString(fmt.Sprintf("\t\tinternal static %sTable Instance = new %sTable();\n", structName, structName))
	buf.WriteString(fmt.Sprintf("\t\tinternal %sTable()\n", structName))
	buf.WriteString("\t\t{\n")
	buf.WriteString(fmt.Sprintf("\t\t\tL = new List<%s>()\n", structName))
	buf.WriteString("\t\t\t{\n")
	for _, jsonObject := range result.jsonObjects {
		var idValue = jsonObject[idField.name]
		if idValue == nil {
			return errors.Error("the table does not have an id value")
		}
		buf.WriteString(fmt.Sprintf("\t\t\t\tnew %s()\n", structName))
		buf.WriteString("\t\t\t\t{\n")
		for _, field := range clientFields {
			var fieldValue = jsonObject[field.name]
			if isDefaultValue(fieldValue) {
				continue
			}
			switch field.csharpType {
			case "bool":
				buf.WriteString(fmt.Sprintf("\t\t\t\t\t%s = %v,\n", field.formatName, fieldValue.(bool)))
			case "bool[]":
				var ary = fieldValue.([]interface{})
				if len(ary) > 0 {
					buf.WriteString(fmt.Sprintf("\t\t\t\t\t%s = new bool[]{", field.formatName))
					for _, v := range ary {
						buf.WriteString(fmt.Sprintf("%v, ", v.(bool)))
					}
					buf.WriteString("},\n")
				}
			case "int":
				buf.WriteString(fmt.Sprintf("\t\t\t\t\t%s = %v,\n", field.formatName, fieldValue.(int)))
			case "int[]":
				var ary = fieldValue.([]interface{})
				if len(ary) > 0 {
					buf.WriteString(fmt.Sprintf("\t\t\t\t\t%s = new int[]{", field.formatName))
					for _, v := range ary {
						buf.WriteString(fmt.Sprintf("%v, ", v.(int)))
					}
					buf.WriteString("},\n")
				}
			case "float":
				buf.WriteString(fmt.Sprintf("\t\t\t\t\t%s = %vf,\n", field.formatName, fieldValue.(float64)))
			case "float[]":
				var ary = fieldValue.([]interface{})
				if len(ary) > 0 {
					buf.WriteString(fmt.Sprintf("\t\t\t\t\t%s = new float[]{", field.formatName))
					for _, v := range ary {
						buf.WriteString(fmt.Sprintf("%vf, ", v.(float64)))
					}
					buf.WriteString("},\n")
				}
			case "double":
				buf.WriteString(fmt.Sprintf("\t\t\t\t\t%s = %v,\n", field.formatName, fieldValue.(float64)))
			case "double[]":
				var ary = fieldValue.([]interface{})
				if len(ary) > 0 {
					buf.WriteString(fmt.Sprintf("\t\t\t\t\t%s = new double[]{", field.formatName))
					for _, v := range ary {
						buf.WriteString(fmt.Sprintf("%v, ", v.(float64)))
					}
					buf.WriteString("},\n")
				}
			case "string":
				buf.WriteString(fmt.Sprintf("\t\t\t\t\t%s = \"%v\",\n", field.formatName, fieldValue.(string)))
			case "string[]":
				var ary = fieldValue.([]interface{})
				if len(ary) > 0 {
					buf.WriteString(fmt.Sprintf("\t\t\t\t\t%s = new string[]{", field.formatName))
					for _, v := range ary {
						buf.WriteString(fmt.Sprintf("\"%v\", ", v.(string)))
					}
					buf.WriteString("},\n")
				}
			case "Vector3":
				var vv = fieldValue.([]interface{})
				switch len(vv) {
				case 2:
					buf.WriteString(fmt.Sprintf("\t\t\t\t\t%s = new Vector3(%vf, %vf, 0f),\n", field.formatName, vv[0].(float64), vv[1].(float64)))
				case 3:
					buf.WriteString(fmt.Sprintf("\t\t\t\t\t%s = new Vector3(%vf, %vf, %vf),\n", field.formatName, vv[0].(float64), vv[1].(float64), vv[2].(float64)))
				default:
					return errors.Errorf("the value of field '%s' invalid for Vector3, id: %v", field.name, idValue)
				}
			case "Vector3[]":
				var ary = fieldValue.([]interface{})
				if len(ary) > 0 {
					buf.WriteString(fmt.Sprintf("\t\t\t\t\t%s = new Vector3[]{", field.formatName))
					for _, av := range ary {
						if av == nil {
							continue
						}
						var vv = av.([]interface{})
						if len(vv) > 0 {
							switch len(vv) {
							case 2:
								buf.WriteString(fmt.Sprintf("new Vector3(%vf, %vf, 0f), ", vv[0].(float64), vv[1].(float64)))
							case 3:
								buf.WriteString(fmt.Sprintf("new Vector3(%vf, %vf, %vf), ", vv[0].(float64), vv[1].(float64), vv[2].(float64)))
							default:
								return errors.Errorf("the value of field '%s' invalid for Vector3, id: %v", field.name, idValue)
							}
						}
					}
					buf.WriteString("},\n")
				}
			}
		}
		buf.WriteString("\t\t\t\t},\n")
	}
	buf.WriteString("\t\t\t};\n")
	buf.WriteString(fmt.Sprintf("\t\t\tM = new Dictionary<int, %s>();\n", structName))
	buf.WriteString("\t\t\tforeach (var d in L)\n")
	buf.WriteString("\t\t\t{\n")
	buf.WriteString(fmt.Sprintf("\t\t\t\tM[d.%s] = d;\n", idField.formatName))
	buf.WriteString("\t\t\t}\n")
	buf.WriteString("\t\t}\n")
	buf.WriteString("\t}\n")
	buf.WriteString("}\n")

	return os.WriteFile(filepath.Join(csDir, filename), buf.Bytes(), 0666)
}

func readFiles(inDir string, dir os.DirEntry) ([]string, error) {
	var files []string

	var dirPath = filepath.Join(inDir, dir.Name())

	dirs, err := os.ReadDir(dirPath)
	if err != nil {
		return nil, err
	}

	for _, sub := range dirs {
		if sub.IsDir() {
			subFiles, err := readFiles(dirPath, sub)
			if err != nil {
				return nil, err
			}

			files = append(files, subFiles...)
		} else {
			if path.Ext(sub.Name()) != ".xlsx" {
				continue
			}
			if sub.Name()[0] == '.' || sub.Name()[0] == '~' {
				continue
			}
			files = append(files, filepath.Join(dir.Name(), sub.Name()))
		}
	}

	return files, nil
}

func exportFiles(inDir string, files []string) (*exportResult, error) {
	var result exportResult

	for _, file := range files {
		var filename = filepath.Join(inDir, file)
		log.DefaultLogger.Infof("Reading %s...", filename)
		f, err := excelize.OpenFile(filename)
		if err != nil {
			return nil, err
		}

		if f.SheetCount == 0 {
			return nil, errors.Errorf("empty document %s", filename)
		}

		for i := 0; i < f.SheetCount; i++ {
			var sheetName = f.GetSheetName(i)
			if strings.Contains(sheetName, "help") {
				continue
			}
			err = readSheet(f, sheetName, &result)
			if err != nil {
				return nil, err
			}
		}

		_ = f.Close()
	}
	return &result, nil
}

func checkHeadStruct(types, fields, tags []string, codeObjects map[string]*codeField) error {
	for i, field := range fields {
		if !strings.Contains(tags[i], "server") && !strings.Contains(tags[i], "client") {
			continue
		}

		ff, ok := codeObjects[strings.TrimSpace(field)]
		if !ok {
			return errors.Errorf("inconsistent structures of multiple sheets for the same configuration table, unexpected field '%s'", field)
		}

		if strings.TrimSpace(types[i]) != ff.sourceType {
			return errors.Errorf("inconsistent type of the field '%s' in multiple sheets", field)
		}

		if tags[i] != ff.tags {
			return errors.Errorf("inconsistent tags of the field '%s' in multiple sheets", field)
		}
	}
	return nil
}

func getColumn(ci int) string {
	var col, _ = excelize.ColumnNumberToName(ci + 1)
	return col
}

func readSheet(excelFile *excelize.File, sheetName string, result *exportResult) error {
	rows, err := excelFile.GetRows(sheetName)
	if err != nil {
		return err
	}

	if len(rows) == 0 {
		return nil
	}

	if len(rows) < 4 {
		return errors.Errorf("sheet '%s' format error, the rows are less 4", sheetName)
	}

	var descs = rows[0]
	var types = rows[1]
	var fields = rows[2]
	var tags = rows[3]

	if len(types) != len(fields) && len(tags) != len(fields) {
		return errors.Errorf("sheet '%s' format error, inconsistent length of types, fields, and tags", sheetName)
	}

	if result.codeFields != nil {
		err = checkHeadStruct(types, fields, tags, result.codeFields)
		if err != nil {
			return errors.Errorf("sheet '%s' format error, %v", sheetName, err)
		}
	}

	rows = rows[4:]
	for ri, row := range rows {
		var object = make(map[string]interface{})
		for fi, field := range fields {
			if !strings.Contains(tags[fi], "server") && !strings.Contains(tags[fi], "client") {
				continue
			}

			var fieldName = strings.TrimSpace(field)
			var fieldType = strings.TrimSpace(types[fi])

			if fieldName == "" || fieldType == "" {
				continue
			}

			var srcType = strings.TrimSpace(fieldType)
			goType, ok := goTypeMap[srcType]
			if !ok {
				return errors.Errorf("sheet '%s' row %d column %s can not found go type", sheetName, ri+5, getColumn(fi))
			}

			csType, ok := csTypeMap[srcType]
			if !ok {
				return errors.Errorf("sheet '%s' row %d column %s can not found cs type", sheetName, ri+5, getColumn(fi))
			}

			var rowVal = ""
			if fi < len(row) {
				rowVal = row[fi]
			}

			value, err := readValue(rowVal, srcType)
			if err != nil {
				return errors.Errorf("sheet '%s' row %d column %s read value failed, %v", sheetName, ri+5, getColumn(fi), err)
			}

			if !isDefaultValue(value) {
				object[fieldName] = value
			}

			if result.codeFields == nil {
				result.codeFields = map[string]*codeField{}
			}

			if result.codeFields[fieldName] == nil {
				result.codeFields[fieldName] = &codeField{
					sort:       uint32(fi),
					name:       fieldName,
					tags:       tags[fi],
					desc:       descs[fi],
					sourceType: fieldType,
					golangType: goType,
					csharpType: csType,
					formatName: util.UpperCamelCase(fieldName),
				}
			}
		}
		if len(object) > 0 {
			result.jsonObjects = append(result.jsonObjects, object)
		}
	}
	return nil
}

func readValue(value, valType string) (interface{}, error) {
	return parseValue(value, valType)
}

func isDefaultValue(value interface{}) bool {
	switch v := value.(type) {
	case bool:
		return !v
	case int, int64, float32, float64:
		return v == 0
	case string:
	default:
		return value == nil
	}
	return false
}

func parseValue(value, valType string) (interface{}, error) {
	switch valType {
	case "bool":
		return boolParser(value)
	case "bool[]":
		return splitValue(value, ",", boolParser)
	case "int":
		return intParser(value)
	case "int[]":
		return splitValue(value, ",", intParser)
	case "float":
		return doubleParser(value)
	case "float[]":
		return splitValue(value, ",", doubleParser)
	case "double":
		return doubleParser(value)
	case "double[]":
		return splitValue(value, ",", doubleParser)
	case "string":
		return stringParser(value)
	case "string[]":
		return splitValue(value, ",", stringParser)
	case "date":
		return dateParser(value)
	case "date[]":
		return splitValue(value, ",", dateParser)
	case "time":
		return timeParser(value)
	case "time[]":
		return splitValue(value, ",", timeParser)
	case "datetime":
		return datetimeParser(value)
	case "datetime[]":
		return splitValue(value, ",", datetimeParser)
	case "Vector3":
		return vector3Parser(value)
	case "Vector3[]":
		return splitValue(value, "|", vector3Parser)
	default:
		return stringParser(value)
	}
}

func splitValue(value, sep string, parser func(string) (interface{}, error)) (interface{}, error) {
	if value == "" {
		return nil, nil
	}

	var values []interface{}
	var items = strings.Split(value, sep)
	for _, item := range items {
		parsed, err := parser(item)
		if err != nil {
			return nil, err
		}
		if parsed != nil {
			values = append(values, parsed)
		}
	}
	if len(values) == 0 {
		return nil, nil
	}
	return values, nil
}

func boolParser(item string) (interface{}, error) {
	item = strings.TrimSpace(item)
	if item == "" {
		return false, nil
	}
	return strconv.ParseBool(item)
}
func intParser(item string) (interface{}, error) {
	item = strings.TrimLeft(strings.TrimSpace(item), "0")
	if item == "" {
		return 0, nil
	}
	return strconv.Atoi(item)
}

func doubleParser(item string) (interface{}, error) {
	item = strings.TrimLeft(strings.TrimSpace(item), "0")
	if item == "" {
		return float64(0), nil
	}
	if item[0] == '.' {
		if len(item) == 1 {
			return float64(0), nil
		} else {
			item = "0" + item
		}
	}
	return strconv.ParseFloat(item, 64)
}

func stringParser(item string) (interface{}, error) {
	return strings.TrimSpace(item), nil
}

func dateParser(item string) (interface{}, error) {
	if item == "" {
		return int64(0), nil
	}

	t, err := time.ParseInLocation(time.DateOnly, item, util.UTC8())
	if err != nil {
		return nil, err
	}

	return t.Unix(), nil
}

func timeParser(item string) (interface{}, error) {
	if item == "" {
		return int64(0), nil
	}

	t, err := time.ParseInLocation(time.TimeOnly, item, util.UTC8())
	if err != nil {
		return nil, err
	}

	return int64(3600*t.Hour() + 60*t.Minute()*t.Second()), nil
}

func datetimeParser(item string) (interface{}, error) {
	if item == "" {
		return int64(0), nil
	}

	t, err := time.ParseInLocation(time.DateTime, item, util.UTC8())
	if err != nil {
		return nil, err
	}

	return t.Unix(), nil
}

func vector3Parser(item string) (interface{}, error) {
	if item == "" {
		return nil, nil
	}

	vectorValue, err := splitValue(item, ",", doubleParser)
	if err != nil {
		return nil, err
	}

	var ary = vectorValue.([]interface{})
	for i := len(ary); i < 3; i++ {
		ary = append(ary, 0)
	}

	return vectorValue, nil
}