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

package repository

import (
	"context"

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

const addProjectMember = `-- name: AddProjectMember :exec
INSERT INTO project_members (project_id, user_id, role)
VALUES ($1, $2, $3)
ON CONFLICT (project_id, user_id) DO UPDATE SET role = EXCLUDED.role
`

type AddProjectMemberParams struct {
	ProjectID pgtype.UUID `json:"project_id"`
	UserID    pgtype.UUID `json:"user_id"`
	Role      string      `json:"role"`
}

func (q *Queries) AddProjectMember(ctx context.Context, arg AddProjectMemberParams) error {
	_, err := q.db.Exec(ctx, addProjectMember, arg.ProjectID, arg.UserID, arg.Role)
	return err
}

const createProject = `-- name: CreateProject :one
INSERT INTO projects (id, owner_id, name, color, is_shared, deadline, sort_order)
VALUES ($1, $2, $3, $4, COALESCE($5, false), $6, COALESCE($7, 0))
RETURNING id, owner_id, name, color, is_shared, deadline, sort_order, created_at, updated_at, deleted_at
`

type CreateProjectParams struct {
	ID       pgtype.UUID        `json:"id"`
	OwnerID  pgtype.UUID        `json:"owner_id"`
	Name     string             `json:"name"`
	Color    string             `json:"color"`
	Column5  interface{}        `json:"column_5"`
	Deadline pgtype.Timestamptz `json:"deadline"`
	Column7  interface{}        `json:"column_7"`
}

func (q *Queries) CreateProject(ctx context.Context, arg CreateProjectParams) (Project, error) {
	row := q.db.QueryRow(ctx, createProject,
		arg.ID,
		arg.OwnerID,
		arg.Name,
		arg.Color,
		arg.Column5,
		arg.Deadline,
		arg.Column7,
	)
	var i Project
	err := row.Scan(
		&i.ID,
		&i.OwnerID,
		&i.Name,
		&i.Color,
		&i.IsShared,
		&i.Deadline,
		&i.SortOrder,
		&i.CreatedAt,
		&i.UpdatedAt,
		&i.DeletedAt,
	)
	return i, err
}

const getProjectByID = `-- name: GetProjectByID :one
SELECT id, owner_id, name, color, is_shared, deadline, sort_order, created_at, updated_at, deleted_at FROM projects
WHERE id = $1 AND owner_id = $2 AND deleted_at IS NULL
`

type GetProjectByIDParams struct {
	ID      pgtype.UUID `json:"id"`
	OwnerID pgtype.UUID `json:"owner_id"`
}

func (q *Queries) GetProjectByID(ctx context.Context, arg GetProjectByIDParams) (Project, error) {
	row := q.db.QueryRow(ctx, getProjectByID, arg.ID, arg.OwnerID)
	var i Project
	err := row.Scan(
		&i.ID,
		&i.OwnerID,
		&i.Name,
		&i.Color,
		&i.IsShared,
		&i.Deadline,
		&i.SortOrder,
		&i.CreatedAt,
		&i.UpdatedAt,
		&i.DeletedAt,
	)
	return i, err
}

const getProjectMember = `-- name: GetProjectMember :one
SELECT project_id, user_id, role FROM project_members
WHERE project_id = $1 AND user_id = $2
`

type GetProjectMemberParams struct {
	ProjectID pgtype.UUID `json:"project_id"`
	UserID    pgtype.UUID `json:"user_id"`
}

func (q *Queries) GetProjectMember(ctx context.Context, arg GetProjectMemberParams) (ProjectMember, error) {
	row := q.db.QueryRow(ctx, getProjectMember, arg.ProjectID, arg.UserID)
	var i ProjectMember
	err := row.Scan(&i.ProjectID, &i.UserID, &i.Role)
	return i, err
}

const listProjectMembers = `-- name: ListProjectMembers :many
SELECT pm.project_id, pm.user_id, pm.role, u.email
FROM project_members pm
JOIN users u ON u.id = pm.user_id
WHERE pm.project_id = $1
`

type ListProjectMembersRow struct {
	ProjectID pgtype.UUID `json:"project_id"`
	UserID    pgtype.UUID `json:"user_id"`
	Role      string      `json:"role"`
	Email     string      `json:"email"`
}

func (q *Queries) ListProjectMembers(ctx context.Context, projectID pgtype.UUID) ([]ListProjectMembersRow, error) {
	rows, err := q.db.Query(ctx, listProjectMembers, projectID)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	items := []ListProjectMembersRow{}
	for rows.Next() {
		var i ListProjectMembersRow
		if err := rows.Scan(
			&i.ProjectID,
			&i.UserID,
			&i.Role,
			&i.Email,
		); err != nil {
			return nil, err
		}
		items = append(items, i)
	}
	if err := rows.Err(); err != nil {
		return nil, err
	}
	return items, nil
}

const listProjects = `-- name: ListProjects :many
SELECT id, owner_id, name, color, is_shared, deadline, sort_order, created_at, updated_at, deleted_at FROM projects
WHERE owner_id = $1 AND deleted_at IS NULL
ORDER BY sort_order ASC, name ASC
`

func (q *Queries) ListProjects(ctx context.Context, ownerID pgtype.UUID) ([]Project, error) {
	rows, err := q.db.Query(ctx, listProjects, ownerID)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	items := []Project{}
	for rows.Next() {
		var i Project
		if err := rows.Scan(
			&i.ID,
			&i.OwnerID,
			&i.Name,
			&i.Color,
			&i.IsShared,
			&i.Deadline,
			&i.SortOrder,
			&i.CreatedAt,
			&i.UpdatedAt,
			&i.DeletedAt,
		); err != nil {
			return nil, err
		}
		items = append(items, i)
	}
	if err := rows.Err(); err != nil {
		return nil, err
	}
	return items, nil
}

const listProjectsForUser = `-- name: ListProjectsForUser :many
SELECT p.id, p.owner_id, p.name, p.color, p.is_shared, p.deadline, p.sort_order, p.created_at, p.updated_at, p.deleted_at FROM projects p
LEFT JOIN project_members pm ON pm.project_id = p.id AND pm.user_id = $1
WHERE (p.owner_id = $1 OR pm.user_id = $1)
  AND p.deleted_at IS NULL
ORDER BY p.sort_order ASC, p.name ASC
`

func (q *Queries) ListProjectsForUser(ctx context.Context, userID pgtype.UUID) ([]Project, error) {
	rows, err := q.db.Query(ctx, listProjectsForUser, userID)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	items := []Project{}
	for rows.Next() {
		var i Project
		if err := rows.Scan(
			&i.ID,
			&i.OwnerID,
			&i.Name,
			&i.Color,
			&i.IsShared,
			&i.Deadline,
			&i.SortOrder,
			&i.CreatedAt,
			&i.UpdatedAt,
			&i.DeletedAt,
		); err != nil {
			return nil, err
		}
		items = append(items, i)
	}
	if err := rows.Err(); err != nil {
		return nil, err
	}
	return items, nil
}

const removeProjectMember = `-- name: RemoveProjectMember :exec
DELETE FROM project_members
WHERE project_id = $1 AND user_id = $2
`

type RemoveProjectMemberParams struct {
	ProjectID pgtype.UUID `json:"project_id"`
	UserID    pgtype.UUID `json:"user_id"`
}

func (q *Queries) RemoveProjectMember(ctx context.Context, arg RemoveProjectMemberParams) error {
	_, err := q.db.Exec(ctx, removeProjectMember, arg.ProjectID, arg.UserID)
	return err
}

const softDeleteProject = `-- name: SoftDeleteProject :exec
UPDATE projects SET deleted_at = now(), updated_at = now()
WHERE id = $1 AND owner_id = $2 AND deleted_at IS NULL
`

type SoftDeleteProjectParams struct {
	ID      pgtype.UUID `json:"id"`
	OwnerID pgtype.UUID `json:"owner_id"`
}

func (q *Queries) SoftDeleteProject(ctx context.Context, arg SoftDeleteProjectParams) error {
	_, err := q.db.Exec(ctx, softDeleteProject, arg.ID, arg.OwnerID)
	return err
}

const updateProject = `-- name: UpdateProject :one
UPDATE projects
SET name = COALESCE($1, name),
    color = COALESCE($2, color),
    is_shared = COALESCE($3, is_shared),
    deadline = $4,
    sort_order = COALESCE($5, sort_order),
    updated_at = now()
WHERE id = $6 AND owner_id = $7 AND deleted_at IS NULL
RETURNING id, owner_id, name, color, is_shared, deadline, sort_order, created_at, updated_at, deleted_at
`

type UpdateProjectParams struct {
	Name      pgtype.Text        `json:"name"`
	Color     pgtype.Text        `json:"color"`
	IsShared  pgtype.Bool        `json:"is_shared"`
	Deadline  pgtype.Timestamptz `json:"deadline"`
	SortOrder pgtype.Int4        `json:"sort_order"`
	ID        pgtype.UUID        `json:"id"`
	OwnerID   pgtype.UUID        `json:"owner_id"`
}

func (q *Queries) UpdateProject(ctx context.Context, arg UpdateProjectParams) (Project, error) {
	row := q.db.QueryRow(ctx, updateProject,
		arg.Name,
		arg.Color,
		arg.IsShared,
		arg.Deadline,
		arg.SortOrder,
		arg.ID,
		arg.OwnerID,
	)
	var i Project
	err := row.Scan(
		&i.ID,
		&i.OwnerID,
		&i.Name,
		&i.Color,
		&i.IsShared,
		&i.Deadline,
		&i.SortOrder,
		&i.CreatedAt,
		&i.UpdatedAt,
		&i.DeletedAt,
	)
	return i, err
}