// Code generated by sqlc. DO NOT EDIT.
// versions:
//   sqlc v1.31.1
// source: user.sql

package sqlcgen

import (
	"context"
)

const createUser = `-- name: CreateUser :one
INSERT INTO users (access_hash, phone, first_name, last_name, username, country_code)
VALUES ($1, $2, $3, $4, $5, $6)
RETURNING id, access_hash, phone, first_name, last_name, username, country_code, created_at, updated_at, verified, support, about, last_seen_at
`

type CreateUserParams struct {
	AccessHash  int64
	Phone       string
	FirstName   string
	LastName    string
	Username    string
	CountryCode string
}

func (q *Queries) CreateUser(ctx context.Context, arg CreateUserParams) (User, error) {
	row := q.db.QueryRow(ctx, createUser,
		arg.AccessHash,
		arg.Phone,
		arg.FirstName,
		arg.LastName,
		arg.Username,
		arg.CountryCode,
	)
	var i User
	err := row.Scan(
		&i.ID,
		&i.AccessHash,
		&i.Phone,
		&i.FirstName,
		&i.LastName,
		&i.Username,
		&i.CountryCode,
		&i.CreatedAt,
		&i.UpdatedAt,
		&i.Verified,
		&i.Support,
		&i.About,
		&i.LastSeenAt,
	)
	return i, err
}

const getUserByID = `-- name: GetUserByID :one
SELECT id, access_hash, phone, first_name, last_name, username, country_code, created_at, updated_at, verified, support, about, last_seen_at FROM users WHERE id = $1
`

func (q *Queries) GetUserByID(ctx context.Context, id int64) (User, error) {
	row := q.db.QueryRow(ctx, getUserByID, id)
	var i User
	err := row.Scan(
		&i.ID,
		&i.AccessHash,
		&i.Phone,
		&i.FirstName,
		&i.LastName,
		&i.Username,
		&i.CountryCode,
		&i.CreatedAt,
		&i.UpdatedAt,
		&i.Verified,
		&i.Support,
		&i.About,
		&i.LastSeenAt,
	)
	return i, err
}

const getUserByPhone = `-- name: GetUserByPhone :one
SELECT id, access_hash, phone, first_name, last_name, username, country_code, created_at, updated_at, verified, support, about, last_seen_at FROM users WHERE phone = $1
`

func (q *Queries) GetUserByPhone(ctx context.Context, phone string) (User, error) {
	row := q.db.QueryRow(ctx, getUserByPhone, phone)
	var i User
	err := row.Scan(
		&i.ID,
		&i.AccessHash,
		&i.Phone,
		&i.FirstName,
		&i.LastName,
		&i.Username,
		&i.CountryCode,
		&i.CreatedAt,
		&i.UpdatedAt,
		&i.Verified,
		&i.Support,
		&i.About,
		&i.LastSeenAt,
	)
	return i, err
}

const getUserByUsername = `-- name: GetUserByUsername :one
SELECT id, access_hash, phone, first_name, last_name, username, country_code, created_at, updated_at, verified, support, about, last_seen_at FROM users WHERE lower(username) = lower($1) AND username <> ''
`

func (q *Queries) GetUserByUsername(ctx context.Context, lower string) (User, error) {
	row := q.db.QueryRow(ctx, getUserByUsername, lower)
	var i User
	err := row.Scan(
		&i.ID,
		&i.AccessHash,
		&i.Phone,
		&i.FirstName,
		&i.LastName,
		&i.Username,
		&i.CountryCode,
		&i.CreatedAt,
		&i.UpdatedAt,
		&i.Verified,
		&i.Support,
		&i.About,
		&i.LastSeenAt,
	)
	return i, err
}

const getUsersByIDs = `-- name: GetUsersByIDs :many
SELECT id, access_hash, phone, first_name, last_name, username, country_code, created_at, updated_at, verified, support, about, last_seen_at
FROM users
WHERE id = ANY($1::bigint[])
ORDER BY id
`

func (q *Queries) GetUsersByIDs(ctx context.Context, ids []int64) ([]User, error) {
	rows, err := q.db.Query(ctx, getUsersByIDs, ids)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []User
	for rows.Next() {
		var i User
		if err := rows.Scan(
			&i.ID,
			&i.AccessHash,
			&i.Phone,
			&i.FirstName,
			&i.LastName,
			&i.Username,
			&i.CountryCode,
			&i.CreatedAt,
			&i.UpdatedAt,
			&i.Verified,
			&i.Support,
			&i.About,
			&i.LastSeenAt,
		); err != nil {
			return nil, err
		}
		items = append(items, i)
	}
	if err := rows.Err(); err != nil {
		return nil, err
	}
	return items, nil
}

const getUsersByPhones = `-- name: GetUsersByPhones :many
SELECT id, access_hash, phone, first_name, last_name, username, country_code, created_at, updated_at, verified, support, about, last_seen_at
FROM users
WHERE phone = ANY($1::text[])
ORDER BY id
`

func (q *Queries) GetUsersByPhones(ctx context.Context, phones []string) ([]User, error) {
	rows, err := q.db.Query(ctx, getUsersByPhones, phones)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []User
	for rows.Next() {
		var i User
		if err := rows.Scan(
			&i.ID,
			&i.AccessHash,
			&i.Phone,
			&i.FirstName,
			&i.LastName,
			&i.Username,
			&i.CountryCode,
			&i.CreatedAt,
			&i.UpdatedAt,
			&i.Verified,
			&i.Support,
			&i.About,
			&i.LastSeenAt,
		); err != nil {
			return nil, err
		}
		items = append(items, i)
	}
	if err := rows.Err(); err != nil {
		return nil, err
	}
	return items, nil
}

const searchUsers = `-- name: SearchUsers :many
WITH matched AS (
  SELECT
    u.id,
    u.access_hash,
    COALESCE(NULLIF(c.contact_phone, ''), u.phone)::text AS phone,
    COALESCE(NULLIF(c.contact_first_name, ''), u.first_name)::text AS first_name,
    COALESCE(c.contact_last_name, u.last_name)::text AS last_name,
    u.about,
    u.username,
    u.country_code,
    u.verified,
    u.support,
    u.last_seen_at,
    (c.contact_user_id IS NOT NULL)::boolean AS contact,
    COALESCE(c.mutual, false)::boolean AS mutual,
    CASE
      WHEN $2::text <> '' AND u.phone = $2::text THEN 0
      WHEN lower(u.username) = $3::text THEN 1
      WHEN lower(COALESCE(NULLIF(c.contact_first_name, ''), u.first_name)) = $3::text THEN 2
      WHEN lower(u.first_name) = $3::text THEN 3
      WHEN c.contact_user_id IS NOT NULL THEN 4
      ELSE 5
    END AS rank
  FROM users u
  LEFT JOIN contacts c ON c.user_id = $4::bigint AND c.contact_user_id = u.id
  WHERE u.id <> $4::bigint
    AND $3::text <> ''
    AND (
      ($2::text <> '' AND u.phone LIKE $2::text || '%')
      OR lower(u.username) LIKE $5::text || '%' ESCAPE '\'
      OR lower(u.first_name) LIKE '%' || $5::text || '%' ESCAPE '\'
      OR lower(u.last_name) LIKE '%' || $5::text || '%' ESCAPE '\'
      OR lower(trim(u.first_name || ' ' || u.last_name)) LIKE '%' || $5::text || '%' ESCAPE '\'
      OR lower(c.contact_first_name) LIKE '%' || $5::text || '%' ESCAPE '\'
      OR lower(c.contact_last_name) LIKE '%' || $5::text || '%' ESCAPE '\'
      OR lower(trim(c.contact_first_name || ' ' || c.contact_last_name)) LIKE '%' || $5::text || '%' ESCAPE '\'
    )
)
SELECT
  id,
  access_hash,
  phone,
  first_name,
  last_name,
  about,
  username,
  country_code,
  verified,
  support,
  last_seen_at,
  contact,
  mutual
FROM matched
ORDER BY contact DESC, rank, id
LIMIT $1
`

type SearchUsersParams struct {
	LimitCount    int32
	PhoneQuery    string
	QueryLower    string
	CurrentUserID int64
	QueryLike     string
}

type SearchUsersRow struct {
	ID          int64
	AccessHash  int64
	Phone       string
	FirstName   string
	LastName    string
	About       string
	Username    string
	CountryCode string
	Verified    bool
	Support     bool
	LastSeenAt  int64
	Contact     bool
	Mutual      bool
}

func (q *Queries) SearchUsers(ctx context.Context, arg SearchUsersParams) ([]SearchUsersRow, error) {
	rows, err := q.db.Query(ctx, searchUsers,
		arg.LimitCount,
		arg.PhoneQuery,
		arg.QueryLower,
		arg.CurrentUserID,
		arg.QueryLike,
	)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []SearchUsersRow
	for rows.Next() {
		var i SearchUsersRow
		if err := rows.Scan(
			&i.ID,
			&i.AccessHash,
			&i.Phone,
			&i.FirstName,
			&i.LastName,
			&i.About,
			&i.Username,
			&i.CountryCode,
			&i.Verified,
			&i.Support,
			&i.LastSeenAt,
			&i.Contact,
			&i.Mutual,
		); err != nil {
			return nil, err
		}
		items = append(items, i)
	}
	if err := rows.Err(); err != nil {
		return nil, err
	}
	return items, nil
}

const updateUserLastSeen = `-- name: UpdateUserLastSeen :exec
UPDATE users
SET last_seen_at = GREATEST(last_seen_at, $1::bigint),
    updated_at = now()
WHERE id = $2::bigint
`

type UpdateUserLastSeenParams struct {
	LastSeenAt int64
	ID         int64
}

func (q *Queries) UpdateUserLastSeen(ctx context.Context, arg UpdateUserLastSeenParams) error {
	_, err := q.db.Exec(ctx, updateUserLastSeen, arg.LastSeenAt, arg.ID)
	return err
}

const updateUserProfile = `-- name: UpdateUserProfile :one
UPDATE users
SET first_name = $2,
    last_name = $3,
    about = $4,
    updated_at = now()
WHERE id = $1
RETURNING id, access_hash, phone, first_name, last_name, username, country_code, created_at, updated_at, verified, support, about, last_seen_at
`

type UpdateUserProfileParams struct {
	ID        int64
	FirstName string
	LastName  string
	About     string
}

func (q *Queries) UpdateUserProfile(ctx context.Context, arg UpdateUserProfileParams) (User, error) {
	row := q.db.QueryRow(ctx, updateUserProfile,
		arg.ID,
		arg.FirstName,
		arg.LastName,
		arg.About,
	)
	var i User
	err := row.Scan(
		&i.ID,
		&i.AccessHash,
		&i.Phone,
		&i.FirstName,
		&i.LastName,
		&i.Username,
		&i.CountryCode,
		&i.CreatedAt,
		&i.UpdatedAt,
		&i.Verified,
		&i.Support,
		&i.About,
		&i.LastSeenAt,
	)
	return i, err
}

const updateUserUsername = `-- name: UpdateUserUsername :one
UPDATE users
SET username = $2,
    updated_at = now()
WHERE id = $1
RETURNING id, access_hash, phone, first_name, last_name, username, country_code, created_at, updated_at, verified, support, about, last_seen_at
`

type UpdateUserUsernameParams struct {
	ID       int64
	Username string
}

func (q *Queries) UpdateUserUsername(ctx context.Context, arg UpdateUserUsernameParams) (User, error) {
	row := q.db.QueryRow(ctx, updateUserUsername, arg.ID, arg.Username)
	var i User
	err := row.Scan(
		&i.ID,
		&i.AccessHash,
		&i.Phone,
		&i.FirstName,
		&i.LastName,
		&i.Username,
		&i.CountryCode,
		&i.CreatedAt,
		&i.UpdatedAt,
		&i.Verified,
		&i.Support,
		&i.About,
		&i.LastSeenAt,
	)
	return i, err
}