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

package generated

import (
	"context"

	"github.com/jackc/pgx/v5/pgtype"
)

const createPrecoEvento = `-- name: CreatePrecoEvento :one
INSERT INTO precos_tipos_eventos (tipo_evento_id, funcao_profissional_id, valor, regiao) 
VALUES ($1, $2, $3, $4) 
ON CONFLICT (tipo_evento_id, funcao_profissional_id, regiao) DO UPDATE 
SET valor = $3
RETURNING id, tipo_evento_id, funcao_profissional_id, valor, regiao, criado_em
`

type CreatePrecoEventoParams struct {
	TipoEventoID         pgtype.UUID    `json:"tipo_evento_id"`
	FuncaoProfissionalID pgtype.UUID    `json:"funcao_profissional_id"`
	Valor                pgtype.Numeric `json:"valor"`
	Regiao               pgtype.Text    `json:"regiao"`
}

func (q *Queries) CreatePrecoEvento(ctx context.Context, arg CreatePrecoEventoParams) (PrecosTiposEvento, error) {
	row := q.db.QueryRow(ctx, createPrecoEvento,
		arg.TipoEventoID,
		arg.FuncaoProfissionalID,
		arg.Valor,
		arg.Regiao,
	)
	var i PrecosTiposEvento
	err := row.Scan(
		&i.ID,
		&i.TipoEventoID,
		&i.FuncaoProfissionalID,
		&i.Valor,
		&i.Regiao,
		&i.CriadoEm,
	)
	return i, err
}

const createTipoEvento = `-- name: CreateTipoEvento :one
INSERT INTO tipos_eventos (nome, regiao) VALUES ($1, $2) RETURNING id, nome, criado_em, regiao
`

type CreateTipoEventoParams struct {
	Nome   string      `json:"nome"`
	Regiao pgtype.Text `json:"regiao"`
}

func (q *Queries) CreateTipoEvento(ctx context.Context, arg CreateTipoEventoParams) (TiposEvento, error) {
	row := q.db.QueryRow(ctx, createTipoEvento, arg.Nome, arg.Regiao)
	var i TiposEvento
	err := row.Scan(
		&i.ID,
		&i.Nome,
		&i.CriadoEm,
		&i.Regiao,
	)
	return i, err
}

const deletePreco = `-- name: DeletePreco :exec
DELETE FROM precos_tipos_eventos WHERE id = $1
`

func (q *Queries) DeletePreco(ctx context.Context, id pgtype.UUID) error {
	_, err := q.db.Exec(ctx, deletePreco, id)
	return err
}

const deleteTipoEvento = `-- name: DeleteTipoEvento :exec
DELETE FROM tipos_eventos WHERE id = $1 AND regiao = $2
`

type DeleteTipoEventoParams struct {
	ID     pgtype.UUID `json:"id"`
	Regiao pgtype.Text `json:"regiao"`
}

func (q *Queries) DeleteTipoEvento(ctx context.Context, arg DeleteTipoEventoParams) error {
	_, err := q.db.Exec(ctx, deleteTipoEvento, arg.ID, arg.Regiao)
	return err
}

const getPreco = `-- name: GetPreco :one
SELECT id, tipo_evento_id, funcao_profissional_id, valor, regiao, criado_em FROM precos_tipos_eventos WHERE tipo_evento_id = $1 AND funcao_profissional_id = $2 AND regiao = $3
`

type GetPrecoParams struct {
	TipoEventoID         pgtype.UUID `json:"tipo_evento_id"`
	FuncaoProfissionalID pgtype.UUID `json:"funcao_profissional_id"`
	Regiao               pgtype.Text `json:"regiao"`
}

func (q *Queries) GetPreco(ctx context.Context, arg GetPrecoParams) (PrecosTiposEvento, error) {
	row := q.db.QueryRow(ctx, getPreco, arg.TipoEventoID, arg.FuncaoProfissionalID, arg.Regiao)
	var i PrecosTiposEvento
	err := row.Scan(
		&i.ID,
		&i.TipoEventoID,
		&i.FuncaoProfissionalID,
		&i.Valor,
		&i.Regiao,
		&i.CriadoEm,
	)
	return i, err
}

const getStandardPrice = `-- name: GetStandardPrice :one
SELECT p.valor
FROM precos_tipos_eventos p
JOIN tipos_eventos te ON p.tipo_evento_id = te.id
JOIN funcoes_profissionais f ON p.funcao_profissional_id = f.id
WHERE te.nome ILIKE $1 
  AND f.nome ILIKE $2 
  AND te.regiao = $3
  AND p.regiao = $3
ORDER BY p.criado_em DESC
LIMIT 1
`

type GetStandardPriceParams struct {
	Nome   string      `json:"nome"`
	Nome_2 string      `json:"nome_2"`
	Regiao pgtype.Text `json:"regiao"`
}

func (q *Queries) GetStandardPrice(ctx context.Context, arg GetStandardPriceParams) (pgtype.Numeric, error) {
	row := q.db.QueryRow(ctx, getStandardPrice, arg.Nome, arg.Nome_2, arg.Regiao)
	var valor pgtype.Numeric
	err := row.Scan(&valor)
	return valor, err
}

const getTipoEventoByID = `-- name: GetTipoEventoByID :one
SELECT id, nome, criado_em, regiao FROM tipos_eventos WHERE id = $1 AND regiao = $2
`

type GetTipoEventoByIDParams struct {
	ID     pgtype.UUID `json:"id"`
	Regiao pgtype.Text `json:"regiao"`
}

func (q *Queries) GetTipoEventoByID(ctx context.Context, arg GetTipoEventoByIDParams) (TiposEvento, error) {
	row := q.db.QueryRow(ctx, getTipoEventoByID, arg.ID, arg.Regiao)
	var i TiposEvento
	err := row.Scan(
		&i.ID,
		&i.Nome,
		&i.CriadoEm,
		&i.Regiao,
	)
	return i, err
}

const getTipoEventoByNome = `-- name: GetTipoEventoByNome :one
SELECT id, nome, criado_em, regiao FROM tipos_eventos WHERE nome = $1 AND regiao = $2
`

type GetTipoEventoByNomeParams struct {
	Nome   string      `json:"nome"`
	Regiao pgtype.Text `json:"regiao"`
}

func (q *Queries) GetTipoEventoByNome(ctx context.Context, arg GetTipoEventoByNomeParams) (TiposEvento, error) {
	row := q.db.QueryRow(ctx, getTipoEventoByNome, arg.Nome, arg.Regiao)
	var i TiposEvento
	err := row.Scan(
		&i.ID,
		&i.Nome,
		&i.CriadoEm,
		&i.Regiao,
	)
	return i, err
}

const listPrecosByEventoID = `-- name: ListPrecosByEventoID :many
SELECT p.id, p.tipo_evento_id, p.funcao_profissional_id, p.valor, p.regiao, p.criado_em, f.nome as funcao_nome 
FROM precos_tipos_eventos p
JOIN funcoes_profissionais f ON p.funcao_profissional_id = f.id
WHERE p.tipo_evento_id = $1
`

type ListPrecosByEventoIDRow struct {
	ID                   pgtype.UUID        `json:"id"`
	TipoEventoID         pgtype.UUID        `json:"tipo_evento_id"`
	FuncaoProfissionalID pgtype.UUID        `json:"funcao_profissional_id"`
	Valor                pgtype.Numeric     `json:"valor"`
	Regiao               pgtype.Text        `json:"regiao"`
	CriadoEm             pgtype.Timestamptz `json:"criado_em"`
	FuncaoNome           string             `json:"funcao_nome"`
}

func (q *Queries) ListPrecosByEventoID(ctx context.Context, tipoEventoID pgtype.UUID) ([]ListPrecosByEventoIDRow, error) {
	rows, err := q.db.Query(ctx, listPrecosByEventoID, tipoEventoID)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []ListPrecosByEventoIDRow
	for rows.Next() {
		var i ListPrecosByEventoIDRow
		if err := rows.Scan(
			&i.ID,
			&i.TipoEventoID,
			&i.FuncaoProfissionalID,
			&i.Valor,
			&i.Regiao,
			&i.CriadoEm,
			&i.FuncaoNome,
		); err != nil {
			return nil, err
		}
		items = append(items, i)
	}
	if err := rows.Err(); err != nil {
		return nil, err
	}
	return items, nil
}

const listTiposEventos = `-- name: ListTiposEventos :many
SELECT id, nome, criado_em, regiao FROM tipos_eventos WHERE regiao = $1 ORDER BY nome
`

func (q *Queries) ListTiposEventos(ctx context.Context, regiao pgtype.Text) ([]TiposEvento, error) {
	rows, err := q.db.Query(ctx, listTiposEventos, regiao)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []TiposEvento
	for rows.Next() {
		var i TiposEvento
		if err := rows.Scan(
			&i.ID,
			&i.Nome,
			&i.CriadoEm,
			&i.Regiao,
		); err != nil {
			return nil, err
		}
		items = append(items, i)
	}
	if err := rows.Err(); err != nil {
		return nil, err
	}
	return items, nil
}

const updateTipoEvento = `-- name: UpdateTipoEvento :one
UPDATE tipos_eventos SET nome = $2 WHERE id = $1 AND regiao = $3 RETURNING id, nome, criado_em, regiao
`

type UpdateTipoEventoParams struct {
	ID     pgtype.UUID `json:"id"`
	Nome   string      `json:"nome"`
	Regiao pgtype.Text `json:"regiao"`
}

func (q *Queries) UpdateTipoEvento(ctx context.Context, arg UpdateTipoEventoParams) (TiposEvento, error) {
	row := q.db.QueryRow(ctx, updateTipoEvento, arg.ID, arg.Nome, arg.Regiao)
	var i TiposEvento
	err := row.Scan(
		&i.ID,
		&i.Nome,
		&i.CriadoEm,
		&i.Regiao,
	)
	return i, err
}
