type Query struct {
	Raw   string
	Named *sqlx.NamedStmt
}

func (q *Query) Build(db *sqlx.DB) error {
	var err error
	q.Named, err = db.PrepareNamed(q.Raw)
	return nil
}

func initQF(db *sqlx.DB, qf func() *Query) error {
	q := qf()
	return q.Build(db)
}

func defineQ(q *Query, raw string) *Query {
	if q != nil {
		return q
	}
	q = &Query{
		Raw: raw,
	}
	return q
}

type AddUser struct {
	checkUserExists *Query
	insertUser      *Query
}

func NewAddUser(db *sqlx.DB) (*AppQueries, error) {
	var au AddUser

	if err := initQF(db, au.checkUserExists); err != nil {
		return nil, err
	}

	if err := initQF(db, au.insertUser); err != nil {
		return nil, err
	}

	return &au, nil
}

type UserQuery interface {
	CheckUserExists() Query
	InsertUser() Query
}

func SignupUser(uq UserQuery) {
	uq.CheckUserExists()
	uq.InsertUser()
}

// Here is the nice part: You can define you queries in their methods, which seems clean and
// easily inspectable
func (au *AddUser) CheckUserExists() *Query {
	return defineQ(au.checkUserExists,
		`SELECT COUNT(*) FROM users ...`)
}

func (au *AddUser) InsertUser() *Query {
	return defineQ(au.insertUser,
		`INSERT INTO users ...`)
}

// =============================================================================

type AddUser struct {
	db              *sqlx.DB
	checkUserExists *sqlx.NamedStmt
	insertUser      *sqlx.NamedStmt
}

func NewAddUser(db *sqlx.DB) (*AddUser, error) {
	var err error

	queryCUE := "SELECT COUNT(*) FROM users ..."
	namedCUE, err := db.PrepareNamed(queryCUE)
	if err != nil {
		return nil, err
	}

	queryIU := "INSERT INTO users ..."
	namedIU, err := db.PrepareNamed(queryIU)
	if err != nil {
		return nil, err
	}

	au := AddUser{
		db:              db,
		checkUserExists: namedCUE,
		insertUser:      namedIU,
	}

	return &au, nil
}

func (au *AddUser) Execute() error {
	// DO STUFF HERE
}