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

package dbgen

import (
	"context"

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

const DeleteAllCompanySetting = `-- name: DeleteAllCompanySetting :exec
DELETE FROM company_settings
WHERE company_id = $1
`

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

const DeleteCompanySetting = `-- name: DeleteCompanySetting :exec
DELETE FROM company_settings
WHERE company_id = $1
    AND key = $2
`

type DeleteCompanySettingParams struct {
	CompanyID int64  `json:"company_id"`
	Key       string `json:"key"`
}

func (q *Queries) DeleteCompanySetting(ctx context.Context, arg DeleteCompanySettingParams) error {
	_, err := q.db.Exec(ctx, DeleteCompanySetting, arg.CompanyID, arg.Key)
	return err
}

const GetAllCompanySettings = `-- name: GetAllCompanySettings :many
SELECT company_id, key, value, created_at, updated_at
FROM company_settings
`

func (q *Queries) GetAllCompanySettings(ctx context.Context) ([]CompanySetting, error) {
	rows, err := q.db.Query(ctx, GetAllCompanySettings)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []CompanySetting
	for rows.Next() {
		var i CompanySetting
		if err := rows.Scan(
			&i.CompanyID,
			&i.Key,
			&i.Value,
			&i.CreatedAt,
			&i.UpdatedAt,
		); err != nil {
			return nil, err
		}
		items = append(items, i)
	}
	if err := rows.Err(); err != nil {
		return nil, err
	}
	return items, nil
}

const GetCompanySetting = `-- name: GetCompanySetting :many
SELECT company_id, key, value, created_at, updated_at
FROM company_settings
WHERE company_id = $1
`

func (q *Queries) GetCompanySetting(ctx context.Context, companyID int64) ([]CompanySetting, error) {
	rows, err := q.db.Query(ctx, GetCompanySetting, companyID)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []CompanySetting
	for rows.Next() {
		var i CompanySetting
		if err := rows.Scan(
			&i.CompanyID,
			&i.Key,
			&i.Value,
			&i.CreatedAt,
			&i.UpdatedAt,
		); err != nil {
			return nil, err
		}
		items = append(items, i)
	}
	if err := rows.Err(); err != nil {
		return nil, err
	}
	return items, nil
}

const GetCompanySettingsByKey = `-- name: GetCompanySettingsByKey :many
SELECT company_id, key, value, created_at, updated_at
FROM company_settings
WHERE key = $1
`

func (q *Queries) GetCompanySettingsByKey(ctx context.Context, key string) ([]CompanySetting, error) {
	rows, err := q.db.Query(ctx, GetCompanySettingsByKey, key)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []CompanySetting
	for rows.Next() {
		var i CompanySetting
		if err := rows.Scan(
			&i.CompanyID,
			&i.Key,
			&i.Value,
			&i.CreatedAt,
			&i.UpdatedAt,
		); err != nil {
			return nil, err
		}
		items = append(items, i)
	}
	if err := rows.Err(); err != nil {
		return nil, err
	}
	return items, nil
}

const GetGlobalSetting = `-- name: GetGlobalSetting :one
SELECT key, value, created_at, updated_at
FROM global_settings
WHERE key = $1
`

func (q *Queries) GetGlobalSetting(ctx context.Context, key string) (GlobalSetting, error) {
	row := q.db.QueryRow(ctx, GetGlobalSetting, key)
	var i GlobalSetting
	err := row.Scan(
		&i.Key,
		&i.Value,
		&i.CreatedAt,
		&i.UpdatedAt,
	)
	return i, err
}

const GetGlobalSettings = `-- name: GetGlobalSettings :many
SELECT key, value, created_at, updated_at
FROM global_settings
`

func (q *Queries) GetGlobalSettings(ctx context.Context) ([]GlobalSetting, error) {
	rows, err := q.db.Query(ctx, GetGlobalSettings)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []GlobalSetting
	for rows.Next() {
		var i GlobalSetting
		if err := rows.Scan(
			&i.Key,
			&i.Value,
			&i.CreatedAt,
			&i.UpdatedAt,
		); err != nil {
			return nil, err
		}
		items = append(items, i)
	}
	if err := rows.Err(); err != nil {
		return nil, err
	}
	return items, nil
}

const GetOverrideSettings = `-- name: GetOverrideSettings :many
SELECT gs.key, gs.value, gs.created_at, gs.updated_at,
    COALESCE(cs.value, gs.value) AS value
FROM global_settings gs
    LEFT JOIN company_settings cs ON cs.key = gs.key
    AND cs.company_id = $1
`

type GetOverrideSettingsRow struct {
	Key       string           `json:"key"`
	Value     string           `json:"value"`
	CreatedAt pgtype.Timestamp `json:"created_at"`
	UpdatedAt pgtype.Timestamp `json:"updated_at"`
	Value_2   string           `json:"value_2"`
}

func (q *Queries) GetOverrideSettings(ctx context.Context, companyID int64) ([]GetOverrideSettingsRow, error) {
	rows, err := q.db.Query(ctx, GetOverrideSettings, companyID)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []GetOverrideSettingsRow
	for rows.Next() {
		var i GetOverrideSettingsRow
		if err := rows.Scan(
			&i.Key,
			&i.Value,
			&i.CreatedAt,
			&i.UpdatedAt,
			&i.Value_2,
		); err != nil {
			return nil, err
		}
		items = append(items, i)
	}
	if err := rows.Err(); err != nil {
		return nil, err
	}
	return items, nil
}

const InsertCompanySetting = `-- name: InsertCompanySetting :exec
INSERT INTO company_settings (company_id, key, value)
VALUES ($1, $2, $3) ON CONFLICT (company_id, key) DO
UPDATE
SET value = EXCLUDED.value
`

type InsertCompanySettingParams struct {
	CompanyID int64  `json:"company_id"`
	Key       string `json:"key"`
	Value     string `json:"value"`
}

func (q *Queries) InsertCompanySetting(ctx context.Context, arg InsertCompanySettingParams) error {
	_, err := q.db.Exec(ctx, InsertCompanySetting, arg.CompanyID, arg.Key, arg.Value)
	return err
}

const UpdateGlobalSetting = `-- name: UpdateGlobalSetting :exec
UPDATE global_settings
SET value = $2,
    updated_at = CURRENT_TIMESTAMP
WHERE key = $1
`

type UpdateGlobalSettingParams struct {
	Key   string `json:"key"`
	Value string `json:"value"`
}

func (q *Queries) UpdateGlobalSetting(ctx context.Context, arg UpdateGlobalSettingParams) error {
	_, err := q.db.Exec(ctx, UpdateGlobalSetting, arg.Key, arg.Value)
	return err
}