Managing Tournaments

async function removeTeam(teamId: string) {
  if (tournament.status === 'Live') {
    throw new Error('Cannot remove teams after tournament starts');
  }
  
  await apolloClient.mutate({
    mutation: gql`
      mutation RemoveTeam($id: uuid!) {
        delete_tournament_teams_by_pk(id: $id) {
          id
        }
      }
    `,
    variables: { id: teamId }
  });
}

interface BulkSchedule {
  bracket_id: string;
  scheduled_at: string;
}

async function bulkScheduleMatches(schedules: BulkSchedule[]) {
  const updates = schedules.map(({ bracket_id, scheduled_at }) => ({
    where: { id: { _eq: bracket_id } },
    _set: { scheduled_at }
  }));
  
  await apolloClient.mutate({
    mutation: gql`
      mutation BulkSchedule($updates: [tournament_brackets_updates!]!) {
        update_tournament_brackets_many(updates: $updates) {
          affected_rows
        }
      }
    `,
    variables: { updates }
  });
}

// Example: Schedule all Round 1 matches 30 minutes apart
const round1Matches = brackets.filter(b => b.round === 1);
const startTime = new Date('2024-01-20T18:00:00Z');

const schedules = round1Matches.map((bracket, index) => ({
  bracket_id: bracket.id,
  scheduled_at: new Date(
    startTime.getTime() + index * 30 * 60 * 1000
  ).toISOString()
}));

await bulkScheduleMatches(schedules);

<template>
  <Card class="p-4 mb-4">
    <div class="grid grid-cols-1 md:grid-cols-3 gap-4">
      <!-- Tournament ID Search -->
      <FormField name="tournamentId">
        <FormLabel>Search by ID</FormLabel>
        <Input 
          v-model="form.values.tournamentId"
          @update:model-value="onFilterChange"
          placeholder="Enter tournament ID"
        />
      </FormField>
      
      <!-- Tournament Name Search -->
      <FormField name="tournamentName">
        <FormLabel>Search by Name</FormLabel>
        <Input 
          v-model="form.values.tournamentName"
          @update:model-value="onFilterChange"
          placeholder="Enter tournament name"
        />
      </FormField>
      
      <!-- Status Filter -->
      <FormField name="statuses">
        <FormLabel>Filter by Status</FormLabel>
        <Select
          v-model="form.values.statuses"
          @update:model-value="onStatusChange"
          multiple
        >
          <SelectTrigger>
            <SelectValue placeholder="Select statuses" />
          </SelectTrigger>
          <SelectContent>
            <SelectItem
              v-for="status in tournamentStatusOptions"
              :value="status.value"
            >
              {{ status.label }}
            </SelectItem>
          </SelectContent>
        </Select>
      </FormField>
    </div>
    
    <!-- Additional Filters -->
    <div class="flex items-center justify-between mt-4">
      <div class="flex items-center space-x-2">
        <Switch v-model="showOnlyMyTournaments" />
        <Label>Only show my tournaments</Label>
      </div>
      
      <Button variant="outline" @click="resetFilters">
        Reset Filters
      </Button>
    </div>
  </Card>
</template>

function getWhereClause() {
  const filterConditions: any = {};
  
  // ID filter
  if (form.values.tournamentId?.trim()) {
    const tournamentId = form.values.tournamentId.trim();
    if (validateUUID(tournamentId)) {
      filterConditions.id = { _eq: tournamentId };
    } else {
      // Return no results for invalid UUID
      return { id: { _eq: '00000000-0000-0000-0000-000000000000' } };
    }
  }
  
  // Name filter (case-insensitive partial match)
  if (form.values.tournamentName?.trim()) {
    filterConditions.name = {
      _ilike: `%${form.values.tournamentName.trim()}%`
    };
  }
  
  // Status filter
  if (form.values.statuses?.length > 0) {
    filterConditions.status = {
      _in: form.values.statuses
    };
  }
  
  // My tournaments only
  if (showOnlyMyTournaments) {
    filterConditions.is_organizer = { _eq: true };
  }
  
  return filterConditions;
}

<template>
  <div class="flex items-center space-x-4">
    <Select v-model="sortField" @update:model-value="onSortChange">
      <SelectTrigger class="w-40">
        <SelectValue />
      </SelectTrigger>
      <SelectContent>
        <SelectItem value="created_at">Created At</SelectItem>
        <SelectItem value="start">Start Time</SelectItem>
      </SelectContent>
    </Select>
    
    <Button
      variant="outline"
      @click="toggleSortDirection"
      class="flex items-center space-x-1"
    >
      <ArrowUpIcon v-if="sortDirection === 'desc'" class="w-4 h-4" />
      <ArrowDownIcon v-else class="w-4 h-4" />
      <span>{{ sortDirection === 'desc' ? 'Newest First' : 'Oldest First' }}</span>
    </Button>
  </div>
</template>

<script>
function getSortOrder() {
  const orderBy = sortDirection === 'desc' ? order_by.desc : order_by.asc;
  switch (sortField) {
    case 'created_at':
      return { created_at: orderBy };
    case 'start':
      return { start: orderBy };
    default:
      return { created_at: orderBy };
  }
}
</script>

interface DiscordNotification {
  content?: string;  // Role ping if configured
  embeds: [{
    title: string;
    description: string;
    color: number;
    fields: {
      name: string;
      value: string;
      inline?: boolean;
    }[];
    timestamp: string;
    url?: string;
  }];
}

// Example: Match Live notification
const notification: DiscordNotification = {
  content: roleId ? `<@&${roleId}>` : undefined,
  embeds: [{
    title: '🔴 Match is Live!',
    description: `${team1.name} vs ${team2.name}`,
    color: 0xFF0000,
    fields: [
      {
        name: 'Tournament',
        value: tournament.name,
        inline: true
      },
      {
        name: 'Format',
        value: `Best of ${match.options.best_of}`,
        inline: true
      },
      {
        name: 'Round',
        value: getRoundLabel(bracket.round),
        inline: true
      }
    ],
    timestamp: new Date().toISOString(),
    url: `https://5stack.gg/matches/${match.id}`
  }]
};

// Update tournament status
const UPDATE_TOURNAMENT_STATUS = gql`
  mutation UpdateTournamentStatus(
    $id: uuid!
    $status: e_tournament_status_enum!
  ) {
    update_tournaments_by_pk(
      pk_columns: { id: $id }
      _set: { status: $status }
    ) {
      id
      status
    }
  }
`;

// Add tournament team
const ADD_TOURNAMENT_TEAM = gql`
  mutation AddTeam($object: tournament_teams_insert_input!) {
    insert_tournament_teams_one(object: $object) {
      id
      name
      seed
    }
  }
`;

// Update team seed
const UPDATE_TEAM_SEED = gql`
  mutation UpdateTeamSeed($id: uuid!, $seed: Int) {
    update_tournament_teams_by_pk(
      pk_columns: { id: $id }
      _set: { seed: $seed }
    ) {
      id
      seed
    }
  }
`;

// Schedule bracket
const SCHEDULE_BRACKET = gql`
  mutation ScheduleBracket(
    $bracket_id: uuid!
    $scheduled_at: timestamptz!
  ) {
    update_tournament_brackets_by_pk(
      pk_columns: { id: $bracket_id }
      _set: { scheduled_at: $scheduled_at }
    ) {
      id
      scheduled_at
    }
  }
`;

// Delete tournament
const DELETE_TOURNAMENT = gql`
  mutation DeleteTournament($tournament_id: uuid!) {
    deleteTournament(tournament_id: $tournament_id) {
      success
    }
  }
`;