package paneldb

import (
	"fmt"

	"github.com/go-pg/pg"
	"github.com/pkg/errors"
	"golang.org/x/crypto/bcrypt"
)

// An User represents a user of the application.
type User struct {
	ID           string `sql:"uid"`
	Name         string `sql:"username"`
	Email        string `sql:"email"`
	DateCreated  string `sql:"created"`
	PasswordHash string `sql:"password"`
}

func (u User) String() string {
	return fmt.Sprintf("{User: %s <%s>}", u.Name, u.Email)
}

func (u User) Details() string {
	return fmt.Sprintf("UID:\t%s\nName:\t%s\nEmail:\t%s\nCreated:\t%s",
		u.ID, u.Name, u.Email, u.DateCreated)
}

// DB represents the application database. It provides high-level methods to get and manipulate objects.
type DB struct {
	PgDB   *pg.DB
	Schema string
}

// Setup will create schemas and tables as appropriate
func (db *DB) Setup() error {
	_, err := db.PgDB.Exec(`CREATE SCHEMA IF NOT EXISTS users`)
	if err != nil {
		return errors.Wrap(err, "Error creating schema")
	}
	fmt.Println("schema created")

	_, err = db.PgDB.Exec(`CREATE TABLE IF NOT EXISTS users.users (
		uid UUID PRIMARY KEY DEFAULT uuid_generate_v4(),
		username varchar(64) UNIQUE NOT NULL,
		email varchar(100) UNIQUE NOT NULL,
		created TIMESTAMPTZ NOT NULL DEFAULT NOW(),
		password varchar(256) NOT NULL
	)`)
	if err != nil {
		return errors.Wrap(err, "Error creating users table")
	}
	fmt.Println("table created")
	return nil
}

// UserAdd will add a user to the database
func (db *DB) UserAdd(username, email, pwd string) error {
	stmt, err := db.PgDB.Prepare("INSERT INTO users.users (username, email, password) VALUES ($1, $2, $3)")
	if err != nil {
		return errors.Wrap(err, "Error preparing insert statement")
	}
	pwhash, err := bcrypt.GenerateFromPassword([]byte(pwd), bcrypt.DefaultCost)
	if err != nil {
		return errors.Wrap(err, "Error deriving password (with bcrypt)")
	}
	_, err = stmt.Exec(username, email, string(pwhash))
	if err != nil {
		return errors.Wrapf(err, "Error adding user `%s`", username)
	}
	return nil
}

// GetUsers returns an array of Users
func (db *DB) GetUsers() ([]User, error) {
	var users []User
	_, err := db.PgDB.Query(&users, "SELECT * FROM users.users")
	if err != nil {
		return users, errors.Wrap(err, "User enumeration failed")
	}
	return users, err
}

// GetUserByName Search for exact username
func (db *DB) GetUserByName(username string) (User, error) {
	var user User
	_, err := db.PgDB.QueryOne(&user, `SELECT * FROM users.users WHERE username = ?`, username)
	if err != nil {
		return user, errors.Wrap(err, "User fetch failed")
	}
	return user, nil
}

// GetUserByEmail searches for exact email
func (db *DB) GetUserByEmail(email string) (User, error) {
	var user User
	_, err := db.PgDB.QueryOne(&user, "SELECT * FROM users.users WHERE email = ?", email)
	if err != nil {
		return user, errors.Wrap(err, "User fetch failed")
	}
	return user, nil
}

// GetUserByID search for exact uid
func (db *DB) GetUserByID(uid string) (User, error) {
	var user User
	_, err := db.PgDB.QueryOne(&user, "SELECT * FROM users.users WHERE uid=$1", uid)
	if err != nil {
		return user, errors.Wrap(err, "User fetch failed")
	}
	return user, nil
}