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

package dbgen

import (
	"context"
	"time"

	"github.com/google/uuid"
	"github.com/shopspring/decimal"
)

const addSlateMember = `-- name: AddSlateMember :one
INSERT INTO slate_members (
    organization_id, slate_id, candidate_id,
    total_score, band,
    clearance_score, skills_score, certs_score, customer_score, experience_score, location_score,
    explanation, trace, gap_summary, rank, model_version
) VALUES ($1,$2,$3,$4,$5,$6,$7,$8,$9,$10,$11,$12,$13,$14,$15,$16)
RETURNING organization_id, slate_id, candidate_id, total_score, band, clearance_score, skills_score, certs_score, customer_score, experience_score, location_score, explanation, trace, gap_summary, decision, decided_by, decided_at, rank, created_at, model_version, decision_note
`

type AddSlateMemberParams struct {
	OrganizationID  uuid.UUID       `json:"organization_id"`
	SlateID         uuid.UUID       `json:"slate_id"`
	CandidateID     uuid.UUID       `json:"candidate_id"`
	TotalScore      decimal.Decimal `json:"total_score"`
	Band            string          `json:"band"`
	ClearanceScore  decimal.Decimal `json:"clearance_score"`
	SkillsScore     decimal.Decimal `json:"skills_score"`
	CertsScore      decimal.Decimal `json:"certs_score"`
	CustomerScore   decimal.Decimal `json:"customer_score"`
	ExperienceScore decimal.Decimal `json:"experience_score"`
	LocationScore   decimal.Decimal `json:"location_score"`
	Explanation     string          `json:"explanation"`
	Trace           []byte          `json:"trace"`
	GapSummary      []byte          `json:"gap_summary"`
	Rank            *int32          `json:"rank"`
	ModelVersion    *string         `json:"model_version"`
}

func (q *Queries) AddSlateMember(ctx context.Context, arg AddSlateMemberParams) (SlateMember, error) {
	row := q.db.QueryRow(ctx, addSlateMember,
		arg.OrganizationID,
		arg.SlateID,
		arg.CandidateID,
		arg.TotalScore,
		arg.Band,
		arg.ClearanceScore,
		arg.SkillsScore,
		arg.CertsScore,
		arg.CustomerScore,
		arg.ExperienceScore,
		arg.LocationScore,
		arg.Explanation,
		arg.Trace,
		arg.GapSummary,
		arg.Rank,
		arg.ModelVersion,
	)
	var i SlateMember
	err := row.Scan(
		&i.OrganizationID,
		&i.SlateID,
		&i.CandidateID,
		&i.TotalScore,
		&i.Band,
		&i.ClearanceScore,
		&i.SkillsScore,
		&i.CertsScore,
		&i.CustomerScore,
		&i.ExperienceScore,
		&i.LocationScore,
		&i.Explanation,
		&i.Trace,
		&i.GapSummary,
		&i.Decision,
		&i.DecidedBy,
		&i.DecidedAt,
		&i.Rank,
		&i.CreatedAt,
		&i.ModelVersion,
		&i.DecisionNote,
	)
	return i, err
}

const createSlate = `-- name: CreateSlate :one
INSERT INTO slates (organization_id, requirement_id, name, status, created_by)
VALUES ($1,$2,$3,$4,$5)
RETURNING id, organization_id, requirement_id, name, status, created_by, created_at, updated_at
`

type CreateSlateParams struct {
	OrganizationID uuid.UUID  `json:"organization_id"`
	RequirementID  uuid.UUID  `json:"requirement_id"`
	Name           string     `json:"name"`
	Status         string     `json:"status"`
	CreatedBy      *uuid.UUID `json:"created_by"`
}

func (q *Queries) CreateSlate(ctx context.Context, arg CreateSlateParams) (Slate, error) {
	row := q.db.QueryRow(ctx, createSlate,
		arg.OrganizationID,
		arg.RequirementID,
		arg.Name,
		arg.Status,
		arg.CreatedBy,
	)
	var i Slate
	err := row.Scan(
		&i.ID,
		&i.OrganizationID,
		&i.RequirementID,
		&i.Name,
		&i.Status,
		&i.CreatedBy,
		&i.CreatedAt,
		&i.UpdatedAt,
	)
	return i, err
}

const getSlate = `-- name: GetSlate :one
SELECT id, organization_id, requirement_id, name, status, created_by, created_at, updated_at FROM slates WHERE id = $1
`

func (q *Queries) GetSlate(ctx context.Context, id uuid.UUID) (Slate, error) {
	row := q.db.QueryRow(ctx, getSlate, id)
	var i Slate
	err := row.Scan(
		&i.ID,
		&i.OrganizationID,
		&i.RequirementID,
		&i.Name,
		&i.Status,
		&i.CreatedBy,
		&i.CreatedAt,
		&i.UpdatedAt,
	)
	return i, err
}

const getSlateMember = `-- name: GetSlateMember :one

SELECT organization_id, slate_id, candidate_id, total_score, band, clearance_score, skills_score, certs_score, customer_score, experience_score, location_score, explanation, trace, gap_summary, decision, decided_by, decided_at, rank, created_at, model_version, decision_note FROM slate_members WHERE slate_id = $1 AND candidate_id = $2
`

type GetSlateMemberParams struct {
	SlateID     uuid.UUID `json:"slate_id"`
	CandidateID uuid.UUID `json:"candidate_id"`
}

// PK tiebreaker => total order [review SQLC-5]
// The frozen decision record for one member: the full per component trace, rationale, and gap summary
// for the audit and candidate facing explanation.
func (q *Queries) GetSlateMember(ctx context.Context, arg GetSlateMemberParams) (SlateMember, error) {
	row := q.db.QueryRow(ctx, getSlateMember, arg.SlateID, arg.CandidateID)
	var i SlateMember
	err := row.Scan(
		&i.OrganizationID,
		&i.SlateID,
		&i.CandidateID,
		&i.TotalScore,
		&i.Band,
		&i.ClearanceScore,
		&i.SkillsScore,
		&i.CertsScore,
		&i.CustomerScore,
		&i.ExperienceScore,
		&i.LocationScore,
		&i.Explanation,
		&i.Trace,
		&i.GapSummary,
		&i.Decision,
		&i.DecidedBy,
		&i.DecidedAt,
		&i.Rank,
		&i.CreatedAt,
		&i.ModelVersion,
		&i.DecisionNote,
	)
	return i, err
}

const listSlateMembers = `-- name: ListSlateMembers :many
SELECT organization_id, slate_id, candidate_id, total_score, band, clearance_score, skills_score, certs_score, customer_score, experience_score, location_score, explanation, trace, gap_summary, decision, decided_by, decided_at, rank, created_at, model_version, decision_note FROM slate_members
WHERE slate_id = $1
ORDER BY rank NULLS LAST, total_score DESC, candidate_id
`

func (q *Queries) ListSlateMembers(ctx context.Context, slateID uuid.UUID) ([]SlateMember, error) {
	rows, err := q.db.Query(ctx, listSlateMembers, slateID)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	items := []SlateMember{}
	for rows.Next() {
		var i SlateMember
		if err := rows.Scan(
			&i.OrganizationID,
			&i.SlateID,
			&i.CandidateID,
			&i.TotalScore,
			&i.Band,
			&i.ClearanceScore,
			&i.SkillsScore,
			&i.CertsScore,
			&i.CustomerScore,
			&i.ExperienceScore,
			&i.LocationScore,
			&i.Explanation,
			&i.Trace,
			&i.GapSummary,
			&i.Decision,
			&i.DecidedBy,
			&i.DecidedAt,
			&i.Rank,
			&i.CreatedAt,
			&i.ModelVersion,
			&i.DecisionNote,
		); err != nil {
			return nil, err
		}
		items = append(items, i)
	}
	if err := rows.Err(); err != nil {
		return nil, err
	}
	return items, nil
}

const listSlateMembersWithNames = `-- name: ListSlateMembersWithNames :many
SELECT sm.organization_id, sm.slate_id, sm.candidate_id, sm.total_score, sm.band, sm.clearance_score, sm.skills_score, sm.certs_score, sm.customer_score, sm.experience_score, sm.location_score, sm.explanation, sm.trace, sm.gap_summary, sm.decision, sm.decided_by, sm.decided_at, sm.rank, sm.created_at, sm.model_version, sm.decision_note, c.full_name
FROM slate_members sm
JOIN candidates c ON c.organization_id = sm.organization_id AND c.id = sm.candidate_id
WHERE sm.slate_id = $1
ORDER BY sm.rank NULLS LAST, sm.total_score DESC, sm.candidate_id
`

type ListSlateMembersWithNamesRow struct {
	OrganizationID  uuid.UUID       `json:"organization_id"`
	SlateID         uuid.UUID       `json:"slate_id"`
	CandidateID     uuid.UUID       `json:"candidate_id"`
	TotalScore      decimal.Decimal `json:"total_score"`
	Band            string          `json:"band"`
	ClearanceScore  decimal.Decimal `json:"clearance_score"`
	SkillsScore     decimal.Decimal `json:"skills_score"`
	CertsScore      decimal.Decimal `json:"certs_score"`
	CustomerScore   decimal.Decimal `json:"customer_score"`
	ExperienceScore decimal.Decimal `json:"experience_score"`
	LocationScore   decimal.Decimal `json:"location_score"`
	Explanation     string          `json:"explanation"`
	Trace           []byte          `json:"trace"`
	GapSummary      []byte          `json:"gap_summary"`
	Decision        string          `json:"decision"`
	DecidedBy       *uuid.UUID      `json:"decided_by"`
	DecidedAt       *time.Time      `json:"decided_at"`
	Rank            *int32          `json:"rank"`
	CreatedAt       time.Time       `json:"created_at"`
	ModelVersion    *string         `json:"model_version"`
	DecisionNote    *string         `json:"decision_note"`
	FullName        string          `json:"full_name"`
}

// The slate roster joined to the candidate name for the slateMATCH detail and the branded export. Both
// tables are RLS scoped to the caller's org, so the join cannot cross tenants.
func (q *Queries) ListSlateMembersWithNames(ctx context.Context, slateID uuid.UUID) ([]ListSlateMembersWithNamesRow, error) {
	rows, err := q.db.Query(ctx, listSlateMembersWithNames, slateID)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	items := []ListSlateMembersWithNamesRow{}
	for rows.Next() {
		var i ListSlateMembersWithNamesRow
		if err := rows.Scan(
			&i.OrganizationID,
			&i.SlateID,
			&i.CandidateID,
			&i.TotalScore,
			&i.Band,
			&i.ClearanceScore,
			&i.SkillsScore,
			&i.CertsScore,
			&i.CustomerScore,
			&i.ExperienceScore,
			&i.LocationScore,
			&i.Explanation,
			&i.Trace,
			&i.GapSummary,
			&i.Decision,
			&i.DecidedBy,
			&i.DecidedAt,
			&i.Rank,
			&i.CreatedAt,
			&i.ModelVersion,
			&i.DecisionNote,
			&i.FullName,
		); err != nil {
			return nil, err
		}
		items = append(items, i)
	}
	if err := rows.Err(); err != nil {
		return nil, err
	}
	return items, nil
}

const listSlatesForRequirement = `-- name: ListSlatesForRequirement :many
SELECT id, organization_id, requirement_id, name, status, created_by, created_at, updated_at FROM slates WHERE requirement_id = $1 ORDER BY created_at DESC, id
`

func (q *Queries) ListSlatesForRequirement(ctx context.Context, requirementID uuid.UUID) ([]Slate, error) {
	rows, err := q.db.Query(ctx, listSlatesForRequirement, requirementID)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	items := []Slate{}
	for rows.Next() {
		var i Slate
		if err := rows.Scan(
			&i.ID,
			&i.OrganizationID,
			&i.RequirementID,
			&i.Name,
			&i.Status,
			&i.CreatedBy,
			&i.CreatedAt,
			&i.UpdatedAt,
		); err != nil {
			return nil, err
		}
		items = append(items, i)
	}
	if err := rows.Err(); err != nil {
		return nil, err
	}
	return items, nil
}

const setSlateMemberDecision = `-- name: SetSlateMemberDecision :one
UPDATE slate_members
SET decision = $3, decided_by = $4, decision_note = $5, decided_at = now()
WHERE slate_id = $1 AND candidate_id = $2
RETURNING organization_id, slate_id, candidate_id, total_score, band, clearance_score, skills_score, certs_score, customer_score, experience_score, location_score, explanation, trace, gap_summary, decision, decided_by, decided_at, rank, created_at, model_version, decision_note
`

type SetSlateMemberDecisionParams struct {
	SlateID      uuid.UUID  `json:"slate_id"`
	CandidateID  uuid.UUID  `json:"candidate_id"`
	Decision     string     `json:"decision"`
	DecidedBy    *uuid.UUID `json:"decided_by"`
	DecisionNote *string    `json:"decision_note"`
}

// Human-in-the-loop: a person approves/rejects each member, optionally with a note. Never auto-decided.
func (q *Queries) SetSlateMemberDecision(ctx context.Context, arg SetSlateMemberDecisionParams) (SlateMember, error) {
	row := q.db.QueryRow(ctx, setSlateMemberDecision,
		arg.SlateID,
		arg.CandidateID,
		arg.Decision,
		arg.DecidedBy,
		arg.DecisionNote,
	)
	var i SlateMember
	err := row.Scan(
		&i.OrganizationID,
		&i.SlateID,
		&i.CandidateID,
		&i.TotalScore,
		&i.Band,
		&i.ClearanceScore,
		&i.SkillsScore,
		&i.CertsScore,
		&i.CustomerScore,
		&i.ExperienceScore,
		&i.LocationScore,
		&i.Explanation,
		&i.Trace,
		&i.GapSummary,
		&i.Decision,
		&i.DecidedBy,
		&i.DecidedAt,
		&i.Rank,
		&i.CreatedAt,
		&i.ModelVersion,
		&i.DecisionNote,
	)
	return i, err
}

const updateSlateStatus = `-- name: UpdateSlateStatus :one
UPDATE slates SET status = $2, updated_at = now() WHERE id = $1 RETURNING id, organization_id, requirement_id, name, status, created_by, created_at, updated_at
`

type UpdateSlateStatusParams struct {
	ID     uuid.UUID `json:"id"`
	Status string    `json:"status"`
}

func (q *Queries) UpdateSlateStatus(ctx context.Context, arg UpdateSlateStatusParams) (Slate, error) {
	row := q.db.QueryRow(ctx, updateSlateStatus, arg.ID, arg.Status)
	var i Slate
	err := row.Scan(
		&i.ID,
		&i.OrganizationID,
		&i.RequirementID,
		&i.Name,
		&i.Status,
		&i.CreatedBy,
		&i.CreatedAt,
		&i.UpdatedAt,
	)
	return i, err
}