package main

import (
	"encoding/csv"
	"fmt"
	"github.com/axgle/mahonia"
	"io"
	"io/ioutil"
	"log"
	"os"
	"path"
	"pro2d/csvdata"
	"reflect"
	"strconv"
	"strings"
	"unicode"
)

/**
 * 将excel中的前四列转化为struct
 * 第一列字段类型		如 int
 * 第二列字段名称		如 显示顺序
 * 第三列字段名		如 id
 * 第四列s,c,all 	s表示服务端使用 c表示客户端使用 all表示都使用
 */

var (
	lineNumber           = 4                                     // 每个工作表至少需要读取的行数
	structBegin          = "type %s struct {\n"                  // 结构体开始
	structValue          = "    %s %s	`json:\"%s\" client:\"%s\"`" // 结构体的内容
	structValueForServer = "    %s %s	`json:\"%s\"`"              // 服务端使用的结构体内容
	structRemarks        = "	 // %s"                             // 结构体备注
	structValueEnd       = "\n"                                  // 结构体内容结束
	structEnd            = "}\n"                                 // 结构体结束
	header               = "package %s\n\r"                      // 文件头

	initpkg				="package csvdata\n\nimport \"sync\"\n\nvar CsvStruct map[string]interface{}\nvar CsvData *sync.Map\n\nfunc init()  {\n\tCsvStruct = make(map[string]interface{})\n\tCsvData = new(sync.Map)\n\n\t%s\n}\n\nfunc GetCsv(key string) interface{}{\n\tif data, ok := CsvData.Load(key); ok {\n\t\treturn data\n\t}\n\treturn nil\n}\nfunc SetCsv(key, value interface{}) {\n\tCsvData.Store(key, value)\n}"
	initline 			= "CsvStruct[\"%s\"] = %s{}\n"
)

type Generate struct {
	savePath string // 生成文件的保存路径
	data     string // 生成文件的内容
	allType  string // 文件当中的数据类型
}

func NewGenerate(savePath, allType string) *Generate {
	return &Generate{
		savePath: savePath,
		allType:  allType,
	}
}

// GBK 转 UTF-8
func GbkToUtf8(s string) string {
	decoder := mahonia.NewDecoder("GBK")
	return decoder.ConvertString(s)
}

// UTF-8 转 GBK
func Utf8ToGbk(s string) string {
	decoder := mahonia.NewDecoder("UTF-8")
	return decoder.ConvertString(s)
}

func GetGoTByCustomerT(t string) string {
	switch t {
	case "IntSlice":
		return "[]int"
	case "StringSlice":
		return "[]string"
	case "FloatSlice":
		return "[]float32"
	default:
		return t
	}
}

func CustomerTypeToGo(allType string) map[string]bool {
	s := strings.Split(allType, ",")
	mt := make(map[string]bool)
	for _, t := range s {
		mt[GetGoTByCustomerT(t)] = true
	}
	return mt
}

//csv to struct
func (g *Generate) CsvToStruct(csvpath, filename string) error {
	csvfile, err := os.Open(csvpath+filename)
	if err != nil {
		return fmt.Errorf("ReadExcel|xlsx.OpenFile is err :%v", err)
	}
	defer csvfile.Close()

	r := csv.NewReader(csvfile)
	i := 0
	sheetData := make([][]string, 0)
	for {
		if i >= lineNumber {
			break
		}
		record, err := r.Read()
		if err == io.EOF {
			break
		}
		if err != nil {
			log.Fatal(err)
		}
		i++
		sheetData = append(sheetData, record)
	}
	name := strings.Replace(filename, ".csv", "", -1)
	data, err := g.SplicingData(sheetData, name)
	if err != nil {
		return fmt.Errorf("fileName:\"%v\" is err:%v", name, err)
	}

	if data == "" {
		return fmt.Errorf("ReadExcel|this.data is nil")
	}
	err = g.WriteNewFile(name, data)
	if err != nil {
		return err
	}

	return nil
}

//csv to mem
func (g *Generate)CsvToMem(csvpath, filename string) error {
	csvfile, err := os.Open(csvpath+filename)
	if err != nil {
		return fmt.Errorf("ReadExcel|xlsx.OpenFile is err :%v", err)
	}
	defer csvfile.Close()

	r := csv.NewReader(csvfile)
	i := 0
	sheetData := make([][]string, 0)
	name := strings.Replace(filename, ".csv", "", -1)
	for {
		record, err := r.Read()
		if err == io.EOF {
			break
		}
		if err != nil {
			log.Fatal(err)
		}

		if i < lineNumber {
			sheetData = append(sheetData, record)
		}else {
			//4行之后
			fields := sheetData[1]
			typs := sheetData[2] //int, string
			keys := sheetData[3] //all, key, key1, key2

			t := reflect.ValueOf(csvdata.CsvStruct[name]).Type()
			v := reflect.New(t).Elem()
			for idx, field := range fields {
				if field == "" || record[idx] == "" {
					continue
				}

				f :=  v.FieldByName(firstRuneToUpper(field))
				switch typs[idx] {
				case "int":
					id, err := strconv.Atoi(record[idx])
					if err != nil {
						return err
					}
					f.SetInt(int64(id))
				case "string":
					f.SetString(record[idx])
				}

				switch keys[idx] {
				case "all":
				case "key":
				case "key1":

				case "key2":
				default:
				}

				//fmt.Printf("%d, %s: %v, %v\n", idx,  firstRuneToUpper(field), v.Field(idx), v.Interface())
			}
			//csvdata.SetCsv(name, datam)
		}
		i++
	}
	return nil
}

//拼装struct
func (g *Generate) SplicingData(data [][]string, structName string) (string, error) {
	if len(data) != lineNumber {
		return "", fmt.Errorf("SplicingData|sheetName:%v col's len:%d is err", data, len(data))
	}
	marks := data[0]
	fields := data[1]
	typs := data[2]
	keys := data[3]
	structData := fmt.Sprintf(structBegin, firstRuneToUpper(structName))

	for i, field := range fields {
		err := g.CheckType(typs[i], structName)
		if err != nil {
			return "", err
		}
		switch keys[i] {
		case "key","all":
			structData += fmt.Sprintf(structValue, firstRuneToUpper(field), GetGoTByCustomerT(typs[i]), strings.ToLower(field), strings.ToLower(field))
			if field != "" {
				structData += fmt.Sprintf(structRemarks, GbkToUtf8(marks[i]))
			}
			structData += fmt.Sprintf(structValueEnd)
		case "s":
			structData += fmt.Sprintf(structValueForServer, firstRuneToUpper(field), GetGoTByCustomerT(typs[i]), strings.ToLower(field))
			if field != "" {
				structData += fmt.Sprintf(structRemarks,GbkToUtf8(marks[i]))
			}
			structData += fmt.Sprintf(structValueEnd)
		case "c":
			continue
		default:
			return "", fmt.Errorf("SplicingData|keys[%d]:\"%v\" is not in s,c,all", i, keys[i])
		}
	}
	structData += structEnd
	return structData, nil
}

// 拼装好的struct写入新的文件
func (g *Generate) WriteNewFile(filename, data string) error {
	str := strings.Split(g.savePath, "/")
	if len(str) == 0 {
		return fmt.Errorf("WriteNewFile|len(str) is 0")
	}

	header = fmt.Sprintf(header, str[len(str)-1])
	data = header + data

	fw, err := os.OpenFile(g.savePath +"/" +filename+".go", os.O_RDWR|os.O_CREATE|os.O_TRUNC, 0644)
	if err != nil {
		return fmt.Errorf("WriteNewFile|OpenFile is err:%v", err)
	}
	defer fw.Close()

	_, err = fw.Write([]byte(data))
	if err != nil {
		return fmt.Errorf("WriteNewFile|Write is err:%v", err)
	}

	return nil
}

// 拼装好的初始化写入init.go文件
func (g *Generate) WriteInitPkg(data string) error {
	str := strings.Split(g.savePath, "/")
	if len(str) == 0 {
		return fmt.Errorf("WriteNewFile|len(str) is 0")
	}

	fw, err := os.OpenFile(g.savePath +"/init.go", os.O_RDWR|os.O_CREATE|os.O_TRUNC, 0644)
	if err != nil {
		return fmt.Errorf("WriteNewFile|OpenFile is err:%v", err)
	}
	defer fw.Close()

	_, err = fw.Write([]byte(fmt.Sprintf(initpkg, data)))
	if err != nil {
		return fmt.Errorf("WriteNewFile|Write is err:%v", err)
	}

	return nil
}

// 检测解析出来的字段类型是否符合要求
func (g *Generate) CheckType(dataType, structName string) error {
	res := strings.Index(g.allType, dataType)
	if res == -1 {
		return fmt.Errorf("CheckType|struct:\"%v\" dataType:\"%v\" is not in provide dataType", structName, dataType)
	}
	return nil
}

// 字符串首字母转换成大写
func firstRuneToUpper(str string) string {
	data := []byte(str)
	for k, v := range data {
		if k == 0 {
			first := []byte(strings.ToUpper(string(v)))
			newData := data[1:]
			data = append(first, newData...)
			break
		}
	}
	return string(data[:])
}

// 判断是否存在汉字或者是否为默认的工作表
func hasChineseOrDefault(r string) bool {
	if strings.Index(r, "Sheet") != -1 {
		return true
	}
	for _, v := range []rune(r) {
		if unicode.Is(unicode.Han, v) {
			return true
		}
	}
	return false
}

// 读取Csv 转化为 struct
func (g *Generate) ReadCsvToStruct(readPath string) error {
	files, err := ioutil.ReadDir(readPath)
	if err != nil {
		return fmt.Errorf("ReadExcel|ReadDir is err:%v", err)
	}


	data := ""
	for _, file := range files {
		if path.Ext(file.Name()) != ".csv" || hasChineseOrDefault(file.Name()) {
			continue
		}
		err := g.CsvToStruct(readPath, file.Name())
		if err != nil {
			return err
		}

		name := strings.Replace(file.Name(), ".csv", "", -1)
		data += fmt.Sprintf(initline, name, firstRuneToUpper(name))
	}
	g.WriteInitPkg(data)
	return nil
}

// 读取Csv 转化为 memory数据
func (g *Generate) ReadCsvToMemory(readPath string) error {
	files, err := ioutil.ReadDir(readPath)
	if err != nil {
		return fmt.Errorf("ReadExcel|ReadDir is err:%v", err)
	}

	for _, file := range files {
		if path.Ext(file.Name()) != ".csv" || hasChineseOrDefault(file.Name()) {
			continue
		}
		err := g.CsvToMem(readPath, file.Name())
		if err != nil {
			return err
		}

	}
	return nil
}