// Code generated by sqlc. DO NOT EDIT.
// versions:
//   sqlc v1.30.0
// source: voice.sql

package dbgen

import (
	"context"
	"database/sql"
)

const clearAllVoiceStates = `-- name: ClearAllVoiceStates :exec
DELETE FROM voice_states
`

func (q *Queries) ClearAllVoiceStates(ctx context.Context) error {
	_, err := q.db.ExecContext(ctx, clearAllVoiceStates)
	return err
}

const clearVoiceState = `-- name: ClearVoiceState :exec
DELETE FROM voice_states WHERE user_id = ?
`

func (q *Queries) ClearVoiceState(ctx context.Context, userID int64) error {
	_, err := q.db.ExecContext(ctx, clearVoiceState, userID)
	return err
}

const countActiveCameras = `-- name: CountActiveCameras :one
SELECT COUNT(*) FROM voice_states WHERE channel_id = ? AND camera = 1
`

func (q *Queries) CountActiveCameras(ctx context.Context, channelID int64) (int64, error) {
	row := q.db.QueryRowContext(ctx, countActiveCameras, channelID)
	var count int64
	err := row.Scan(&count)
	return count, err
}

const enableCameraIfUnderLimit = `-- name: EnableCameraIfUnderLimit :execresult
UPDATE voice_states SET camera = 1
WHERE voice_states.user_id = ? AND voice_states.channel_id = ?
  AND (SELECT COUNT(*) FROM voice_states AS vs2 WHERE vs2.channel_id = ? AND vs2.camera = 1) < ?
`

type EnableCameraIfUnderLimitParams struct {
	UserID      int64 `json:"userId"`
	ChannelID   int64 `json:"channelId"`
	ChannelID_2 int64 `json:"channelId2"`
	ChannelID_3 int64 `json:"channelId3"`
}

func (q *Queries) EnableCameraIfUnderLimit(ctx context.Context, arg EnableCameraIfUnderLimitParams) (sql.Result, error) {
	return q.db.ExecContext(ctx, enableCameraIfUnderLimit,
		arg.UserID,
		arg.ChannelID,
		arg.ChannelID_2,
		arg.ChannelID_3,
	)
}

const getAllVoiceStates = `-- name: GetAllVoiceStates :many
SELECT vs.user_id, vs.channel_id, u.username,
       vs.muted, vs.deafened, vs.speaking,
       vs.camera, vs.screenshare, vs.joined_at
FROM voice_states vs
JOIN users u ON u.id = vs.user_id
ORDER BY vs.channel_id, vs.joined_at ASC
`

type GetAllVoiceStatesRow struct {
	UserID      int64  `json:"userId"`
	ChannelID   int64  `json:"channelId"`
	Username    string `json:"username"`
	Muted       int64  `json:"muted"`
	Deafened    int64  `json:"deafened"`
	Speaking    int64  `json:"speaking"`
	Camera      int64  `json:"camera"`
	Screenshare int64  `json:"screenshare"`
	JoinedAt    string `json:"joinedAt"`
}

func (q *Queries) GetAllVoiceStates(ctx context.Context) ([]GetAllVoiceStatesRow, error) {
	rows, err := q.db.QueryContext(ctx, getAllVoiceStates)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	items := []GetAllVoiceStatesRow{}
	for rows.Next() {
		var i GetAllVoiceStatesRow
		if err := rows.Scan(
			&i.UserID,
			&i.ChannelID,
			&i.Username,
			&i.Muted,
			&i.Deafened,
			&i.Speaking,
			&i.Camera,
			&i.Screenshare,
			&i.JoinedAt,
		); err != nil {
			return nil, err
		}
		items = append(items, i)
	}
	if err := rows.Close(); err != nil {
		return nil, err
	}
	if err := rows.Err(); err != nil {
		return nil, err
	}
	return items, nil
}

const getChannelVoiceStates = `-- name: GetChannelVoiceStates :many
SELECT vs.user_id, vs.channel_id, u.username,
       vs.muted, vs.deafened, vs.speaking,
       vs.camera, vs.screenshare, vs.joined_at
FROM voice_states vs
JOIN users u ON u.id = vs.user_id
WHERE vs.channel_id = ?
ORDER BY vs.joined_at ASC
`

type GetChannelVoiceStatesRow struct {
	UserID      int64  `json:"userId"`
	ChannelID   int64  `json:"channelId"`
	Username    string `json:"username"`
	Muted       int64  `json:"muted"`
	Deafened    int64  `json:"deafened"`
	Speaking    int64  `json:"speaking"`
	Camera      int64  `json:"camera"`
	Screenshare int64  `json:"screenshare"`
	JoinedAt    string `json:"joinedAt"`
}

func (q *Queries) GetChannelVoiceStates(ctx context.Context, channelID int64) ([]GetChannelVoiceStatesRow, error) {
	rows, err := q.db.QueryContext(ctx, getChannelVoiceStates, channelID)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	items := []GetChannelVoiceStatesRow{}
	for rows.Next() {
		var i GetChannelVoiceStatesRow
		if err := rows.Scan(
			&i.UserID,
			&i.ChannelID,
			&i.Username,
			&i.Muted,
			&i.Deafened,
			&i.Speaking,
			&i.Camera,
			&i.Screenshare,
			&i.JoinedAt,
		); err != nil {
			return nil, err
		}
		items = append(items, i)
	}
	if err := rows.Close(); err != nil {
		return nil, err
	}
	if err := rows.Err(); err != nil {
		return nil, err
	}
	return items, nil
}

const getUserVoiceState = `-- name: GetUserVoiceState :one
SELECT vs.user_id, vs.channel_id, u.username,
       vs.muted, vs.deafened, vs.speaking,
       vs.camera, vs.screenshare, vs.joined_at
FROM voice_states vs
JOIN users u ON u.id = vs.user_id
WHERE vs.user_id = ?
`

type GetUserVoiceStateRow struct {
	UserID      int64  `json:"userId"`
	ChannelID   int64  `json:"channelId"`
	Username    string `json:"username"`
	Muted       int64  `json:"muted"`
	Deafened    int64  `json:"deafened"`
	Speaking    int64  `json:"speaking"`
	Camera      int64  `json:"camera"`
	Screenshare int64  `json:"screenshare"`
	JoinedAt    string `json:"joinedAt"`
}

func (q *Queries) GetUserVoiceState(ctx context.Context, userID int64) (GetUserVoiceStateRow, error) {
	row := q.db.QueryRowContext(ctx, getUserVoiceState, userID)
	var i GetUserVoiceStateRow
	err := row.Scan(
		&i.UserID,
		&i.ChannelID,
		&i.Username,
		&i.Muted,
		&i.Deafened,
		&i.Speaking,
		&i.Camera,
		&i.Screenshare,
		&i.JoinedAt,
	)
	return i, err
}

const joinVoiceChannel = `-- name: JoinVoiceChannel :exec
INSERT INTO voice_states (user_id, channel_id, muted, deafened, speaking, camera, screenshare, joined_at)
VALUES (?, ?, 0, 0, 0, 0, 0, ?)
ON CONFLICT(user_id) DO UPDATE SET
    channel_id  = excluded.channel_id,
    muted       = 0,
    deafened    = 0,
    speaking    = 0,
    camera      = 0,
    screenshare = 0,
    joined_at   = excluded.joined_at
`

type JoinVoiceChannelParams struct {
	UserID    int64  `json:"userId"`
	ChannelID int64  `json:"channelId"`
	JoinedAt  string `json:"joinedAt"`
}

func (q *Queries) JoinVoiceChannel(ctx context.Context, arg JoinVoiceChannelParams) error {
	_, err := q.db.ExecContext(ctx, joinVoiceChannel, arg.UserID, arg.ChannelID, arg.JoinedAt)
	return err
}

const joinVoiceChannelIfCapacity = `-- name: JoinVoiceChannelIfCapacity :execresult
INSERT INTO voice_states (user_id, channel_id, muted, deafened, speaking, camera, screenshare, joined_at)
SELECT ?, ?, 0, 0, 0, 0, 0, ?
WHERE (SELECT COUNT(*) FROM voice_states AS vs2 WHERE vs2.channel_id = ?) < ?
ON CONFLICT(user_id) DO UPDATE SET
    channel_id  = excluded.channel_id,
    muted       = 0,
    deafened    = 0,
    speaking    = 0,
    camera      = 0,
    screenshare = 0,
    joined_at   = excluded.joined_at
`

type JoinVoiceChannelIfCapacityParams struct {
	UserID      int64  `json:"userId"`
	ChannelID   int64  `json:"channelId"`
	JoinedAt    string `json:"joinedAt"`
	ChannelID_2 int64  `json:"channelId2"`
	ChannelID_3 int64  `json:"channelId3"`
}

func (q *Queries) JoinVoiceChannelIfCapacity(ctx context.Context, arg JoinVoiceChannelIfCapacityParams) (sql.Result, error) {
	return q.db.ExecContext(ctx, joinVoiceChannelIfCapacity,
		arg.UserID,
		arg.ChannelID,
		arg.JoinedAt,
		arg.ChannelID_2,
		arg.ChannelID_3,
	)
}

const leaveVoiceChannel = `-- name: LeaveVoiceChannel :exec
DELETE FROM voice_states WHERE user_id = ?
`

func (q *Queries) LeaveVoiceChannel(ctx context.Context, userID int64) error {
	_, err := q.db.ExecContext(ctx, leaveVoiceChannel, userID)
	return err
}

const leaveVoiceChannelIfMatch = `-- name: LeaveVoiceChannelIfMatch :execresult
DELETE FROM voice_states WHERE user_id = ? AND channel_id = ? AND joined_at = ?
`

type LeaveVoiceChannelIfMatchParams struct {
	UserID    int64  `json:"userId"`
	ChannelID int64  `json:"channelId"`
	JoinedAt  string `json:"joinedAt"`
}

func (q *Queries) LeaveVoiceChannelIfMatch(ctx context.Context, arg LeaveVoiceChannelIfMatchParams) (sql.Result, error) {
	return q.db.ExecContext(ctx, leaveVoiceChannelIfMatch, arg.UserID, arg.ChannelID, arg.JoinedAt)
}

const updateVoiceCamera = `-- name: UpdateVoiceCamera :exec
UPDATE voice_states SET camera = ? WHERE user_id = ?
`

type UpdateVoiceCameraParams struct {
	Camera int64 `json:"camera"`
	UserID int64 `json:"userId"`
}

func (q *Queries) UpdateVoiceCamera(ctx context.Context, arg UpdateVoiceCameraParams) error {
	_, err := q.db.ExecContext(ctx, updateVoiceCamera, arg.Camera, arg.UserID)
	return err
}

const updateVoiceDeafen = `-- name: UpdateVoiceDeafen :exec
UPDATE voice_states SET deafened = ? WHERE user_id = ?
`

type UpdateVoiceDeafenParams struct {
	Deafened int64 `json:"deafened"`
	UserID   int64 `json:"userId"`
}

func (q *Queries) UpdateVoiceDeafen(ctx context.Context, arg UpdateVoiceDeafenParams) error {
	_, err := q.db.ExecContext(ctx, updateVoiceDeafen, arg.Deafened, arg.UserID)
	return err
}

const updateVoiceMute = `-- name: UpdateVoiceMute :exec
UPDATE voice_states SET muted = ? WHERE user_id = ?
`

type UpdateVoiceMuteParams struct {
	Muted  int64 `json:"muted"`
	UserID int64 `json:"userId"`
}

func (q *Queries) UpdateVoiceMute(ctx context.Context, arg UpdateVoiceMuteParams) error {
	_, err := q.db.ExecContext(ctx, updateVoiceMute, arg.Muted, arg.UserID)
	return err
}

const updateVoiceScreenshare = `-- name: UpdateVoiceScreenshare :exec
UPDATE voice_states SET screenshare = ? WHERE user_id = ?
`

type UpdateVoiceScreenshareParams struct {
	Screenshare int64 `json:"screenshare"`
	UserID      int64 `json:"userId"`
}

func (q *Queries) UpdateVoiceScreenshare(ctx context.Context, arg UpdateVoiceScreenshareParams) error {
	_, err := q.db.ExecContext(ctx, updateVoiceScreenshare, arg.Screenshare, arg.UserID)
	return err
}
