brackt/app/models/participant-result.ts

import { eq, and, inArray } from "drizzle-orm";
import { database } from "~/database/context";
import * as schema from "~/database/schema";

export type ParticipantResult = typeof schema.seasonParticipantResults.$inferSelect;
export type ParticipantResultWithParticipant = ParticipantResult & {
  participant: { id: string; name: string } | null;
};
export type NewParticipantResult = typeof schema.seasonParticipantResults.$inferInsert;

export async function createParticipantResult(
  data: NewParticipantResult
): Promise<ParticipantResult> {
  const db = database();
  const [result] = await db
    .insert(schema.seasonParticipantResults)
    .values(data)
    .returning();
  return result;
}

export async function createManyParticipantResults(
  data: NewParticipantResult[]
): Promise<ParticipantResult[]> {
  const db = database();
  return await db
    .insert(schema.seasonParticipantResults)
    .values(data)
    .returning();
}

export async function findParticipantResultById(
  id: string
): Promise<ParticipantResult | undefined> {
  const db = database();
  return await db.query.seasonParticipantResults.findFirst({
    where: eq(schema.seasonParticipantResults.id, id),
    with: {
      participant: true,
      sportsSeason: {
        with: {
          sport: true,
        },
      },
    },
  });
}

export async function findParticipantResultByParticipantId(
  participantId: string
): Promise<ParticipantResult | undefined> {
  const db = database();
  return await db.query.seasonParticipantResults.findFirst({
    where: eq(schema.seasonParticipantResults.participantId, participantId),
    with: {
      participant: true,
      sportsSeason: {
        with: {
          sport: true,
        },
      },
    },
  });
}

export async function findParticipantResultsBySportsSeasonId(
  sportsSeasonId: string
): Promise<ParticipantResultWithParticipant[]> {
  const db = database();
  return await db.query.seasonParticipantResults.findMany({
    where: eq(schema.seasonParticipantResults.sportsSeasonId, sportsSeasonId),
    orderBy: (results, { asc }) => [asc(results.finalPosition)],
    with: {
      participant: true,
    },
  });
}

export async function updateParticipantResult(
  id: string,
  data: Partial<NewParticipantResult>
): Promise<ParticipantResult> {
  const db = database();
  const [result] = await db
    .update(schema.seasonParticipantResults)
    .set({ ...data, updatedAt: new Date() })
    .where(eq(schema.seasonParticipantResults.id, id))
    .returning();
  return result;
}

export async function deleteParticipantResult(id: string): Promise<void> {
  const db = database();
  await db.delete(schema.seasonParticipantResults).where(eq(schema.seasonParticipantResults.id, id));
}

export async function deleteParticipantResultsBySportsSeasonId(
  sportsSeasonId: string,
  providedDb?: ReturnType<typeof database>
): Promise<void> {
  const db = providedDb || database();
  await db
    .delete(schema.seasonParticipantResults)
    .where(eq(schema.seasonParticipantResults.sportsSeasonId, sportsSeasonId));
}

/**
 * Delete the results of specific participants within one sports season.
 *
 * The season-wide delete above is too blunt for a single bracket: results are keyed by
 * sports season, not by event, so wiping the season takes every other event's placements
 * with it. Scoping to the participants a bracket actually holds lets reprocess-bracket
 * rebuild that bracket from scratch while leaving the rest of the season alone.
 *
 * No-ops on an empty id list — `inArray` with no values is not a valid SQL predicate.
 */
export async function deleteParticipantResultsForParticipants(
  sportsSeasonId: string,
  participantIds: string[],
  providedDb?: ReturnType<typeof database>
): Promise<void> {
  if (participantIds.length === 0) return;
  const db = providedDb || database();
  await db
    .delete(schema.seasonParticipantResults)
    .where(
      and(
        eq(schema.seasonParticipantResults.sportsSeasonId, sportsSeasonId),
        inArray(schema.seasonParticipantResults.participantId, participantIds)
      )
    );
}

/**
 * Set result for a participant in a sports season
 * Points are calculated on-demand based on each fantasy league's scoring rules
 */
export async function setParticipantResult(
  participantId: string,
  sportsSeasonId: string,
  finalPosition: number,
  qualifyingPoints?: number,
  notes?: string
): Promise<ParticipantResult> {
  const db = database();

  // Check if result already exists
  const existing = await db.query.seasonParticipantResults.findFirst({
    where: and(
      eq(schema.seasonParticipantResults.participantId, participantId),
      eq(schema.seasonParticipantResults.sportsSeasonId, sportsSeasonId)
    ),
  });

  if (existing) {
    // Update existing result
    return await updateParticipantResult(existing.id, {
      finalPosition,
      qualifyingPoints: qualifyingPoints?.toString(),
      notes,
    });
  } else {
    // Create new result
    return await createParticipantResult({
      participantId,
      sportsSeasonId,
      finalPosition,
      qualifyingPoints: qualifyingPoints?.toString(),
      notes,
    });
  }
}