package gen

import (
	"errors"
	"fmt"
	"gitee.com/mosache/YFrame/tools/Y/model/conf"
	"os"
	"sort"
	"text/template"
)

type Generator struct {
	dataBaseName string
	tables       []string
	tablePrefix  string
}

func NewGenerator(opts ...Option) *Generator {
	g := &Generator{
		dataBaseName: conf.Config.DataBase,
		tables:       nil,
		tablePrefix:  "",
	}

	for _, o := range opts {
		o(g)
	}

	return g
}

type Option func(g *Generator)

func WithDataBaseName(dataBaseName string) Option {
	return func(g *Generator) {
		g.dataBaseName = dataBaseName
	}
}

func WithTables(tables []string) Option {
	return func(g *Generator) {
		g.tables = tables
	}
}

func WithTablePrefix(tablePrefix string) Option {
	return func(g *Generator) {
		g.tablePrefix = tablePrefix
	}
}

///====================================================================================

func (g *Generator) Generate(targetPath string, packageName string, tableNamePrefix string, isDoc bool) error {
	/// 1 get column information
	cInfo, err := getColumnInfo(g.dataBaseName, g.tables)
	if err != nil {
		return err
	}

	/// 2 get table vo
	tables := make([]tableInfo, 0)
	tableNameFilterMap := make(map[tableNameAndCommentFilterMapKey][]*ColumnInfoModel)
	for _, e := range cInfo {
		key := tableNameAndCommentFilterMapKey{
			TableName:    e.TableName,
			TableComment: e.TableComment,
		}
		if _, ok := tableNameFilterMap[key]; ok {
			tableNameFilterMap[key] = append(tableNameFilterMap[key], e)
		} else {
			tableNameFilterMap[key] = []*ColumnInfoModel{e}
		}
	}

	for k, v := range tableNameFilterMap {
		filedList := make([]tableColumnInfo, 0)

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

		for _, e := range v {
			filedList = append(filedList, tableColumnInfo{
				ColumnName:    e.ColumnName,
				DataType:      _getGoDataType(e.DataType),
				ColumType:     e.ColumnType,
				ColumnComment: _getFieldComment(e.ColumnComment),
				IsPrimaryKey:  _getIsPrimaryKey(e.IsPrimaryKey),
				Tag:           _getModelFieldTag(e.ColumnName, _getIsPrimaryKey(e.IsPrimaryKey)),
			})
		}

		tables = append(tables, tableInfo{
			TableName:       k.TableName,
			TableComment:    k.TableComment,
			TableNamePrefix: tableNamePrefix,
			Columns:         filedList,
			ModName:         conf.Config.ModName,
			Package:         packageName,
		})

	}

	/// 3 gen file
	if !isDoc {
		/// gen model file
		return _genModelFile(targetPath, tables)
	}

	/// is doc , gen doc markdown file
	return _genDocMarkDown(targetPath, tables)
}

func _genDocMarkDown(targetPath string, tables []tableInfo) error {
	t := template.New("doc-template")

	t.Funcs(map[string]interface{}{
		"GetFieldCommentStr": GetFieldCommentStr,
	})

	pt, err := t.Parse(DocTpl)
	if err != nil {
		return err
	}

	/// 判断targetPath是否存在,没有需要创建
	if err := _checkTargetPath(targetPath); err != nil {
		return err
	}

	fileName := "doc.md"
	file, err := os.OpenFile(fmt.Sprintf("%s/%s", targetPath, fileName), os.O_CREATE|os.O_RDWR|os.O_TRUNC, os.ModePerm)
	if err != nil {
		return err
	}

	err = pt.Execute(file, map[string]interface{}{"tables": tables})
	if err != nil {
		return err
	}

	return nil
}

func _genModelFile(targetPath string, tables []tableInfo) error {
	t := template.New("m-template")
	t.Funcs(map[string]interface{}{
		"GetGoStylePropertyName": GetGoStylePropertyName,
		"FormatComment":          FormatComment,
	})
	pt, err := t.Parse(modelTpl)
	if err != nil {
		return err
	}

	if len(targetPath) == 0 {
		targetPath = "./"
	}
	/// 判断targetPath是否存在,没有需要创建
	if err := _checkTargetPath(targetPath); err != nil {
		return err
	}

	for _, e := range tables {
		fileName := fmt.Sprintf("%sModel.go", GetGoStylePropertyName(e.TableName))
		file, err := os.OpenFile(fmt.Sprintf("%s/%s", targetPath, fileName), os.O_CREATE|os.O_RDWR|os.O_TRUNC, os.ModePerm)
		if err != nil {
			return err
		}

		err = pt.Execute(file, e)
		if err != nil {
			return err
		}
	}

	return nil
}

func _checkTargetPath(targetPath string) error {
	_, err := os.Stat(targetPath)
	if err != nil {
		if errors.Is(err, os.ErrNotExist) {
			err := os.MkdirAll(targetPath, os.ModePerm)
			if err != nil {
				return err
			}
		} else {
			return err
		}
	}

	return nil
}