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

package repo

import (
	"context"
)

const dissolveSpace = `-- name: DissolveSpace :exec
UPDATE space SET
    status = 2,
    dissolve_time = NOW(),
    update_time = NOW()
WHERE id = $1
`

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

const getSpaceById = `-- name: GetSpaceById :one
SELECT id, name, invite_code, owner_id, status, disabled_time, dissolve_time, create_time, update_time FROM space WHERE id = $1
`

// 根据id获取分享空间信息
func (q *Queries) GetSpaceById(ctx context.Context, id int64) (Space, error) {
	row := q.db.QueryRow(ctx, getSpaceById, id)
	var i Space
	err := row.Scan(
		&i.ID,
		&i.Name,
		&i.InviteCode,
		&i.OwnerID,
		&i.Status,
		&i.DisabledTime,
		&i.DissolveTime,
		&i.CreateTime,
		&i.UpdateTime,
	)
	return i, err
}

const getSpaceByInviteCode = `-- name: GetSpaceByInviteCode :one
SELECT id, name, invite_code, owner_id, status, disabled_time, dissolve_time, create_time, update_time FROM space WHERE invite_code = $1
`

// 根据邀请码获取
func (q *Queries) GetSpaceByInviteCode(ctx context.Context, inviteCode string) (Space, error) {
	row := q.db.QueryRow(ctx, getSpaceByInviteCode, inviteCode)
	var i Space
	err := row.Scan(
		&i.ID,
		&i.Name,
		&i.InviteCode,
		&i.OwnerID,
		&i.Status,
		&i.DisabledTime,
		&i.DissolveTime,
		&i.CreateTime,
		&i.UpdateTime,
	)
	return i, err
}

const getSpaceByUserIdAndSpaceId = `-- name: GetSpaceByUserIdAndSpaceId :one
SELECT
    s.id AS space_id,
    s.owner_id,
    s.name,
    sm.role,
    COALESCE(mc.member_count, 0) AS member_count,
    sm.is_default,
    sm.member_name,
    sm.sort_number,
    s.invite_code
FROM space s
         JOIN space_member sm
              ON s.id = sm.space_id
         LEFT JOIN (
    SELECT space_id, COUNT(*) AS member_count
    FROM space_member
    GROUP BY space_id
) mc
                   ON s.id = mc.space_id
WHERE sm.user_id = $1 AND s.id = $2 AND s.status != 2 AND sm.status != 2
ORDER BY sm.is_default DESC, sm.sort_number ASC
`

type GetSpaceByUserIdAndSpaceIdParams struct {
	UserID int64
	ID     int64
}

type GetSpaceByUserIdAndSpaceIdRow struct {
	SpaceID     int64
	OwnerID     int64
	Name        string
	Role        int16
	MemberCount int64
	IsDefault   int16
	MemberName  string
	SortNumber  int32
	InviteCode  string
}

func (q *Queries) GetSpaceByUserIdAndSpaceId(ctx context.Context, arg GetSpaceByUserIdAndSpaceIdParams) (GetSpaceByUserIdAndSpaceIdRow, error) {
	row := q.db.QueryRow(ctx, getSpaceByUserIdAndSpaceId, arg.UserID, arg.ID)
	var i GetSpaceByUserIdAndSpaceIdRow
	err := row.Scan(
		&i.SpaceID,
		&i.OwnerID,
		&i.Name,
		&i.Role,
		&i.MemberCount,
		&i.IsDefault,
		&i.MemberName,
		&i.SortNumber,
		&i.InviteCode,
	)
	return i, err
}

const insertSpace = `-- name: InsertSpace :exec
INSERT INTO space (
    id,name,invite_code,owner_id,create_time,update_time
) VALUES ($1,$2,$3,$4,NOW(),NOW())
`

type InsertSpaceParams struct {
	ID         int64
	Name       string
	InviteCode string
	OwnerID    int64
}

// 创建空间
func (q *Queries) InsertSpace(ctx context.Context, arg InsertSpaceParams) error {
	_, err := q.db.Exec(ctx, insertSpace,
		arg.ID,
		arg.Name,
		arg.InviteCode,
		arg.OwnerID,
	)
	return err
}

const listSpacesByUserId = `-- name: ListSpacesByUserId :many
SELECT
    s.id AS space_id,
    s.owner_id,
    s.name,
    sm.role,
    COALESCE(mc.member_count, 0) AS member_count,
    sm.is_default,
    sm.member_name,
    sm.sort_number
FROM space s
         JOIN space_member sm
              ON s.id = sm.space_id
         LEFT JOIN (
    SELECT space_id, COUNT(*) AS member_count
    FROM space_member
    GROUP BY space_id
) mc
                   ON s.id = mc.space_id
WHERE sm.user_id = $1 AND s.status != 2 AND sm.status != 2
ORDER BY sm.is_default DESC, sm.sort_number ASC
`

type ListSpacesByUserIdRow struct {
	SpaceID     int64
	OwnerID     int64
	Name        string
	Role        int16
	MemberCount int64
	IsDefault   int16
	MemberName  string
	SortNumber  int32
}

func (q *Queries) ListSpacesByUserId(ctx context.Context, userID int64) ([]ListSpacesByUserIdRow, error) {
	rows, err := q.db.Query(ctx, listSpacesByUserId, userID)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []ListSpacesByUserIdRow
	for rows.Next() {
		var i ListSpacesByUserIdRow
		if err := rows.Scan(
			&i.SpaceID,
			&i.OwnerID,
			&i.Name,
			&i.Role,
			&i.MemberCount,
			&i.IsDefault,
			&i.MemberName,
			&i.SortNumber,
		); err != nil {
			return nil, err
		}
		items = append(items, i)
	}
	if err := rows.Err(); err != nil {
		return nil, err
	}
	return items, nil
}

const updateSpaceInviteCode = `-- name: UpdateSpaceInviteCode :exec
UPDATE space set invite_code = $1,update_time = NOW() WHERE id = $2
`

type UpdateSpaceInviteCodeParams struct {
	InviteCode string
	ID         int64
}

func (q *Queries) UpdateSpaceInviteCode(ctx context.Context, arg UpdateSpaceInviteCodeParams) error {
	_, err := q.db.Exec(ctx, updateSpaceInviteCode, arg.InviteCode, arg.ID)
	return err
}

const updateSpaceName = `-- name: UpdateSpaceName :exec
UPDATE space SET name = $1
WHERE id = $2
`

type UpdateSpaceNameParams struct {
	Name string
	ID   int64
}

func (q *Queries) UpdateSpaceName(ctx context.Context, arg UpdateSpaceNameParams) error {
	_, err := q.db.Exec(ctx, updateSpaceName, arg.Name, arg.ID)
	return err
}

const updateSpaceOwnerId = `-- name: UpdateSpaceOwnerId :exec
UPDATE space set owner_id = $1,update_time = NOW() WHERE id = $2
`

type UpdateSpaceOwnerIdParams struct {
	OwnerID int64
	ID      int64
}

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