// Code generated by sqlc. DO NOT EDIT.
// versions:
//   sqlc v1.29.0
// source: market_settings.sql

package dbgen

import (
	"context"

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

const DeleteAllMarketSettingsForCompany = `-- name: DeleteAllMarketSettingsForCompany :exec
DELETE FROM company_odd_market_settings
WHERE company_id = $1
`

func (q *Queries) DeleteAllMarketSettingsForCompany(ctx context.Context, companyID int64) error {
	_, err := q.db.Exec(ctx, DeleteAllMarketSettingsForCompany, companyID)
	return err
}

const DeleteCompanyMarketSettings = `-- name: DeleteCompanyMarketSettings :exec
DELETE FROM company_odd_market_settings
WHERE market_id = $1
    AND company_id = $2
`

type DeleteCompanyMarketSettingsParams struct {
	MarketID  int64 `json:"market_id"`
	CompanyID int64 `json:"company_id"`
}

func (q *Queries) DeleteCompanyMarketSettings(ctx context.Context, arg DeleteCompanyMarketSettingsParams) error {
	_, err := q.db.Exec(ctx, DeleteCompanyMarketSettings, arg.MarketID, arg.CompanyID)
	return err
}

const GetAllCompanyMarketSettings = `-- name: GetAllCompanyMarketSettings :many
SELECT market_id, market_name, company_id, is_active, updated_at
FROM company_odd_market_settings
WHERE (
        company_id = $1
        OR $1 IS NULL
    )
LIMIT $3 OFFSET $2
`

type GetAllCompanyMarketSettingsParams struct {
	CompanyID pgtype.Int8 `json:"company_id"`
	Offset    pgtype.Int4 `json:"offset"`
	Limit     pgtype.Int4 `json:"limit"`
}

func (q *Queries) GetAllCompanyMarketSettings(ctx context.Context, arg GetAllCompanyMarketSettingsParams) ([]CompanyOddMarketSetting, error) {
	rows, err := q.db.Query(ctx, GetAllCompanyMarketSettings, arg.CompanyID, arg.Offset, arg.Limit)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []CompanyOddMarketSetting
	for rows.Next() {
		var i CompanyOddMarketSetting
		if err := rows.Scan(
			&i.MarketID,
			&i.MarketName,
			&i.CompanyID,
			&i.IsActive,
			&i.UpdatedAt,
		); err != nil {
			return nil, err
		}
		items = append(items, i)
	}
	if err := rows.Err(); err != nil {
		return nil, err
	}
	return items, nil
}

const GetAllGlobalMarketSettings = `-- name: GetAllGlobalMarketSettings :many
SELECT market_id, market_name, is_active, updated_at
FROM global_odd_market_settings
LIMIT $2 OFFSET $1
`

type GetAllGlobalMarketSettingsParams struct {
	Offset pgtype.Int4 `json:"offset"`
	Limit  pgtype.Int4 `json:"limit"`
}

func (q *Queries) GetAllGlobalMarketSettings(ctx context.Context, arg GetAllGlobalMarketSettingsParams) ([]GlobalOddMarketSetting, error) {
	rows, err := q.db.Query(ctx, GetAllGlobalMarketSettings, arg.Offset, arg.Limit)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []GlobalOddMarketSetting
	for rows.Next() {
		var i GlobalOddMarketSetting
		if err := rows.Scan(
			&i.MarketID,
			&i.MarketName,
			&i.IsActive,
			&i.UpdatedAt,
		); err != nil {
			return nil, err
		}
		items = append(items, i)
	}
	if err := rows.Err(); err != nil {
		return nil, err
	}
	return items, nil
}

const GetAllOverrideMarketSettings = `-- name: GetAllOverrideMarketSettings :many
SELECT gdm.market_id,
    gdm.market_name,
    COALESCE(cdm.is_active, gdm.is_active) AS is_active,
    COALESCE(cdm.updated_at, gdm.updated_at) AS updated_at
FROM global_odd_market_settings gdm
    LEFT JOIN company_odd_market_settings cdm ON cdm.market_id = gdm.market_id
    AND company_id = $1
LIMIT $3 OFFSET $2
`

type GetAllOverrideMarketSettingsParams struct {
	CompanyID int64       `json:"company_id"`
	Offset    pgtype.Int4 `json:"offset"`
	Limit     pgtype.Int4 `json:"limit"`
}

type GetAllOverrideMarketSettingsRow struct {
	MarketID   int64            `json:"market_id"`
	MarketName string           `json:"market_name"`
	IsActive   bool             `json:"is_active"`
	UpdatedAt  pgtype.Timestamp `json:"updated_at"`
}

func (q *Queries) GetAllOverrideMarketSettings(ctx context.Context, arg GetAllOverrideMarketSettingsParams) ([]GetAllOverrideMarketSettingsRow, error) {
	rows, err := q.db.Query(ctx, GetAllOverrideMarketSettings, arg.CompanyID, arg.Offset, arg.Limit)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []GetAllOverrideMarketSettingsRow
	for rows.Next() {
		var i GetAllOverrideMarketSettingsRow
		if err := rows.Scan(
			&i.MarketID,
			&i.MarketName,
			&i.IsActive,
			&i.UpdatedAt,
		); err != nil {
			return nil, err
		}
		items = append(items, i)
	}
	if err := rows.Err(); err != nil {
		return nil, err
	}
	return items, nil
}

const GetCompanyMarketSettingsByID = `-- name: GetCompanyMarketSettingsByID :one
SELECT market_id, market_name, company_id, is_active, updated_at
FROM company_odd_market_settings
WHERE market_id = $1
`

func (q *Queries) GetCompanyMarketSettingsByID(ctx context.Context, marketID int64) (CompanyOddMarketSetting, error) {
	row := q.db.QueryRow(ctx, GetCompanyMarketSettingsByID, marketID)
	var i CompanyOddMarketSetting
	err := row.Scan(
		&i.MarketID,
		&i.MarketName,
		&i.CompanyID,
		&i.IsActive,
		&i.UpdatedAt,
	)
	return i, err
}

const GetGlobalMarketSettingsByID = `-- name: GetGlobalMarketSettingsByID :one
SELECT market_id, market_name, is_active, updated_at
FROM global_odd_market_settings
WHERE market_id = $1
`

func (q *Queries) GetGlobalMarketSettingsByID(ctx context.Context, marketID int64) (GlobalOddMarketSetting, error) {
	row := q.db.QueryRow(ctx, GetGlobalMarketSettingsByID, marketID)
	var i GlobalOddMarketSetting
	err := row.Scan(
		&i.MarketID,
		&i.MarketName,
		&i.IsActive,
		&i.UpdatedAt,
	)
	return i, err
}

const GetOverrideMarketSettingByID = `-- name: GetOverrideMarketSettingByID :one
SELECT gdm.market_id,
    gdm.market_name,
    COALESCE(cdm.is_active, gdm.is_active) AS is_active,
    COALESCE(cdm.updated_at, gdm.updated_at) AS updated_at
FROM global_odd_market_settings gdm
    LEFT JOIN company_odd_market_settings cdm ON cdm.market_id = gdm.market_id
    AND company_id = $1
WHERE gdm.market_id = $2
`

type GetOverrideMarketSettingByIDParams struct {
	CompanyID int64 `json:"company_id"`
	MarketID  int64 `json:"market_id"`
}

type GetOverrideMarketSettingByIDRow struct {
	MarketID   int64            `json:"market_id"`
	MarketName string           `json:"market_name"`
	IsActive   bool             `json:"is_active"`
	UpdatedAt  pgtype.Timestamp `json:"updated_at"`
}

func (q *Queries) GetOverrideMarketSettingByID(ctx context.Context, arg GetOverrideMarketSettingByIDParams) (GetOverrideMarketSettingByIDRow, error) {
	row := q.db.QueryRow(ctx, GetOverrideMarketSettingByID, arg.CompanyID, arg.MarketID)
	var i GetOverrideMarketSettingByIDRow
	err := row.Scan(
		&i.MarketID,
		&i.MarketName,
		&i.IsActive,
		&i.UpdatedAt,
	)
	return i, err
}

const InsertCompanyMarketSettings = `-- name: InsertCompanyMarketSettings :exec
INSERT INTO company_odd_market_settings (company_id, market_id, market_name, is_active)
VALUES ($1, $2, $3, $4) ON CONFLICT (company_id, market_id) DO
UPDATE
SET is_active = EXCLUDED.is_active,
    updated_at = CURRENT_TIMESTAMP
`

type InsertCompanyMarketSettingsParams struct {
	CompanyID  int64       `json:"company_id"`
	MarketID   int64       `json:"market_id"`
	MarketName string      `json:"market_name"`
	IsActive   pgtype.Bool `json:"is_active"`
}

func (q *Queries) InsertCompanyMarketSettings(ctx context.Context, arg InsertCompanyMarketSettingsParams) error {
	_, err := q.db.Exec(ctx, InsertCompanyMarketSettings,
		arg.CompanyID,
		arg.MarketID,
		arg.MarketName,
		arg.IsActive,
	)
	return err
}

const InsertGlobalMarketSettings = `-- name: InsertGlobalMarketSettings :exec
INSERT INTO global_odd_market_settings (market_id, market_name, is_active)
VALUES ($1, $2, $3) ON CONFLICT (market_id) DO
UPDATE
SET is_active = EXCLUDED.is_active,
    updated_at = CURRENT_TIMESTAMP
`

type InsertGlobalMarketSettingsParams struct {
	MarketID   int64  `json:"market_id"`
	MarketName string `json:"market_name"`
	IsActive   bool   `json:"is_active"`
}

func (q *Queries) InsertGlobalMarketSettings(ctx context.Context, arg InsertGlobalMarketSettingsParams) error {
	_, err := q.db.Exec(ctx, InsertGlobalMarketSettings, arg.MarketID, arg.MarketName, arg.IsActive)
	return err
}