package db

import (
	"database/sql"
)

type Config struct {
	host     string
	port     string
	user     string
	password string
}

type Db struct {
	db     *sql.DB
	Driver string
}

func New(driver string, connection string) (*Db, error) {
	conn, err := open(driver, connection)
	if err != nil {
		return nil, err
	}

	db := &Db{db: conn, Driver: driver}
	if err != nil {
		return nil, err
	}

	return db, nil
}

func open(driver string, conn string) (*sql.DB, error) {
	if driver == "mssql" {
		return OpenMssql(conn)
	}

	if driver == "pgsql" {
		return OpenPgsql(conn)
	}

	return OpenSqlite(conn)
}

func (db *Db) Execute(sql string) (int64, error) {
	res, err := db.db.Exec(sql)
	if err != nil {
		return -1, err
	}

	num, err := res.RowsAffected()
	if err != nil {
		return -1, err
	}

	return num, nil
}

func (db *Db) Query(sql string) (*sql.Rows, error) {
	rows, err := db.db.Query(sql)
	if err != nil {
		return nil, err
	}

	return rows, nil
}

func (db *Db) QueryMap(sql string) ([]map[string]interface{}, error) {
	rows, err := db.Query(sql)
	if err != nil {
		return nil, err
	}
	defer rows.Close()

	cols, err := rows.Columns()
	if err != nil {
		return nil, err
	}

	row := make([]interface{}, len(cols))
	for idx := range row {
		var obj interface{}
		row[idx] = &obj
	}

	var list []map[string]interface{}
	for rows.Next() {
		_ = rows.Scan(row...)

		item := make(map[string]interface{})
		for key, val := range row {
			item[cols[key]] = *val.(*interface{})
		}

		list = append(list, item)
	}

	return list, nil
}

func (db *Db) Close() {
	db.db.Close()
}