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

package sqlcgen

import (
	"context"
)

const deleteLangPackMeta = `-- name: DeleteLangPackMeta :exec
DELETE FROM lang_packs
WHERE lang_pack = $1 AND lang_code = $2
`

type DeleteLangPackMetaParams struct {
	LangPack string
	LangCode string
}

func (q *Queries) DeleteLangPackMeta(ctx context.Context, arg DeleteLangPackMetaParams) error {
	_, err := q.db.Exec(ctx, deleteLangPackMeta, arg.LangPack, arg.LangCode)
	return err
}

const deleteLangPackSeedHash = `-- name: DeleteLangPackSeedHash :exec
DELETE FROM seed_states
WHERE key = $1
`

func (q *Queries) DeleteLangPackSeedHash(ctx context.Context, key string) error {
	_, err := q.db.Exec(ctx, deleteLangPackSeedHash, key)
	return err
}

const deleteLangPackStrings = `-- name: DeleteLangPackStrings :exec
DELETE FROM lang_pack_strings
WHERE lang_pack = $1 AND lang_code = $2
`

type DeleteLangPackStringsParams struct {
	LangPack string
	LangCode string
}

func (q *Queries) DeleteLangPackStrings(ctx context.Context, arg DeleteLangPackStringsParams) error {
	_, err := q.db.Exec(ctx, deleteLangPackStrings, arg.LangPack, arg.LangCode)
	return err
}

const getLangPackMeta = `-- name: GetLangPackMeta :one
SELECT lang_pack, lang_code, version, strings_count
FROM lang_packs
WHERE lang_pack = $1 AND lang_code = $2
`

type GetLangPackMetaParams struct {
	LangPack string
	LangCode string
}

type GetLangPackMetaRow struct {
	LangPack     string
	LangCode     string
	Version      int32
	StringsCount int32
}

func (q *Queries) GetLangPackMeta(ctx context.Context, arg GetLangPackMetaParams) (GetLangPackMetaRow, error) {
	row := q.db.QueryRow(ctx, getLangPackMeta, arg.LangPack, arg.LangCode)
	var i GetLangPackMetaRow
	err := row.Scan(
		&i.LangPack,
		&i.LangCode,
		&i.Version,
		&i.StringsCount,
	)
	return i, err
}

const getLangPackSeedHash = `-- name: GetLangPackSeedHash :one
SELECT content_hash
FROM seed_states
WHERE key = $1
`

func (q *Queries) GetLangPackSeedHash(ctx context.Context, key string) (string, error) {
	row := q.db.QueryRow(ctx, getLangPackSeedHash, key)
	var content_hash string
	err := row.Scan(&content_hash)
	return content_hash, err
}

const getLangPackStringsByKeys = `-- name: GetLangPackStringsByKeys :many
SELECT
  lang_pack, lang_code, key, version, pluralized, value,
  zero_value, one_value, two_value, few_value, many_value, other_value, deleted
FROM lang_pack_strings
WHERE lang_pack = $1 AND lang_code = $2 AND key = ANY($3::text[]) AND NOT deleted
ORDER BY key
`

type GetLangPackStringsByKeysParams struct {
	LangPack string
	LangCode string
	Keys     []string
}

type GetLangPackStringsByKeysRow struct {
	LangPack   string
	LangCode   string
	Key        string
	Version    int32
	Pluralized bool
	Value      string
	ZeroValue  string
	OneValue   string
	TwoValue   string
	FewValue   string
	ManyValue  string
	OtherValue string
	Deleted    bool
}

func (q *Queries) GetLangPackStringsByKeys(ctx context.Context, arg GetLangPackStringsByKeysParams) ([]GetLangPackStringsByKeysRow, error) {
	rows, err := q.db.Query(ctx, getLangPackStringsByKeys, arg.LangPack, arg.LangCode, arg.Keys)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []GetLangPackStringsByKeysRow
	for rows.Next() {
		var i GetLangPackStringsByKeysRow
		if err := rows.Scan(
			&i.LangPack,
			&i.LangCode,
			&i.Key,
			&i.Version,
			&i.Pluralized,
			&i.Value,
			&i.ZeroValue,
			&i.OneValue,
			&i.TwoValue,
			&i.FewValue,
			&i.ManyValue,
			&i.OtherValue,
			&i.Deleted,
		); err != nil {
			return nil, err
		}
		items = append(items, i)
	}
	if err := rows.Err(); err != nil {
		return nil, err
	}
	return items, nil
}

const listLangPackCodes = `-- name: ListLangPackCodes :many
SELECT lang_code
FROM lang_packs
WHERE lang_pack = $1
ORDER BY lang_code
`

func (q *Queries) ListLangPackCodes(ctx context.Context, langPack string) ([]string, error) {
	rows, err := q.db.Query(ctx, listLangPackCodes, langPack)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []string
	for rows.Next() {
		var lang_code string
		if err := rows.Scan(&lang_code); err != nil {
			return nil, err
		}
		items = append(items, lang_code)
	}
	if err := rows.Err(); err != nil {
		return nil, err
	}
	return items, nil
}

const listLangPackLanguages = `-- name: ListLangPackLanguages :many
SELECT
  p.lang_pack,
  p.lang_code,
  p.version,
  p.strings_count,
  COALESCE(
    MAX(s.value) FILTER (WHERE s.key = 'LanguageNameInEnglish'),
    MAX(s.value) FILTER (WHERE s.key = 'Localization.EnglishLanguageName'),
    ''
  )::text AS name,
  CASE
    WHEN p.lang_pack = 'android' THEN COALESCE(
      MAX(s.value) FILTER (WHERE s.key = 'TranslateLanguage' || upper(split_part(replace(p.lang_code, '-', '_'), '_', 1))),
      MAX(s.value) FILTER (WHERE s.key = 'PassportLanguage_' || upper(split_part(replace(p.lang_code, '-', '_'), '_', 1))),
      MAX(s.value) FILTER (WHERE s.key = 'LanguageName'),
      ''
    )
    ELSE COALESCE(
      MAX(s.value) FILTER (WHERE s.key = 'lng_language_name'),
      MAX(s.value) FILTER (WHERE s.key = 'LanguageName'),
      MAX(s.value) FILTER (WHERE s.key = 'Localization.LanguageName'),
      MAX(s.value) FILTER (WHERE s.key = 'TranslateLanguage' || upper(split_part(replace(p.lang_code, '-', '_'), '_', 1))),
      MAX(s.value) FILTER (WHERE s.key = 'PassportLanguage_' || upper(split_part(replace(p.lang_code, '-', '_'), '_', 1))),
      ''
    )
  END::text AS native_name
FROM lang_packs p
LEFT JOIN lang_pack_strings s
  ON s.lang_pack = p.lang_pack
 AND s.lang_code = p.lang_code
 AND s.key = ANY(ARRAY[
   'lng_language_name',
   'LanguageName',
   'LanguageNameInEnglish',
   'Localization.LanguageName',
   'Localization.EnglishLanguageName',
   'TranslateLanguage' || upper(split_part(replace(p.lang_code, '-', '_'), '_', 1)),
   'PassportLanguage_' || upper(split_part(replace(p.lang_code, '-', '_'), '_', 1))
 ]::text[])
 AND NOT s.deleted
WHERE p.lang_pack = $1
GROUP BY p.lang_pack, p.lang_code, p.version, p.strings_count
ORDER BY p.lang_code
`

type ListLangPackLanguagesRow struct {
	LangPack     string
	LangCode     string
	Version      int32
	StringsCount int32
	Name         string
	NativeName   string
}

func (q *Queries) ListLangPackLanguages(ctx context.Context, langPack string) ([]ListLangPackLanguagesRow, error) {
	rows, err := q.db.Query(ctx, listLangPackLanguages, langPack)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []ListLangPackLanguagesRow
	for rows.Next() {
		var i ListLangPackLanguagesRow
		if err := rows.Scan(
			&i.LangPack,
			&i.LangCode,
			&i.Version,
			&i.StringsCount,
			&i.Name,
			&i.NativeName,
		); err != nil {
			return nil, err
		}
		items = append(items, i)
	}
	if err := rows.Err(); err != nil {
		return nil, err
	}
	return items, nil
}

const listLangPackStrings = `-- name: ListLangPackStrings :many
SELECT
  lang_pack, lang_code, key, version, pluralized, value,
  zero_value, one_value, two_value, few_value, many_value, other_value, deleted
FROM lang_pack_strings
WHERE lang_pack = $1 AND lang_code = $2 AND NOT deleted
ORDER BY key
`

type ListLangPackStringsParams struct {
	LangPack string
	LangCode string
}

type ListLangPackStringsRow struct {
	LangPack   string
	LangCode   string
	Key        string
	Version    int32
	Pluralized bool
	Value      string
	ZeroValue  string
	OneValue   string
	TwoValue   string
	FewValue   string
	ManyValue  string
	OtherValue string
	Deleted    bool
}

func (q *Queries) ListLangPackStrings(ctx context.Context, arg ListLangPackStringsParams) ([]ListLangPackStringsRow, error) {
	rows, err := q.db.Query(ctx, listLangPackStrings, arg.LangPack, arg.LangCode)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []ListLangPackStringsRow
	for rows.Next() {
		var i ListLangPackStringsRow
		if err := rows.Scan(
			&i.LangPack,
			&i.LangCode,
			&i.Key,
			&i.Version,
			&i.Pluralized,
			&i.Value,
			&i.ZeroValue,
			&i.OneValue,
			&i.TwoValue,
			&i.FewValue,
			&i.ManyValue,
			&i.OtherValue,
			&i.Deleted,
		); err != nil {
			return nil, err
		}
		items = append(items, i)
	}
	if err := rows.Err(); err != nil {
		return nil, err
	}
	return items, nil
}

const putLangPackSeedHash = `-- name: PutLangPackSeedHash :exec
INSERT INTO seed_states (key, content_hash)
VALUES ($1, $2)
ON CONFLICT (key) DO UPDATE SET
  content_hash = EXCLUDED.content_hash,
  updated_at = now()
`

type PutLangPackSeedHashParams struct {
	Key         string
	ContentHash string
}

func (q *Queries) PutLangPackSeedHash(ctx context.Context, arg PutLangPackSeedHashParams) error {
	_, err := q.db.Exec(ctx, putLangPackSeedHash, arg.Key, arg.ContentHash)
	return err
}

const upsertLangPackMeta = `-- name: UpsertLangPackMeta :exec
INSERT INTO lang_packs (lang_pack, lang_code, version, strings_count)
VALUES ($1, $2, $3, $4)
ON CONFLICT (lang_pack, lang_code) DO UPDATE SET
  version = EXCLUDED.version,
  strings_count = EXCLUDED.strings_count,
  updated_at = now()
`

type UpsertLangPackMetaParams struct {
	LangPack     string
	LangCode     string
	Version      int32
	StringsCount int32
}

func (q *Queries) UpsertLangPackMeta(ctx context.Context, arg UpsertLangPackMetaParams) error {
	_, err := q.db.Exec(ctx, upsertLangPackMeta,
		arg.LangPack,
		arg.LangCode,
		arg.Version,
		arg.StringsCount,
	)
	return err
}

const upsertLangPackString = `-- name: UpsertLangPackString :exec
INSERT INTO lang_pack_strings (
  lang_pack, lang_code, key, version, pluralized, value,
  zero_value, one_value, two_value, few_value, many_value, other_value, deleted
)
VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13)
ON CONFLICT (lang_pack, lang_code, key) DO UPDATE SET
  version = EXCLUDED.version,
  pluralized = EXCLUDED.pluralized,
  value = EXCLUDED.value,
  zero_value = EXCLUDED.zero_value,
  one_value = EXCLUDED.one_value,
  two_value = EXCLUDED.two_value,
  few_value = EXCLUDED.few_value,
  many_value = EXCLUDED.many_value,
  other_value = EXCLUDED.other_value,
  deleted = EXCLUDED.deleted,
  updated_at = now()
`

type UpsertLangPackStringParams struct {
	LangPack   string
	LangCode   string
	Key        string
	Version    int32
	Pluralized bool
	Value      string
	ZeroValue  string
	OneValue   string
	TwoValue   string
	FewValue   string
	ManyValue  string
	OtherValue string
	Deleted    bool
}

func (q *Queries) UpsertLangPackString(ctx context.Context, arg UpsertLangPackStringParams) error {
	_, err := q.db.Exec(ctx, upsertLangPackString,
		arg.LangPack,
		arg.LangCode,
		arg.Key,
		arg.Version,
		arg.Pluralized,
		arg.Value,
		arg.ZeroValue,
		arg.OneValue,
		arg.TwoValue,
		arg.FewValue,
		arg.ManyValue,
		arg.OtherValue,
		arg.Deleted,
	)
	return err
}