// Code generated by sqlc. DO NOT EDIT.
// versions:
//   sqlc v1.28.0
// source: income.sql

package db

import (
	"context"
	"time"

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

const createIncome = `-- name: CreateIncome :one
INSERT INTO incomes (project_id, budget_id, amount, income_at, income_type, income_bank, remark, status, created_user_id) 
VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9)
RETURNING id, project_id, budget_id, amount, income_at, income_type, income_bank, remark, status, created_at, created_user_id, updated_at, updated_user_id
`

type CreateIncomeParams struct {
	ProjectID     int64          `json:"project_id"`
	BudgetID      int64          `json:"budget_id"`
	Amount        pgtype.Numeric `json:"amount"`
	IncomeAt      time.Time      `json:"income_at"`
	IncomeType    int32          `json:"income_type"`
	IncomeBank    int32          `json:"income_bank"`
	Remark        string         `json:"remark"`
	Status        int16          `json:"status"`
	CreatedUserID int32          `json:"created_user_id"`
}

func (q *Queries) CreateIncome(ctx context.Context, arg *CreateIncomeParams) (*Income, error) {
	row := q.db.QueryRow(ctx, createIncome,
		arg.ProjectID,
		arg.BudgetID,
		arg.Amount,
		arg.IncomeAt,
		arg.IncomeType,
		arg.IncomeBank,
		arg.Remark,
		arg.Status,
		arg.CreatedUserID,
	)
	var i Income
	err := row.Scan(
		&i.ID,
		&i.ProjectID,
		&i.BudgetID,
		&i.Amount,
		&i.IncomeAt,
		&i.IncomeType,
		&i.IncomeBank,
		&i.Remark,
		&i.Status,
		&i.CreatedAt,
		&i.CreatedUserID,
		&i.UpdatedAt,
		&i.UpdatedUserID,
	)
	return &i, err
}

const getIncome = `-- name: GetIncome :one
SELECT id, project_id, budget_id, amount, income_at, income_type, income_bank, remark, status, created_at, created_user_id, updated_at, updated_user_id 
FROM incomes 
WHERE id = $1
LIMIT 1
`

func (q *Queries) GetIncome(ctx context.Context, id int64) (*Income, error) {
	row := q.db.QueryRow(ctx, getIncome, id)
	var i Income
	err := row.Scan(
		&i.ID,
		&i.ProjectID,
		&i.BudgetID,
		&i.Amount,
		&i.IncomeAt,
		&i.IncomeType,
		&i.IncomeBank,
		&i.Remark,
		&i.Status,
		&i.CreatedAt,
		&i.CreatedUserID,
		&i.UpdatedAt,
		&i.UpdatedUserID,
	)
	return &i, err
}

const statisticsIncome = `-- name: StatisticsIncome :many
SELECT SUM(amount)::numeric as total_amount,
    (select name from categories where id = incomes.income_type) income_type_name
FROM incomes
GROUP BY income_type
`

type StatisticsIncomeRow struct {
	TotalAmount    pgtype.Numeric `json:"total_amount"`
	IncomeTypeName string         `json:"income_type_name"`
}

func (q *Queries) StatisticsIncome(ctx context.Context) ([]*StatisticsIncomeRow, error) {
	rows, err := q.db.Query(ctx, statisticsIncome)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	items := []*StatisticsIncomeRow{}
	for rows.Next() {
		var i StatisticsIncomeRow
		if err := rows.Scan(&i.TotalAmount, &i.IncomeTypeName); err != nil {
			return nil, err
		}
		items = append(items, &i)
	}
	if err := rows.Err(); err != nil {
		return nil, err
	}
	return items, nil
}

const statisticsIncomeByProjectID = `-- name: StatisticsIncomeByProjectID :many
SELECT SUM(amount)::numeric as total_amount,
    (select name from categories where id = incomes.income_type) income_type_name
FROM incomes
WHERE project_id = $1
GROUP BY income_type
`

type StatisticsIncomeByProjectIDRow struct {
	TotalAmount    pgtype.Numeric `json:"total_amount"`
	IncomeTypeName string         `json:"income_type_name"`
}

func (q *Queries) StatisticsIncomeByProjectID(ctx context.Context, projectID int64) ([]*StatisticsIncomeByProjectIDRow, error) {
	rows, err := q.db.Query(ctx, statisticsIncomeByProjectID, projectID)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	items := []*StatisticsIncomeByProjectIDRow{}
	for rows.Next() {
		var i StatisticsIncomeByProjectIDRow
		if err := rows.Scan(&i.TotalAmount, &i.IncomeTypeName); err != nil {
			return nil, err
		}
		items = append(items, &i)
	}
	if err := rows.Err(); err != nil {
		return nil, err
	}
	return items, nil
}

const sumIncome = `-- name: SumIncome :one
SELECT SUM(amount)::numeric
FROM incomes
`

func (q *Queries) SumIncome(ctx context.Context) (pgtype.Numeric, error) {
	row := q.db.QueryRow(ctx, sumIncome)
	var column_1 pgtype.Numeric
	err := row.Scan(&column_1)
	return column_1, err
}

const sumIncomeByProjectID = `-- name: SumIncomeByProjectID :one
SELECT SUM(amount)::numeric
FROM incomes
WHERE project_id = $1
`

func (q *Queries) SumIncomeByProjectID(ctx context.Context, projectID int64) (pgtype.Numeric, error) {
	row := q.db.QueryRow(ctx, sumIncomeByProjectID, projectID)
	var column_1 pgtype.Numeric
	err := row.Scan(&column_1)
	return column_1, err
}

const updateIncome = `-- name: UpdateIncome :one
UPDATE incomes
SET
    project_id = COALESCE($2, project_id),
    budget_id = COALESCE($3, budget_id),
    amount = COALESCE($4, amount),
    income_at = COALESCE($5, income_at),
    income_type = COALESCE($6, income_type),
    income_bank = COALESCE($7, income_bank),
    remark = COALESCE($8, remark),
    status = COALESCE($9, status),
    updated_user_id = COALESCE($10, updated_user_id),
    updated_at = NOW()
WHERE id = $1
RETURNING id, project_id, budget_id, amount, income_at, income_type, income_bank, remark, status, created_at, created_user_id, updated_at, updated_user_id
`

type UpdateIncomeParams struct {
	ID            int64              `json:"id"`
	ProjectID     pgtype.Int8        `json:"project_id"`
	BudgetID      pgtype.Int8        `json:"budget_id"`
	Amount        pgtype.Numeric     `json:"amount"`
	IncomeAt      pgtype.Timestamptz `json:"income_at"`
	IncomeType    pgtype.Int4        `json:"income_type"`
	IncomeBank    pgtype.Int4        `json:"income_bank"`
	Remark        pgtype.Text        `json:"remark"`
	Status        pgtype.Int2        `json:"status"`
	UpdatedUserID pgtype.Int4        `json:"updated_user_id"`
}

func (q *Queries) UpdateIncome(ctx context.Context, arg *UpdateIncomeParams) (*Income, error) {
	row := q.db.QueryRow(ctx, updateIncome,
		arg.ID,
		arg.ProjectID,
		arg.BudgetID,
		arg.Amount,
		arg.IncomeAt,
		arg.IncomeType,
		arg.IncomeBank,
		arg.Remark,
		arg.Status,
		arg.UpdatedUserID,
	)
	var i Income
	err := row.Scan(
		&i.ID,
		&i.ProjectID,
		&i.BudgetID,
		&i.Amount,
		&i.IncomeAt,
		&i.IncomeType,
		&i.IncomeBank,
		&i.Remark,
		&i.Status,
		&i.CreatedAt,
		&i.CreatedUserID,
		&i.UpdatedAt,
		&i.UpdatedUserID,
	)
	return &i, err
}