package engine

import (
	"database/sql"
	"fmt"

	_ "git.fsdpf.net/go/db/dialect/mysql"
	_ "git.fsdpf.net/go/db/dialect/postgres"
	_ "git.fsdpf.net/go/db/dialect/sqlite3"
	_ "git.fsdpf.net/go/db/dialect/sqlserver"

	"git.fsdpf.net/go/db"
	"git.fsdpf.net/go/db/internal/errors"
)

type Engine struct {
	configs map[string]DBConfig
	dbs     map[string]*sql.DB
}

var _engine *Engine

func init() {
	_engine = &Engine{
		configs: make(map[string]DBConfig),
		dbs:     make(map[string]*sql.DB),
	}
}

func (e Engine) Connection(name string) *db.Database {
	cfg, ok := e.configs[name]

	if !ok {
		panic(errors.New(fmt.Sprintf("Database connection %s not configured.", name)))
	}

	_db, ok := e.dbs[name]

	if !ok {
		_db = e.MakeConnection(cfg)
		e.dbs[name] = _db
	}

	return db.New(cfg.Driver, _db)
}

func (e Engine) MakeConnection(cfg DBConfig) (db *sql.DB) {
	dsn := cfg.ToDSN()

	switch cfg.Driver {
	case "mysql":
	case "sqlite3":
	case "sqlserver":
	case "postgres":
	default:
		panic(fmt.Sprintf("Unsupported driver: %s", cfg.Driver))
	}

	db, err := sql.Open(cfg.Driver, dsn)

	if err != nil {
		panic(err)
	}

	if err := db.Ping(); err != nil {
		panic(err)
	}

	return db
}

func Open(cfgs map[string]DBConfig) Engine {
	for n, cfg := range cfgs {
		_engine.configs[n] = cfg
	}

	return *_engine
}

func Mock(cfgs map[string]MockDBConfig) Engine {
	for k, cfg := range cfgs {
		_engine.dbs[k] = cfg.Mock
		_engine.configs[k] = DBConfig{Driver: cfg.Driver}
	}
	return *_engine
}