db

var ErrEntityNotFound = errors.New("db: Entity not found")

var TweetDelete = func(tweet *Tweet) error {
	return sqlboiler.EntityDelete(tweet, dbx)
}

var TweetSave = func(tweet *Tweet) error {
	return sqlboiler.EntitySave(tweet, dbx)
}

var TweetsSortableColumns = []string{
	TweetsOrderByDateCreated,
}

var TwitterAccountDelete = func(account *TwitterAccount) error {
	return sqlboiler.EntityDelete(account, dbx)
}

var TwitterAccountFromID = func(id string) (TwitterAccountList, error) {
	var account TwitterAccountList

	if !isUUID.MatchString(id) {
		return account, ErrEntityNotFound
	}

	cmd := `SELECT ` + sqlboiler.GetFullColumnListString(&TwitterAccount{}, "ta") + `, COUNT(t.id) AS num_tweets
			FROM twitter_accounts ta
				LEFT OUTER JOIN tweets t ON ta.id = t.twitter_account_id
			WHERE ta.id = $1
			GROUP BY ta.id`

	err := dbx.QueryRowx(cmd, id).StructScan(&account)
	if err == sql.ErrNoRows {
		return account, ErrEntityNotFound
	}
	return account, err
}

var TwitterAccountGetTweetFromID = func(account *TwitterAccount, tweetID string) (Tweet, error) {
	var tweet Tweet

	cmd := `SELECT id, ` + sqlboiler.GetColumnListString(&tweet, "") + `
			FROM tweets
			WHERE twitter_account_id = $1 AND id = $2`

	err := dbx.Get(&tweet, cmd, account.ID, tweetID)
	if err == sql.ErrNoRows {
		return tweet, ErrEntityNotFound
	}
	return tweet, err
}

var TwitterAccountGetTweets = func(account *TwitterAccount, query TweetsQuery) ([]Tweet, int, error) {
	var tweets []Tweet
	totalRecords := 0

	if account.IsTransient() {
		return tweets, totalRecords, nil
	}

	var queryParams []interface{}
	queryParams = append(queryParams, account.ID)
	queryParams = append(queryParams, query.BuildOrderBy())
	queryParams = append(queryParams, query.Limit())
	queryParams = append(queryParams, query.Offset())

	cmd := `SELECT id, ` + sqlboiler.GetColumnListString(&Tweet{}, "") + `
			FROM tweets
			WHERE twitter_account_id = $1 `

	if !query.ToBePostedSince.IsZero() {
		cmd += `AND is_posted = false AND post_on > $5 `
		queryParams = append(queryParams, query.ToBePostedSince)
	}

	cmd += `ORDER BY $2
			LIMIT $3 OFFSET $4`

	rows, err := dbx.Queryx(cmd, queryParams...)
	if err != nil {
		return tweets, totalRecords, err
	}

	for rows.Next() {
		tweet := Tweet{}
		err = rows.StructScan(&tweet)

		if err != nil {
			return tweets, totalRecords, err
		}

		tweets = append(tweets, tweet)
	}

	rows.Close()

	// count tweets
	var countParams []interface{}
	countCmd := `SELECT COUNT(*) FROM tweets WHERE twitter_account_id = $1`

	countParams = append(countParams, account.ID)

	if !query.ToBePostedSince.IsZero() {
		countCmd += ` AND is_posted = false AND post_on > $2`
		countParams = append(countParams, query.ToBePostedSince)
	}

	err = dbx.Get(&totalRecords, countCmd, countParams...)

	return tweets, totalRecords, err
}

var TwitterAccountSave = func(account *TwitterAccount) error {
	return sqlboiler.EntitySave(account, dbx)
}

var TwitterAccountsAll = func(query TwitterAccountQuery) ([]TwitterAccountList, int, error) {
	var accounts []TwitterAccountList
	recordCount := 0

	cmd := sq.
		Select(sqlboiler.GetFullColumnList(&TwitterAccount{}, "ta")...).Column("COUNT(t.id) AS num_tweets").
		From("twitter_accounts ta").
		LeftJoin("tweets t ON ta.id = t.twitter_account_id")

	if query.ContainsUsername != "" {
		cmd = cmd.Where("ta.username LIKE ?", query.ContainsUsername)
	}

	if !query.HasTweetsToBePostedSince.IsZero() {
		cmd = cmd.Where("t.is_posted = ? AND t.post_on > ?", false, query.HasTweetsToBePostedSince)
	}

	if query.UserID != "" {
		cmd = cmd.Where("ta.user_id = ?", query.UserID)
	}

	cmd = cmd.
		GroupBy("ta.id").
		OrderBy(query.BuildOrderBy()).
		Limit(uint64(query.Limit())).
		Offset(uint64(query.Offset()))

	sqlString, args, err := cmd.PlaceholderFormat(sq.Dollar).ToSql()
	if err != nil {
		return nil, recordCount, err
	}

	rows, err := dbx.Queryx(sqlString, args...)
	if err != nil {
		return nil, recordCount, err
	}

	defer rows.Close()

	for rows.Next() {
		account := TwitterAccountList{}
		err = rows.StructScan(&account)

		if err != nil {
			return nil, recordCount, err
		}

		accounts = append(accounts, account)
	}

	countCmd := sq.
		Select("COUNT(DISTINCT ta.id)").
		From("twitter_accounts ta")

	if query.ContainsUsername != "" || !query.HasTweetsToBePostedSince.IsZero() {
		countCmd = countCmd.
			LeftJoin("tweets t ON ta.id = t.twitter_account_id")

		if query.ContainsUsername != "" {
			countCmd = countCmd.Where("ta.username LIKE ?", query.ContainsUsername)
		}

		if !query.HasTweetsToBePostedSince.IsZero() {
			countCmd = countCmd.Where("t.is_posted = ? AND t.post_on > ?", false, query.HasTweetsToBePostedSince)
		}

		if query.UserID != "" {
			countCmd = countCmd.Where("ta.user_id = ?", query.UserID)
		}
	}

	countSQL, countArgs, err := countCmd.PlaceholderFormat(sq.Dollar).ToSql()
	if err != nil {
		return nil, recordCount, err
	}

	err = dbx.Get(&recordCount, countSQL, countArgs...)

	return accounts, recordCount, err
}

var TwitterAccountsSortableColumns = []string{
	TwitterAccountsOrderByUsername,
	TwitterAccountsOrderByDateCreated,
}

var UserDelete = func(user *User) error {
	return sqlboiler.EntityDelete(user, dbx)
}

var UserFromEmail = func(email string) (User, error) {
	var user User

	cmd := `SELECT ` + sqlboiler.GetFullColumnListString(&user, "") + `
			FROM users
			WHERE email = $1`

	err := dbx.QueryRowx(cmd, email).StructScan(&user)
	if err == sql.ErrNoRows {
		return user, ErrEntityNotFound
	} else if err != nil {
		return user, err
	}

	return user, nil
}

var UserFromID = func(id string) (User, error) {
	var user User

	if !isUUID.MatchString(id) {
		return user, ErrEntityNotFound
	}

	err := sqlboiler.EntityGetByID(&user, id, dbx)
	if err == sqlboiler.ErrEntityNotFound {
		return user, ErrEntityNotFound
	}
	return user, err
}

var UserSave = func(user *User) error {
	return sqlboiler.EntitySave(user, dbx)
}

var UsersAll = func(query PagingInfo) ([]User, int, error) {
	var users []User
	recordCount := 0

	cmd, _, err := sq.
		Select(sqlboiler.GetFullColumnList(&User{}, "")...).
		From("users").
		OrderBy(query.BuildOrderBy()).
		Limit(uint64(query.Limit())).Offset(uint64(query.Offset())).
		ToSql()

	if err != nil {
		return nil, recordCount, err
	}

	rows, err := dbx.Queryx(cmd)
	if err != nil {
		return nil, recordCount, err
	}

	defer rows.Close()

	for rows.Next() {
		user := User{}
		err = rows.StructScan(&user)
		if err != nil {
			return nil, recordCount, err
		}

		users = append(users, user)
	}

	err = dbx.Get(&recordCount, "SELECT COUNT(*) FROM users")
	return users, recordCount, err
}

var UsersSortableColumns = []string{
	UsersOrderByDateCreated,
	UsersOrderByEmail,
}