// Code generated by sqlc. DO NOT EDIT.
// versions:
//   sqlc v1.29.0
// source: members.sql

package organization

import (
	"context"
	"database/sql"
	"time"
)

const createOrgMember = `-- name: CreateOrgMember :one
INSERT INTO core.org_members (org_id, person_id, role_id)
VALUES ($1, $2, $3)
RETURNING org_member_id, org_id, person_id, role_id, status, joined_at, removed_at, created_at, updated_at
`

type CreateOrgMemberParams struct {
	OrgID    string `json:"org_id"`
	PersonID string `json:"person_id"`
	RoleID   string `json:"role_id"`
}

func (q *Queries) CreateOrgMember(ctx context.Context, arg CreateOrgMemberParams) (OrgMember, error) {
	row := q.db.QueryRowContext(ctx, createOrgMember, arg.OrgID, arg.PersonID, arg.RoleID)
	var i OrgMember
	err := row.Scan(
		&i.OrgMemberID,
		&i.OrgID,
		&i.PersonID,
		&i.RoleID,
		&i.Status,
		&i.JoinedAt,
		&i.RemovedAt,
		&i.CreatedAt,
		&i.UpdatedAt,
	)
	return i, err
}

const getOrgMemberByPersonAndOrg = `-- name: GetOrgMemberByPersonAndOrg :one
SELECT org_member_id, org_id, person_id, role_id, status, joined_at, removed_at, created_at, updated_at FROM core.org_members
WHERE person_id = $1 AND org_id = $2
`

type GetOrgMemberByPersonAndOrgParams struct {
	PersonID string `json:"person_id"`
	OrgID    string `json:"org_id"`
}

func (q *Queries) GetOrgMemberByPersonAndOrg(ctx context.Context, arg GetOrgMemberByPersonAndOrgParams) (OrgMember, error) {
	row := q.db.QueryRowContext(ctx, getOrgMemberByPersonAndOrg, arg.PersonID, arg.OrgID)
	var i OrgMember
	err := row.Scan(
		&i.OrgMemberID,
		&i.OrgID,
		&i.PersonID,
		&i.RoleID,
		&i.Status,
		&i.JoinedAt,
		&i.RemovedAt,
		&i.CreatedAt,
		&i.UpdatedAt,
	)
	return i, err
}

const getOrgMembersByOrgID = `-- name: GetOrgMembersByOrgID :many
SELECT om.org_member_id, om.org_id, om.person_id, om.role_id, om.status, om.joined_at, om.removed_at, om.created_at, om.updated_at, p.display_name, p.primary_email, r.role_name
FROM core.org_members om
JOIN core.persons p ON p.person_id = om.person_id
JOIN core.roles r ON r.role_id = om.role_id
WHERE om.org_id = $1
ORDER BY p.display_name
`

type GetOrgMembersByOrgIDRow struct {
	OrgMemberID  string       `json:"org_member_id"`
	OrgID        string       `json:"org_id"`
	PersonID     string       `json:"person_id"`
	RoleID       string       `json:"role_id"`
	Status       string       `json:"status"`
	JoinedAt     time.Time    `json:"joined_at"`
	RemovedAt    sql.NullTime `json:"removed_at"`
	CreatedAt    time.Time    `json:"created_at"`
	UpdatedAt    time.Time    `json:"updated_at"`
	DisplayName  string       `json:"display_name"`
	PrimaryEmail string       `json:"primary_email"`
	RoleName     string       `json:"role_name"`
}

func (q *Queries) GetOrgMembersByOrgID(ctx context.Context, orgID string) ([]GetOrgMembersByOrgIDRow, error) {
	rows, err := q.db.QueryContext(ctx, getOrgMembersByOrgID, orgID)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	items := []GetOrgMembersByOrgIDRow{}
	for rows.Next() {
		var i GetOrgMembersByOrgIDRow
		if err := rows.Scan(
			&i.OrgMemberID,
			&i.OrgID,
			&i.PersonID,
			&i.RoleID,
			&i.Status,
			&i.JoinedAt,
			&i.RemovedAt,
			&i.CreatedAt,
			&i.UpdatedAt,
			&i.DisplayName,
			&i.PrimaryEmail,
			&i.RoleName,
		); err != nil {
			return nil, err
		}
		items = append(items, i)
	}
	if err := rows.Close(); err != nil {
		return nil, err
	}
	if err := rows.Err(); err != nil {
		return nil, err
	}
	return items, nil
}

const listActiveMembersByOrgID = `-- name: ListActiveMembersByOrgID :many
SELECT
    om.org_member_id,
    om.person_id,
    om.role_id,
    om.joined_at,
    p.display_name,
    p.primary_email,
    r.role_name
FROM core.org_members om
JOIN core.persons p ON p.person_id = om.person_id
JOIN core.roles r ON r.role_id = om.role_id
WHERE om.org_id = $1
  AND om.status = 'active'
ORDER BY p.display_name ASC
LIMIT 200
`

type ListActiveMembersByOrgIDRow struct {
	OrgMemberID  string    `json:"org_member_id"`
	PersonID     string    `json:"person_id"`
	RoleID       string    `json:"role_id"`
	JoinedAt     time.Time `json:"joined_at"`
	DisplayName  string    `json:"display_name"`
	PrimaryEmail string    `json:"primary_email"`
	RoleName     string    `json:"role_name"`
}

// Operator composite's Members section. Active members only (status='active',
// excluding removed/historical rows). Defensive LIMIT 200 per design D5;
// pagination is YAGNI until a real org pushes 50+ members.
func (q *Queries) ListActiveMembersByOrgID(ctx context.Context, orgID string) ([]ListActiveMembersByOrgIDRow, error) {
	rows, err := q.db.QueryContext(ctx, listActiveMembersByOrgID, orgID)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	items := []ListActiveMembersByOrgIDRow{}
	for rows.Next() {
		var i ListActiveMembersByOrgIDRow
		if err := rows.Scan(
			&i.OrgMemberID,
			&i.PersonID,
			&i.RoleID,
			&i.JoinedAt,
			&i.DisplayName,
			&i.PrimaryEmail,
			&i.RoleName,
		); err != nil {
			return nil, err
		}
		items = append(items, i)
	}
	if err := rows.Close(); err != nil {
		return nil, err
	}
	if err := rows.Err(); err != nil {
		return nil, err
	}
	return items, nil
}

const listActiveMembershipsByPersonID = `-- name: ListActiveMembershipsByPersonID :many
SELECT
    om.org_member_id,
    om.org_id,
    om.role_id,
    om.joined_at,
    o.name AS org_name,
    o.slug AS org_slug,
    r.role_name
FROM core.org_members om
JOIN core.organizations o ON o.org_id = om.org_id
JOIN core.roles r ON r.role_id = om.role_id
WHERE om.person_id = $1
  AND om.status = 'active'
ORDER BY om.joined_at DESC
LIMIT 200
`

type ListActiveMembershipsByPersonIDRow struct {
	OrgMemberID string    `json:"org_member_id"`
	OrgID       string    `json:"org_id"`
	RoleID      string    `json:"role_id"`
	JoinedAt    time.Time `json:"joined_at"`
	OrgName     string    `json:"org_name"`
	OrgSlug     string    `json:"org_slug"`
	RoleName    string    `json:"role_name"`
}

// Person-detail "Org memberships" section. Returns each org the person
// belongs to (active memberships only) with the org's display fields and
// the person's role at that org. Sorted by joined_at DESC so the most
// recent membership appears first — operators usually want "what's the
// person doing now" rather than "where did they start."
func (q *Queries) ListActiveMembershipsByPersonID(ctx context.Context, personID string) ([]ListActiveMembershipsByPersonIDRow, error) {
	rows, err := q.db.QueryContext(ctx, listActiveMembershipsByPersonID, personID)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	items := []ListActiveMembershipsByPersonIDRow{}
	for rows.Next() {
		var i ListActiveMembershipsByPersonIDRow
		if err := rows.Scan(
			&i.OrgMemberID,
			&i.OrgID,
			&i.RoleID,
			&i.JoinedAt,
			&i.OrgName,
			&i.OrgSlug,
			&i.RoleName,
		); err != nil {
			return nil, err
		}
		items = append(items, i)
	}
	if err := rows.Close(); err != nil {
		return nil, err
	}
	if err := rows.Err(); err != nil {
		return nil, err
	}
	return items, nil
}