package pkg

import (
	"context"
	"fmt"
	"github.com/SkyAPM/go2sky"
	gormPlugin "github.com/SkyAPM/go2sky-plugins/gorm"
	"github.com/gin-gonic/gin"
	"gorm.io/driver/mysql"
	"gorm.io/gorm"
	"gorm.io/gorm/logger"
	"time"
)

type DbPoolConfig struct {
	Type            string `mapstructure:"type"`
	Host            string `mapstructure:"host"`
	Port            int    `mapstructure:"port"`
	User            string `mapstructure:"user"`
	Password        string `mapstructure:"password"`
	Database        string `mapstructure:"db"`
	Charset         string `mapstructure:"charset"`
	TablePrefix     string `mapstructure:"table_prefix"`
	MaxOpenConns    int    `mapstructure:"max_open_conns" summary:"最大连接数"`
	MaxIdleConns    int    `mapstructure:"max_idle_conns" summary:"最大空闲连接数"`
	ConnMaxLifetime int    `mapstructure:"conn_max_lifetime" summary:"连接的最大存活时间"`
	ConnMaxIdleTime int    `mapstructure:"conn_max_idle_time" summary:"连接空闲超时"`
}

type DatabasePkg struct {
}

var Database = &DatabasePkg{}

type Callback func(map[string]*gorm.DB)

func (c *DatabasePkg) Init(conf map[string]*DbPoolConfig, callback Callback) {
	var dbs = make(map[string]*gorm.DB)
	for key, value := range conf {
		dbs[key] = c.GetDb(value)
	}
	callback(dbs)
}

func (c *DatabasePkg) GetDb(config *DbPoolConfig) *gorm.DB {
	fmt.Printf("Cb Decoded result: %+v\n", config)
	dsn := fmt.Sprintf("%s:%s@tcp(%s:%d)/%s?charset=%s&parseTime=True&loc=Local",
		config.User, config.Password, config.Host, config.Port, config.Database, config.Charset)

	db, err := gorm.Open(mysql.Open(dsn), &gorm.Config{
		Logger: &GormLogger{},
	})
	if err != nil {
		panic(fmt.Sprintf("初始化数据库连接失败：%s", err))
	}

	sqlDB, err := db.DB()
	if err != nil {
		panic(fmt.Sprintf("获取 *sql.DB 对象失败：%s", err))
	}
	if config.MaxOpenConns > 0 {
		sqlDB.SetMaxOpenConns(config.MaxOpenConns)
	}
	if config.MaxIdleConns > 0 {
		sqlDB.SetMaxIdleConns(config.MaxOpenConns)
	}
	if config.ConnMaxLifetime > 0 {
		sqlDB.SetConnMaxLifetime(time.Duration(config.ConnMaxLifetime) * time.Second)
	}
	if config.ConnMaxIdleTime > 0 {
		sqlDB.SetConnMaxIdleTime(time.Duration(config.ConnMaxIdleTime) * time.Second)
	}

	tErr := db.Use(gormPlugin.New(
		go2sky.GetGlobalTracer(),
		gormPlugin.WithPeerAddr(fmt.Sprintf("%s:%d", config.Host, config.Port)),
		gormPlugin.WithSqlDBType(gormPlugin.MYSQL),
		gormPlugin.WithQueryReport(),
		gormPlugin.WithParamReport()),
	)
	if tErr != nil {
		panic(fmt.Sprintf("gorm插件引用失败：%s", err))
	}

	return db
}

type GormLogger struct {
}

func (p *GormLogger) LogMode(level logger.LogLevel) logger.Interface {
	return p
}

func (p *GormLogger) Info(ctx context.Context, msg string, data ...interface{}) {
	fmt.Printf("Info: %s\n", msg)
}

func (p *GormLogger) Warn(ctx context.Context, msg string, data ...interface{}) {
	fmt.Printf("Warn: %s\n", msg)
}

func (p *GormLogger) Error(ctx context.Context, msg string, data ...interface{}) {
	fmt.Printf("Error: %s\n", msg)
}

func (p *GormLogger) Trace(ctx context.Context, begin time.Time, fc func() (string, int64), err error) {
	if !gin.IsDebugging() {
		return
	}
	sql, _ := fc()
	SqlStatement := fmt.Sprintf("%s - [%s]", sql, time.Since(begin))
	fmt.Println(SqlStatement)

	ginCtx, existed := GCM.GetContext(ctx)
	var hSqls []string
	if existed {
		sqls, ok := ginCtx.Get("sqls")
		if ok {
			hSqls = sqls.([]string)
			hSqls = append(hSqls, SqlStatement)
		} else {
			hSqls = []string{SqlStatement}
		}
		ginCtx.Set("sqls", hSqls)
	}
}