Function bodies 69 total

  protected void doFilterInternal(
      @NonNull HttpServletRequest request,
      @NonNull HttpServletResponse response,
      @NonNull FilterChain filterChain)
      throws ServletException, IOException {

    String authHeader = request.getHeader(HttpHeaders.AUTHORIZATION);
    if (authHeader != null && authHeader.startsWith(BEARER_PREFIX)) {
      String token = authHeader.substring(BEARER_PREFIX.length());
      try {
        Jwt jwt = jwtDecoder.decode(token);
        SecurityContextHolder.getContext().setAuthentication(new JwtAuthenticationToken(jwt));
      } catch (JwtException e) {
        SecurityContextHolder.clearContext();
      }
    }

    try {
      filterChain.doFilter(request, response);
    } finally {
      SecurityContextHolder.clearContext();
    }
  }

  public SqsTemplate sqsTemplate(SqsAsyncClient sqsAsyncClient, ObjectMapper objectMapper) {
    return SqsTemplate.builder()
        .sqsAsyncClient(sqsAsyncClient)
        .configureDefaultConverter(
            converter -> {
              converter.setObjectMapper(objectMapper);
              converter.setPayloadTypeHeaderValueFunction(message -> null);
            })
        .build();
  }

  public SqsMessagingMessageConverter sqsMessagingMessageConverter(ObjectMapper objectMapper) {
    SqsMessagingMessageConverter converter = new SqsMessagingMessageConverter();
    converter.setObjectMapper(objectMapper);
    converter.setPayloadTypeMapper(message -> null);
    return converter;
  }

  public void handleModerationEvent(ModerationEvent event) {
    switch (event) {
      case VideoApprovedEvent approved -> handleVideoApproved(approved);
      case VideoRejectedEvent rejected -> handleVideoRejected(rejected);
    }
  }

  private void handleVideoApproved(VideoApprovedEvent event) {
    log.info(
        "Received VideoApproved event from SQS: videoId={}, reviewerId={}",
        event.videoId(),
        event.reviewerId());
    videoService.updateVideoStatus(event.videoId(), VideoStatus.APPROVED, null);
    log.info("Updated video {} status to APPROVED", event.videoId());
  }

  private void handleVideoRejected(VideoRejectedEvent event) {
    log.info(
        "Received VideoRejected event from SQS: videoId={}, reviewerId={}, reason={}",
        event.videoId(),
        event.reviewerId(),
        event.reason());
    videoService.updateVideoStatus(event.videoId(), VideoStatus.REJECTED, event.reason());
    log.info("Updated video {} status to REJECTED (reason: {})", event.videoId(), event.reason());
  }

  public void publishVideoSubmitted(
      Video video, String submitterTrustTier, List<UUID> locationIds) {
    VideoSubmittedEvent event =
        new VideoSubmittedEvent(
            video.getId(),
            video.getSubmittedBy(),
            submitterTrustTier,
            video.getTitle(),
            video.getAmendments().stream().map(Amendment::name).collect(Collectors.toSet()),
            locationIds,
            Instant.now());

    log.info(
        "Publishing VideoSubmitted event for video {} to SQS queue {}",
        video.getId(),
        videoEventsQueue);
    try {
      sqsTemplate.send(videoEventsQueue, event);
      sqsTemplate.send(userVideoEventsQueue, event);
      log.debug("Published VideoSubmitted event: {}", event);
    } catch (Exception e) {
      log.error(
          "Failed to publish VideoSubmitted event for video {}: {}",
          video.getId(),
          e.getMessage(),
          e);
      throw e;
    }
  }

  public void publishVideoStatusChanged(
      UUID videoId,
      UUID submittedBy,
      List<UUID> locationIds,
      String previousStatus,
      String newStatus) {
    VideoStatusChangedEvent event =
        new VideoStatusChangedEvent(
            videoId, submittedBy, locationIds, previousStatus, newStatus, Instant.now());

    log.info(
        "Publishing VideoStatusChanged event for video {} ({} -> {}) to SQS queue {}",
        videoId,
        previousStatus,
        newStatus,
        videoStatusEventsQueue);
    try {
      sqsTemplate.send(videoStatusEventsQueue, event);
      sqsTemplate.send(userVideoStatusEventsQueue, event);
      log.debug("Published VideoStatusChanged event: {}", event);
    } catch (Exception e) {
      log.error(
          "Failed to publish VideoStatusChanged event for video {}: {}",
          videoId,
          e.getMessage(),
          e);
      throw e;
    }
  }

public record VideoStatusChangedEvent(
    UUID videoId,
    UUID submittedBy,
    List<UUID> locationIds,
    String previousStatus,
    String newStatus,
    Instant timestamp) {}

public record VideoSubmittedEvent(
    UUID videoId,
    UUID submitterId,
    String submitterTrustTier,
    String title,
    Set<String> amendments,
    List<UUID> locationIds,
    Instant timestamp) {}

  public ResponseEntity<ErrorResponse> handleInvalidYouTubeUrl(InvalidYouTubeUrlException ex) {
    return ResponseEntity.status(HttpStatus.BAD_REQUEST)
        .body(
            new ErrorResponse(
                "INVALID_YOUTUBE_URL", ex.getMessage(), null, UUID.randomUUID().toString()));
  }

  public ResponseEntity<ErrorResponse> handleYouTubeVideoNotFound(
      YouTubeVideoNotFoundException ex) {
    return ResponseEntity.status(HttpStatus.UNPROCESSABLE_ENTITY)
        .body(
            new ErrorResponse(
                "YOUTUBE_VIDEO_UNAVAILABLE", ex.getMessage(), null, UUID.randomUUID().toString()));
  }

  public ResponseEntity<ErrorResponse> handleLocationNotFound(LocationNotFoundException ex) {
    return ResponseEntity.status(HttpStatus.NOT_FOUND)
        .body(
            new ErrorResponse(
                "LOCATION_NOT_FOUND", ex.getMessage(), null, UUID.randomUUID().toString()));
  }

  public ResponseEntity<ErrorResponse> handleLocationAlreadyLinked(
      LocationAlreadyLinkedException ex) {
    return ResponseEntity.status(HttpStatus.CONFLICT)
        .body(
            new ErrorResponse(
                "LOCATION_ALREADY_LINKED", ex.getMessage(), null, UUID.randomUUID().toString()));
  }

  public ResponseEntity<ErrorResponse> handleMetadataExtraction(MetadataExtractionException ex) {
    return ResponseEntity.status(HttpStatus.SERVICE_UNAVAILABLE)
        .body(
            new ErrorResponse(
                "AI_SERVICE_UNAVAILABLE", ex.getMessage(), null, UUID.randomUUID().toString()));
  }

  public ResponseEntity<ErrorResponse> handleCircuitBreakerOpen(CallNotPermittedException ex) {
    return ResponseEntity.status(HttpStatus.SERVICE_UNAVAILABLE)
        .body(
            new ErrorResponse(
                "SERVICE_UNAVAILABLE", ex.getMessage(), null, UUID.randomUUID().toString()));
  }

  public ResponseEntity<ErrorResponse> handleValidation(MethodArgumentNotValidException ex) {
    List<FieldError> details =
        ex.getBindingResult().getFieldErrors().stream()
            .map(e -> new FieldError(e.getField(), e.getDefaultMessage()))
            .toList();
    return ResponseEntity.status(HttpStatus.BAD_REQUEST)
        .body(
            new ErrorResponse(
                VALIDATION_ERROR,
                "Request validation failed",
                details,
                UUID.randomUUID().toString()));
  }

  public ResponseEntity<ErrorResponse> handleConstraintViolation(ConstraintViolationException ex) {
    List<FieldError> details =
        ex.getConstraintViolations().stream()
            .map(v -> new FieldError(v.getPropertyPath().toString(), v.getMessage()))
            .toList();
    return ResponseEntity.status(HttpStatus.BAD_REQUEST)
        .body(
            new ErrorResponse(
                VALIDATION_ERROR,
                "Request validation failed",
                details,
                UUID.randomUUID().toString()));
  }

  public ResponseEntity<ErrorResponse> handleMessageNotReadable(
      HttpMessageNotReadableException ignored) {
    return ResponseEntity.status(HttpStatus.BAD_REQUEST)
        .body(
            new ErrorResponse(
                VALIDATION_ERROR,
                "Malformed or missing request body",
                null,
                UUID.randomUUID().toString()));
  }

  public Optional<LocationSummary> getLocation(UUID locationId) {
    try {
      return Optional.ofNullable(
          webClient
              .get()
              .uri("/locations/{id}", locationId)
              .retrieve()
              .bodyToMono(LocationSummary.class)
              .block());
    } catch (WebClientResponseException.NotFound e) {
      return Optional.empty();
    }
  }

  public MetadataExtractionService(AnthropicProperties properties, ObjectMapper objectMapper) {
    this.properties = properties;
    this.objectMapper = objectMapper;
    if (properties.getApiKey() == null || properties.getApiKey().isBlank()) {
      this.client = null;
    } else {
      this.client =
          AnthropicOkHttpClient.builder()
              .apiKey(properties.getApiKey())
              .timeout(properties.getTimeout())
              .build();
    }
  }

  public ExtractionResult extract(String title, String description, String publishedAt) {
    if (client == null) {
      throw new MetadataExtractionException(
          "AI extraction is not configured. Set the ANTHROPIC_API_KEY environment variable.");
    }

    String userMessage =
        USER_PROMPT_TEMPLATE
            .replace("{{title}}", title != null ? title : "")
            .replace("{{description}}", description != null ? description : "")
            .replace("{{published}}", publishedAt != null ? publishedAt : "unknown");

    log.debug("Extraction request for video: {}", title);
    log.debug("User message sent to Claude:\n{}", userMessage);

    try {
      MessageCreateParams params =
          MessageCreateParams.builder()
              .model(properties.getModel())
              .maxTokens(properties.getMaxTokens())
              .addUserMessage(userMessage)
              .build();

      Message response = client.messages().create(params);

      String text = ex

  private String extractText(Message response) {
    for (ContentBlock block : response.content()) {
      if (block.isText()) {
        return block.asText().text();
      }
    }
    throw new MetadataExtractionException("No text content in AI response");
  }

  private String extractJson(String text) {
    String trimmed = text.strip();

    // Handle code fences if present
    if (trimmed.startsWith("```")) {
      int firstNewline = trimmed.indexOf('\n');
      if (firstNewline >= 0) {
        int lastFence = trimmed.lastIndexOf("```");
        if (lastFence > firstNewline) {
          trimmed = trimmed.substring(firstNewline + 1, lastFence).strip();
        }
      }
    }

    // Find the last '}' and walk back to find its matching '{'
    int lastBrace = trimmed.lastIndexOf('}');
    if (lastBrace < 0) {
      return trimmed;
    }

    int depth = 0;
    for (int i = lastBrace; i >= 0; i--) {
      char c = trimmed.charAt(i);
      if (c == '}') {
        depth++;
      } else if (c == '{') {
        depth--;
        if (depth == 0) {
          return trimmed.substring(i, lastBrace + 1);
        }
      }
    }

    return trimmed;
  }

  public record ExtractionResult(
      List<String> amendments,
      List<String> participants,
      String videoDate,
      LocationSuggestion location,
      ConfidenceScores confidence) {}

  public List<VideoLocation> getVideoLocations(UUID videoId) {
    if (!videoRepository.existsById(videoId)) {
      throw new VideoNotFoundException(videoId);
    }
    return videoLocationRepository.findByVideoId(videoId);
  }

  public VideoLocation addLocation(
      UUID videoId, UUID locationId, boolean isPrimary, UUID currentUserId) {

    Video video =
        videoRepository.findById(videoId).orElseThrow(() -> new VideoNotFoundException(videoId));

    if (mayNotModify(video, currentUserId)) {
      throw new UnauthorizedException("You do not have permission to modify this video");
    }

    return addLocationInternal(video, locationId, isPrimary);
  }

  private VideoLocation addLocationInternal(Video video, UUID locationId, boolean isPrimary) {
    if (videoLocationRepository.existsByVideoIdAndLocationId(video.getId(), locationId)) {
      throw new LocationAlreadyLinkedException(video.getId(), locationId);
    }

    LocationSummary location =
        locationClient
            .getLocation(locationId)
            .orElseThrow(() -> new LocationNotFoundException(locationId));

    if (isPrimary) {
      videoLocationRepository.clearPrimaryForVideo(video.getId());
    }

    VideoLocation videoLocation = new VideoLocation();
    videoLocation.setVideo(video);
    videoLocation.setLocationId(locationId);
    videoLocation.setPrimary(isPrimary);
    videoLocation.setDisplayName(location.displayName());
    videoLocation.setCity(location.city());
    videoLocation.setState(location.state());
    if (location.coordinates() != null) {
      videoLocation.setLatitude(location.coordinates().latitude());
      videoLocation.setLongitude(loc

  public void removeLocation(UUID videoId, UUID locationId, UUID currentUserId) {
    Video video =
        videoRepository.findById(videoId).orElseThrow(() -> new VideoNotFoundException(videoId));

    if (mayNotModify(video, currentUserId)) {
      throw new UnauthorizedException("You do not have permission to modify this video");
    }

    doRemoveLocation(videoId, locationId);
  }

  private void doRemoveLocation(UUID videoId, UUID locationId) {
    VideoLocation location =
        videoLocationRepository
            .findByVideoIdAndLocationId(videoId, locationId)
            .orElseThrow(() -> new LocationNotFoundException(locationId));

    videoLocationRepository.delete(location);
  }

  private boolean mayNotModify(Video video, UUID currentUserId) {
    if (!video.getSubmittedBy().equals(currentUserId)) {
      return true;
    }
    return video.getStatus() == VideoStatus.APPROVED;
  }

  public Page<Video> listVideos(VideoStatus status, Pageable pageable) {
    if (status == null) {
      status = VideoStatus.APPROVED;
    }
    return videoRepository.findByStatusOrderByCreatedAtDesc(status, pageable);
  }

  public Page<Video> listVideosByUser(UUID userId, VideoStatus status, Pageable pageable) {
    if (status != null) {
      return videoRepository.findBySubmittedByAndStatus(userId, status, pageable);
    }
    return videoRepository.findBySubmittedBy(userId, pageable);
  }

  public Video createVideo(
      String youtubeUrl,
      Set<Amendment> amendments,
      Set<Participant> participants,
      LocalDate videoDate,
      UUID submittedBy,
      String submitterTrustTier,
      List<UUID> locationIds) {

    String videoId = youTubeService.extractVideoId(youtubeUrl);

    if (videoRepository.existsByYoutubeId(videoId)) {
      throw new VideoAlreadyExistsException(videoId);
    }

    YouTubeMetadata metadata = youTubeService.fetchMetadata(videoId);

    Video video = new Video();
    video.setYoutubeId(videoId);
    video.setTitle(metadata.title());
    video.setDescription(metadata.description());
    video.setThumbnailUrl(metadata.thumbnailUrl());
    video.setDurationSeconds(metadata.durationSeconds());
    video.setChannelId(metadata.channelId());
    video.setChannelName(metadata.channelName());
    video.setPublishedAt(metadata.publishedAt());
    video.setVideoDate(videoDate);
    video.setAmendments(amendments);
    video.setParticipants(par

  public Video updateVideo(
      UUID id,
      Set<Amendment> amendments,
      Set<Participant> participants,
      LocalDate videoDate,
      UUID currentUserId) {

    Video video = findVideoOrThrow(id);

    if (mayNotModify(video, currentUserId)) {
      throw new UnauthorizedException("You do not have permission to modify this video");
    }

    if (amendments != null && !amendments.isEmpty()) {
      video.setAmendments(amendments);
    }
    if (participants != null && !participants.isEmpty()) {
      video.setParticipants(participants);
    }
    if (videoDate != null) {
      video.setVideoDate(videoDate);
    }

    return videoRepository.save(video);
  }

  public void deleteVideo(UUID id, UUID currentUserId) {
    Video video = findVideoOrThrow(id);

    if (mayNotModify(video, currentUserId)) {
      throw new UnauthorizedException("You do not have permission to delete this video");
    }

    video.setStatus(VideoStatus.DELETED);
    videoRepository.save(video);
  }

  public Video updateVideoInternal(
      UUID id, Set<Amendment> amendments, Set<Participant> participants, LocalDate videoDate) {

    Video video = findVideoOrThrow(id);

    if (amendments != null && !amendments.isEmpty()) {
      video.setAmendments(amendments);
    }
    if (participants != null && !participants.isEmpty()) {
      video.setParticipants(participants);
    }
    if (videoDate != null) {
      video.setVideoDate(videoDate);
    }

    return videoRepository.save(video);
  }

  public Video updateVideoStatus(UUID id, VideoStatus newStatus, String rejectionReason) {
    Video video =
        videoRepository.findByIdWithLocations(id).orElseThrow(() -> new VideoNotFoundException(id));
    VideoStatus previousStatus = video.getStatus();
    video.setStatus(newStatus);
    if (rejectionReason != null) {
      video.setRejectionReason(rejectionReason);
    }
    Video saved = videoRepository.save(video);

    // Publish status change event for downstream services
    List<UUID> locationIds =
        saved.getLocations().stream().map(VideoLocation::getLocationId).toList();
    if (previousStatus != newStatus) {
      videoEventPublisher.publishVideoStatusChanged(
          saved.getId(),
          saved.getSubmittedBy(),
          locationIds,
          previousStatus.name(),
          newStatus.name());
    }

    return saved;
  }

  private boolean mayNotModify(Video video, UUID currentUserId) {
    if (!video.getSubmittedBy().equals(currentUserId)) {
      return true;
    }
    return video.getStatus() == VideoStatus.APPROVED;
  }

  public boolean canView(Video video, UUID currentUserId, String trustTier) {
    return switch (video.getStatus()) {
      case APPROVED -> true;
      case PENDING, REJECTED -> isOwnerOrModerator(video, currentUserId, trustTier);
      case DELETED -> "ADMIN".equals(trustTier);
    };
  }

  private boolean isOwnerOrModerator(Video video, UUID currentUserId, String trustTier) {
    if (video.getSubmittedBy().equals(currentUserId)) {
      return true;
    }
    return Set.of("MODERATOR", "ADMIN").contains(trustTier);
  }

  public String extractVideoId(String url) {
    if (url == null || url.isBlank()) {
      throw new InvalidYouTubeUrlException(url);
    }

    for (Pattern pattern : YOUTUBE_PATTERNS) {
      Matcher matcher = pattern.matcher(url);
      if (matcher.find()) {
        return matcher.group(1);
      }
    }

    throw new InvalidYouTubeUrlException(url);
  }

  public YouTubeMetadata fetchMetadata(String videoId) {
    try {
      var response =
          webClient
              .get()
              .uri(
                  uriBuilder ->
                      uriBuilder
                          .path("/videos")
                          .queryParam("id", videoId)
                          .queryParam("key", properties.getApiKey())
                          .queryParam("part", "snippet,contentDetails,recordingDetails")
                          .build())
              .retrieve()
              .bodyToMono(YouTubeApiResponse.class)
              .block(properties.getTimeout());

      if (response == null || response.items() == null || response.items().isEmpty()) {
        throw new YouTubeVideoNotFoundException(videoId);
      }

      var item = response.items().getFirst();
      var snippet = item.snippet();
      var contentDetails = item.contentDetails();
      var recordingDetails = item.recordingDetails();

      return new YouTubeMeta

  private String selectBestThumbnail(Thumbnails thumbnails) {
    if (thumbnails.maxres() != null) return thumbnails.maxres().url();
    if (thumbnails.high() != null) return thumbnails.high().url();
    if (thumbnails.medium() != null) return thumbnails.medium().url();
    if (thumbnails.standard() != null) return thumbnails.standard().url();
    return thumbnails.defaultThumb() != null ? thumbnails.defaultThumb().url() : null;
  }

  private Integer parseDuration(String isoDuration) {
    if (isoDuration == null) return null;
    try {
      return (int) Duration.parse(isoDuration).toSeconds();
    } catch (Exception e) {
      return null;
    }
  }

  record Snippet(
      String title,
      String description,
      String channelId,
      String channelTitle,
      String publishedAt,
      Thumbnails thumbnails) {}

  record Thumbnails(
      Thumbnail defaultThumb,
      Thumbnail medium,
      Thumbnail high,
      Thumbnail standard,
      Thumbnail maxres) {}

  public ResponseEntity<Void> updateVideo(
      @PathVariable UUID id, @RequestBody UpdateVideoRequest request) {
    Set<Amendment> amendments =
        request.amendments() != null
            ? request.amendments().stream().map(Amendment::valueOf).collect(Collectors.toSet())
            : null;
    Set<Participant> participants =
        request.participants() != null
            ? request.participants().stream().map(Participant::valueOf).collect(Collectors.toSet())
            : null;

    videoService.updateVideoInternal(id, amendments, participants, request.videoDate());
    return ResponseEntity.noContent().build();
  }

  public ResponseEntity<Void> updateStatus(
      @PathVariable UUID id, @RequestBody UpdateStatusRequest request) {
    VideoStatus status = VideoStatus.valueOf(request.status());
    videoService.updateVideoStatus(id, status, null);
    return ResponseEntity.noContent().build();
  }

  public ResponseEntity<VideoLocation> addLocation(
      @PathVariable UUID id, @RequestBody AddLocationRequest request) {
    VideoLocation location =
        videoLocationService.addLocationInternal(id, request.locationId(), request.isPrimary());
    return ResponseEntity.status(HttpStatus.CREATED).body(location);
  }