// OpenFromConnPool takes the existing *pgx.ConnPool pool and returns a *sql.DB
// with pool as the backend. This enables full control over the connection
// process and configuration while maintaining compatibility with the
// database/sql interface. In addition, by calling Driver() on the returned
// *sql.DB and typecasting to *stdlib.Driver a reference to the pgx.ConnPool can
// be reaquired later. This allows fast paths targeting pgx to be used while
// still maintaining compatibility with other databases and drivers.
//
// pool connection size must be at least 2.
func OpenFromConnPool(pool *pgx.ConnPool) (*sql.DB, error) {
	d := &Driver{Pool: pool}
	name := fmt.Sprintf("pgx-%d", openFromConnPoolCount)
	openFromConnPoolCount++
	sql.Register(name, d)
	db, err := sql.Open(name, "")
	if err != nil {
		return nil, err
	}

	// Presumably OpenFromConnPool is being used because the user wants to use
	// database/sql most of the time, but fast path with pgx some of the time.
	// Allow database/sql to use all the connections, but release 2 idle ones.
	// Don't have database/sql immediately release all idle connections because
	// that would mean that prepared statements would be lost (which kills
	// performance if the prepared statements constantly have to be reprepared)
	stat := pool.Stat()

	if stat.MaxConnections <= 2 {
		return nil, errors.New("pool connection size must be at least 2")
	}
	db.SetMaxIdleConns(stat.MaxConnections - 2)
	db.SetMaxOpenConns(stat.MaxConnections)

	return db, nil
}

func init() {
	mu.Lock()
	defer mu.Unlock()

	if !driverRegistered("mysql") {
		sql.Register("mysql", &mysql.MySQLDriver{})
	}

	if !driverRegistered("mariadb") {
		sql.Register("mariadb", &mysql.MySQLDriver{})
	}
}

// init computes the supported versions into a byte slice and register the driver.
func init() {
	for i, v := range versionsSupported {
		binary.BigEndian.PutUint32(handshakeRequest[i*4:i*4+4], v)
	}

	sql.Register("neo4j-bolt", &neoDriver{})
}

func initDatabase() models.Control {
	var dbDriver string
	sql.Register(dbDriver, &sqlite3.SQLiteDriver{})

	database, err := sql.Open(dbDriver, "db")

	if err != nil {
		fmt.Println("Failed to create the handle")
	}

	if err := database.Ping(); err != nil {
		fmt.Println("Failed to keep connection alive")
	}

	if err != nil {
		log.Fatal(err)
	}

	_, err = database.Exec(
		"CREATE TABLE IF NOT EXISTS Config (id integer PRIMARY KEY, notifications_limit integer NOT NULL, timeout integer NOT NULL)",
	)

	if err != nil {
		log.Fatal(err)
	}

	config := models.Config{NotificationsLimit: 3, Timeout: 10}
	_ = database.QueryRow(
		"SELECT notifications_limit, timeout FROM Config ORDER BY id DESC LIMIT 1",
	).Scan(&config.NotificationsLimit, &config.Timeout)

	controller := models.Control{Config: config, Database: database}
	return controller
}

func main() {

	// Load and validate config file.
	config := LoadConfig("config.json")

	// Register SQLite driver.
	sqlite3conn := []*sqlite3.SQLiteConn{}
	sql.Register(config.DbName,
		&sqlite3.SQLiteDriver{
			ConnectHook: func(conn *sqlite3.SQLiteConn) error {
				sqlite3conn = append(sqlite3conn, conn)
				return nil
			},
		})

	// Open SQLite database and assign it to the contxt.
	db, err := sql.Open(config.DbName, config.DbPath)
	if err != nil {
		log.Fatal(err.Error())
	}

	// Create the application context.
	ctx := server.NewAppContext(db, config.AuthKey)
	defer db.Close()

	// Create mux and register the handlers.
	mux := http.NewServeMux()
	mux.Handle("/gcm/devices/", server.NewGCMHandler(ctx))
	mux.Handle("/apn/devices/", server.NewAPNHandler(ctx))

	// Attemp to start the server.
	address := fmt.Sprintf("%s:%d", config.Address, config.Port)
	log.Fatal(http.ListenAndServe(address, mux))
}

func main() {
	sql.Register("sqlite3_with_extensions",
		&sqlite3.SQLiteDriver{
			Extensions: []string{
				"sqlite3_mod_regexp",
			},
		})

	db, err := sql.Open("sqlite3_with_extensions", ":memory:")
	if err != nil {
		log.Fatal(err)
	}
	defer db.Close()

	// Force db to make a new connection in pool
	// by putting the original in a transaction
	tx, err := db.Begin()
	if err != nil {
		log.Fatal(err)
	}
	defer tx.Commit()

	// New connection works (hopefully!)
	rows, err := db.Query("select 'hello world' where 'hello world' regexp '^hello.*d$'")
	if err != nil {
		log.Fatal(err)
	}
	defer rows.Close()
	for rows.Next() {
		var helloworld string
		rows.Scan(&helloworld)
		fmt.Println(helloworld)
	}
}

func BenchmarkCustomFunctions(b *testing.B) {
	customFunctionOnce.Do(func() {
		custom_add := func(a, b int64) int64 {
			return a + b
		}

		sql.Register("sqlite3_BenchmarkCustomFunctions", &SQLiteDriver{
			ConnectHook: func(conn *SQLiteConn) error {
				// Impure function to force sqlite to reexecute it each time.
				if err := conn.RegisterFunc("custom_add", custom_add, false); err != nil {
					return err
				}
				return nil
			},
		})
	})

	db, err := sql.Open("sqlite3_BenchmarkCustomFunctions", ":memory:")
	if err != nil {
		b.Fatal("Failed to open database:", err)
	}
	defer db.Close()

	b.ResetTimer()
	for i := 0; i < b.N; i++ {
		var i int64
		err = db.QueryRow("SELECT custom_add(1,2)").Scan(&i)
		if err != nil {
			b.Fatal("Failed to run custom add:", err)
		}
	}
}

func main() {
	sql.Register("sqlite3_with_extensions",
		&sqlite3.SQLiteDriver{
			Extensions: []string{
				"sqlite3_mod_vtable",
			},
		})

	db, err := sql.Open("sqlite3_with_extensions", ":memory:")
	if err != nil {
		log.Fatal(err)
	}
	defer db.Close()

	db.Exec("create virtual table repo using github(id, full_name, description, html_url)")

	rows, err := db.Query("select id, full_name, description, html_url from repo")
	if err != nil {
		log.Fatal(err)
	}
	defer rows.Close()
	for rows.Next() {
		var id, full_name, description, html_url string
		rows.Scan(&id, &full_name, &description, &html_url)
		fmt.Printf("%s: %s\n\t%s\n\t%s\n\n", id, full_name, description, html_url)
	}
}

// GetDatabase initialises a new database for a NameCache.
func GetDatabase(cfg *DBConfig) (*sql.DB, error) {
	driver := "sqlite3_sous"
	conn := InMemory
	if cfg != nil {
		if cfg.Driver != "" {
			driver = cfg.Driver
		}
		if cfg.Connection != "" {
			conn = cfg.Connection
		}
	}

	if driver == "sqlite3" {
		driver = "sqlite3_sous"
	}

	registerSQLOnce.Do(func() {
		sql.Register(driver, &sqlite.SQLiteDriver{
			ConnectHook: func(conn *sqlite.SQLiteConn) error {
				if err := conn.RegisterFunc("semverEqual", semverEqual, true); err != nil {
					return err
				}
				return nil
			},
		})
	})

	db, err := sql.Open(driver, conn) //only call once
	return db, errors.Wrapf(err, "get DB/open: %v", cfg)
}

func init() {
	err := initDriver()
	if err != nil {
		panic(err)
	}
	sql.Register("odbc", &drv)
}

func TestOpen(t *testing.T) {
	cfgfile := os.Getenv("DBCONFIG")
	if cfgfile == "" {
		cfgfile = "config.toml"
	}
	cfg := new(Config)
	if f, err := os.Open(cfgfile); err != nil {
		t.Fatal(err, "(did you set the DBCONFIG env variable?)")
	} else {
		if _, err := toml.DecodeReader(f, cfg); err != nil {
			t.Fatal(err)
		}
	}

	d := NewDriver("ClusterSql", mysql.MySQLDriver{})

	for _, ncfg := range cfg.Nodes {
		if ncfg.Password != "" {
			d.AddNode(ncfg.Name, fmt.Sprintf("%s:%[email protected](%s:%d)/%s", ncfg.UserName, ncfg.Password, ncfg.HostName, ncfg.Port, ncfg.DBName))
		} else {
			d.AddNode(ncfg.Name, fmt.Sprintf("%[email protected](%s:%d)/%s", ncfg.UserName, ncfg.HostName, ncfg.Port, ncfg.DBName))
		}
	}

	sql.Register("cluster", d)
	var err error
	db, err = sql.Open("cluster", "galera")
	if err != nil {
		t.Error(err)
	}
}

// Register a txdb sql driver under the given sql driver name
// which can be used to open a single transaction based database
// connection.
//
// When Open is called any number of times it returns
// the same transaction connection. Any Begin, Commit calls
// will not start or close the transaction.
//
// When Close is called, the transaction is rolled back.
//
// Use drv and dsn as the standard sql properties for
// your test database connection to be isolated within transaction.
//
// Note: if you open a secondary database, make sure to differianciate
// the dsn string when opening the sql.DB. The transaction will be
// isolated within that dsn
func Register(name, drv, dsn string) {
	sql.Register(name, &txDriver{
		dsn:   dsn,
		drv:   drv,
		conns: make(map[string]*conn),
	})
}

func init() {
	hook := func(conn *sqlite3.SQLiteConn) error {
		_, err := conn.Exec("PRAGMA foreign_keys = ON", nil)
		return err
	}
	driver := &sqlite3.SQLiteDriver{ConnectHook: hook}
	sql.Register("sql_fk", driver)
}

func init() {
	sql.Register("sqlite3", &Driver{})
	if os.Getenv("SQLITE_LOG") != "" {
		ConfigLog(func(d interface{}, err error, msg string) {
			log.Printf("%s: %s, %s\n", d, err, msg)
		}, "SQLITE")
	}
}

func init() {
	fmt.Println("init()", reflect.TypeOf(globalStubDriver))

	// for stub test: not call in init() usually
	db, err := globalStubDriver.Open("DataSourceName")
	fmt.Println("db, err=\t", db, err)

	sql.Register("stubdriver", globalStubDriver)
}

func init() {
	dvr = NewFakeDialect()
	sql.Register("dali", dvr)
	dbHandle, err := sql.Open("dali", "")
	if err != nil {
		panic(err)
	}
	db = NewDB(dbHandle, dvr)
}

func init() {
	sql.Register("sqlite3_textql",
		&sqlite3.SQLiteDriver{
			ConnectHook: func(conn *sqlite3.SQLiteConn) error {
				sqlite3conn = append(sqlite3conn, conn)
				return nil
			},
		})
}

func init() {
	sql.Register("sqlite3_fk",
		&sqlite3.SQLiteDriver{
			ConnectHook: func(conn *sqlite3.SQLiteConn) error {
				_, err := conn.Exec("PRAGMA foreign_keys = ON", nil)
				return err
			},
		})
}

func init() {
	sql.Register("sqlite3", &impl{open: defaultOpen})
	if os.Getenv("SQLITE_LOG") != "" {
		ConfigLog(func(d interface{}, err error, msg string) {
			log.Printf("%s: %s, %s\n", d, err, msg)
		}, "SQLITE")
	}
	ConfigMemStatus(false)
}

func init() {
	sql.Register("csv", &csvDriver{})

	db, err := sql.Open("ql", "memory:///dev/null")
	if err != nil {
		panic(err)
	}
	defer db.Close()
	qldrv = db.Driver()
}