package conf

import (
	"database/sql"
	"fmt"
	"sync"
	"time"

	_ "github.com/go-sql-driver/mysql"
)

// 全局配置对象，初始化时加载配置，应用程序中直接使用
// 配置加载方式：
//
//	loadConfigFromToml
//	loadConfigFromEnv
//
// 为了不被程序运行时恶意修改，设置为私有变量
var config *Config

var db *sql.DB

// GetConfig 获取全局配置对象
func C() *Config {
	return config
}

// NewDefaultConfig 创建默认配置
func NewDefaultConfig() *Config {
	return &Config{
		App:   NewDefaultApp(),
		Log:   NewDefaultLog(),
		MySQL: NewDefaultMySQL(),
	}
}

// 应用配置对象
type Config struct {
	App   *App   `toml:"app"`
	Log   *Log   `toml:"log"`
	MySQL *MySQL `toml:"mysql"`
}

func NewDefaultApp() *App {
	return &App{
		Name: "app",
		Host: "127.0.0.1",
		Port: "8080",
	}
}

type App struct {
	Name string `toml:"name" env:"APP_NAME"`
	Host string `toml:"host" env:"APP_HOST"`
	Port string `toml:"port" env:"APP_PORT"`
}

func NewDefaultLog() *Log {
	return &Log{
		Level:  "info",
		Format: TextFormat,
		To:     ToStdout,
	}
}

type Log struct {
	//debug, info, warn, error, dpanic, panic, fatal
	Level   string    `toml:"level" env:"LOG_LEVEL"`
	PathDir string    `toml:"path_dir" env:"LOG_PATH_DIR"`
	Format  LogFormat `toml:"format" env:"LOG_FORMAT"`
	To      LogTo     `toml:"to" env:"LOG_TO"`
}

func NewDefaultMySQL() *MySQL {
	return &MySQL{
		Host:         "127.0.0.1",
		Port:         "3306",
		UserName:     "root",
		Password:     "2370411",
		Database:     "restful_api_demo",
		MaxIdleConns: 5,
		MaxOpenConns: 10,
		MaxLifetime:  300,
		MaxIdleTime:  300,
	}
}

type MySQL struct {
	Host     string `toml:"host" env:"MYSQL_HOST"`
	Port     string `toml:"port" env:"MYSQL_PORT"`
	UserName string `toml:"username" env:"MYSQL_USERNAME"`
	Password string `toml:"password" env:"MYSQL_PASSWORD"`
	Database string `toml:"database" env:"MYSQL_DATABASE"`
	// 连接池配置,含义：最大空闲连接数
	MaxIdleConns int `toml:"max_idle_conns" env:"MYSQL_MAX_IDLE_CONNS"`
	// 最大打开连接数，含义：最大连接数
	MaxOpenConns int `toml:"max_open_conns" env:"MYSQL_MAX_OPEN_CONNS"`
	// 连接最大存活时间，含义：连接最大存活时间
	MaxLifetime int `toml:"max_lifetime" env:"MYSQL_MAX_LIFETIME"`
	// 连接最大空闲时间，含义：连接最大空闲时间
	MaxIdleTime int `toml:"max_idle_time" env:"MYSQL_MAX_IDLE_TIME"`

	//锁,私有变量
	lock sync.Mutex
}

func (m *MySQL) GetDBConn() (*sql.DB, error) {
	var err error
	dsn := fmt.Sprintf("%s:%s@tcp(%s:%s)/%s?charset=utf8mb4&parseTime=True&loc=Local", m.UserName, m.Password, m.Host, m.Port, m.Database)
	db, err := sql.Open("mysql", dsn)
	if err != nil {
		return nil, err
	}
	db.SetMaxOpenConns(m.MaxOpenConns)
	db.SetMaxIdleConns(m.MaxIdleConns)
	db.SetConnMaxLifetime(time.Duration(m.MaxLifetime) * time.Second)
	db.SetConnMaxIdleTime(time.Duration(m.MaxIdleTime) * time.Second)
	return db, nil
}

// 1.使用LoadGlobalDB()函数加载全局数据库连接
// 2.惰性加载，获取的时候动态加载再初始化
func (m *MySQL) GetDB() *sql.DB {
	if db != nil {
		return db
	}
	m.lock.Lock()
	defer m.lock.Unlock()
	if db != nil {
		return db
	}
	var err error
	db, err = m.GetDBConn()
	if err != nil {
		panic(err)
	}
	return db
}