package sqlload

import (
	"fmt"
	"go-create-template/configs"
	"go-create-template/util"
	"strings"
)

var CTables []CTable
var CGans []Gen

// Load 加载数据库参数
func Load() {
	metas, err := configs.Engine.DBMetas()
	if err != nil {
		panic(err)
	}
	CTables = make([]CTable, len(metas))
	for i := range metas {
		table := CTable{
			Name:          metas[i].Name,
			Comment:       metas[i].Comment,
			Key:           CTableColumn{},
			CTableColumns: make([]CTableColumn, len(metas[i].Columns())),
		}
		for j := range metas[i].Columns() {
			column := CTableColumn{}
			column.Name = metas[i].Columns()[j].Name
			column.IsPrimaryKey = metas[i].Columns()[j].IsPrimaryKey
			column.IsAutoIncrement = metas[i].Columns()[j].IsAutoIncrement
			column.Comment = metas[i].Columns()[j].Comment
			column.SQLType = CSQLType{
				Name:           metas[i].Columns()[j].SQLType.Name,
				DefaultLength:  metas[i].Columns()[j].SQLType.DefaultLength,
				DefaultLength2: metas[i].Columns()[j].SQLType.DefaultLength2,
			}
			column.Nullable = metas[i].Columns()[j].Nullable
			if column.IsPrimaryKey {
				table.Key = column
			}
			table.CTableColumns[j] = column
		}
		CTables[i] = table
	}

	LoadGenTableAndGenTableColumn()
	LoadGenTableData()
}

// LoadGenTableAndGenTableColumn 加载数据库中的表格和列字段生成
func LoadGenTableAndGenTableColumn() {
	var tables = make([]GenTable, 0)
	err := configs.Engine.Table("gen_table").Find(&tables)
	if err != nil {
		panic(err)
	}
	var genTableColumns []GenTableColumn
	err = configs.Engine.Table("gen_table_column").Find(&genTableColumns)
	if err != nil {
		panic(err)
	}
	gens := make([]Gen, len(tables))
	m := make(map[int64]int)
	for i := range tables {
		gen := Gen{Table: tables[i], TableColumns: make([]GenTableColumn, 0)}
		gens[i] = gen
		m[tables[i].Id] = i
	}

	for i := range genTableColumns {
		gen, ok := m[genTableColumns[i].TableId]
		if ok {
			gens[gen].TableColumns = append(gens[gen].TableColumns, genTableColumns[i])
		}
	}
	CGans = gens
}

// LoadGenTableData 去重补漏
func LoadGenTableData() {
	//查询表格是否重复
	ct := make(map[string]CTable)
	cg := make(map[string]Gen)
	for i := range CTables {
		ct[CTables[i].Name] = CTables[i]
	}
	for i := range CGans {
		cg[CGans[i].Table.TableName] = CGans[i]
	}
	notAddedCG := make(map[string]Gen)
	addedCG := make(map[string]CTable)
	for s := range cg {
		_, ok := ct[s]
		if ok {
			addedCG[s] = ct[s]
		} else {
			fmt.Println(cg[s])
			notAddedCG[s] = cg[s]
		}
	}

	for s := range notAddedCG {
		configs.Engine.Insert(GenTable{
			TableName:    notAddedCG[s].Table.TableName,
			TableComment: notAddedCG[s].Table.TableComment,
			Name:         util.BigHump(notAddedCG[s].Table.TableName),
			RouterName:   util.SmallHump(notAddedCG[s].Table.TableName),
			Remark:       notAddedCG[s].Table.TableComment})
	}
	//删除多余表格
	for s := range ct {
		_, ok := cg[s]
		if !ok {
			configs.Engine.Table("gen_table").Where("id = ?", cg[s].Table.Id).Delete(ct[s])
		}
	}
	LoadGenTableAndGenTableColumn()
	for i := range CTables {
		ct[CTables[i].Name] = CTables[i]
	}
	for i := range CGans {
		cg[CGans[i].Table.TableName] = CGans[i]
	}
	//添加未添加字段
	for i := range CTables {
		//获取表格
		var table GenTable
		configs.Engine.Table("gen_table").Where("table_name = ?", CTables[i].Name).Get(&table)
		for j := range CTables[i].CTableColumns {
			//获取列字段
			var tableColumn GenTableColumn
			configs.Engine.Table("gen_table_column").
				Where("table_id = ? and column_name = ?", table.Id, CTables[i].CTableColumns[j].Name).Get(&tableColumn)
			if tableColumn.Id == 0 {
				column := GenTableColumn{
					TableId:       table.Id,
					Sort:          0,
					ColumnName:    CTables[i].CTableColumns[j].Name,
					ColumnComment: CTables[i].CTableColumns[j].Comment,
					ColumnType:    strings.ToLower(CTables[i].CTableColumns[j].SQLType.Name),
					GoType:        util.ToGoType(CTables[i].CTableColumns[j].SQLType.Name),
					GoField:       util.BigHump(CTables[i].CTableColumns[j].Name),
					VueShowType:   "",
					IsRequired:    "",
					IsKey:         "",
					DictType:      "",
				}
				fmt.Println(column)
				configs.Engine.Table("gen_table_column").Insert(&column)
			}
		}
	}
	//移除多余字段
	for i := range CGans {
		sign := 0
		for j := range CTables {
			if CTables[j].Name == CGans[i].Table.Name {
				sign = j
				break
			}
		}
		for k := range CGans[i].TableColumns {
			ex := false
			for j := 0; j < len(CTables[sign].CTableColumns); j++ {
				if CGans[i].TableColumns[k].ColumnName == CTables[sign].CTableColumns[j].Name {
					ex = true
					break
				}
			}
			//删除
			if !ex {
				configs.Engine.Table("gen_table_column").Where("table_id = ? and column_name = ?",
					CGans[i].TableColumns[k].Id, CGans[i].TableColumns[k].ColumnName).Limit(1).Delete(CGans[i].TableColumns[k])
				fmt.Println("delete column:", CGans[i].TableColumns[k].ColumnName)
			}
		}
	}
}