package com.krylov.refound.service;

import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.krylov.refound.dto.AddressInfo;
import com.krylov.refound.dto.CachedPostPage;
import com.krylov.refound.dto.PostRequest;
import com.krylov.refound.dto.PostResponse;
import com.krylov.refound.entity.Image;
import com.krylov.refound.entity.Post;
import com.krylov.refound.entity.User;
import com.krylov.refound.enums.ErrorCode;
import com.krylov.refound.enums.PostCategory;
import com.krylov.refound.enums.PostStatus;
import com.krylov.refound.enums.PostType;
import com.krylov.refound.exception.ApiException;
import com.krylov.refound.mapper.PostMapper;
import com.krylov.refound.repository.ImageRepository;
import com.krylov.refound.repository.PostRepository;
import com.krylov.refound.service.redis.MapCacheService;
import com.krylov.refound.service.redis.PostCacheKeyGenerator;
import com.krylov.refound.service.redis.PostCacheService;
import com.krylov.refound.util.PostSpecification;
import com.krylov.refound.util.PostVisibility;
import java.time.Duration;
import java.time.LocalDateTime;
import java.util.Arrays;
import java.util.EnumSet;
import java.util.List;
import java.util.Set;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.PageImpl;
import org.springframework.data.domain.Pageable;
import org.springframework.data.jpa.domain.Specification;
import org.springframework.http.HttpStatus;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.util.StringUtils;
import org.springframework.web.multipart.MultipartFile;

@Service
@RequiredArgsConstructor
@Slf4j
public class PostService {
  // Статусы, которые показываются в публичной ленте. MODERATION и REJECTED видны
  // только владельцу (getPostsByUserId, getPostOnMapById), но не в общем фиде.
  private static final Set<PostStatus> FEED_VISIBLE_STATUSES = PostVisibility.FEED_VISIBLE_STATUSES;

  private final PostRepository postRepository;
  private final PostMapper mapper;
  private final ImageRepository imageRepository;
  private final GeocodingService geocodingService;
  private final UserService userService;
  private final FileStorageService fileStorageService;
  private final StatisticsService statisticsService;
  private final ObjectMapper objectMapper;
  private final PostCacheService postCacheService;
  private final PostCacheKeyGenerator postCacheKeyGenerator;
  private final MapCacheService mapCacheService;

  @Transactional
  public PostRequest create(PostRequest request, List<MultipartFile> images) {

    User currentUser = userService.getCurrentUser();

    Post post = mapper.toEntity(request);
    post.setCreatedAt(LocalDateTime.now());
    post.setStatus(PostStatus.MODERATION);
    post.setUser(currentUser);
    post.setIsReward(request.getReward());
    if (request.getLatitude() == null || request.getLongitude() == null) {
      post.setCity(request.getAddress());
    } else {
      AddressInfo address = geocodingService.getAddress(request.getLatitude().toString(), request.getLongitude().toString());
      post.setCity(address.city());
      post.setDistrict(address.district());
    }

    postRepository.save(post);
    log.info("Создан пост id={} пользователем userId={}, статус={}", post.getId(), currentUser.getId(), post.getStatus());

    int uploaded = attachImages(post, images);
    log.info("К посту id={} прикреплено {} изображений", post.getId(), uploaded);

    statisticsService.incrementCreated();
    postCacheService.invalidatePosts();
    mapCacheService.clearMapMarkersCache();
    return request;
  }

  public Page<PostResponse> getFeed(String search, Pageable pageable) {

    // Ключ содержит версию ленты, она читается до запроса в БД
    String cacheKey = postCacheKeyGenerator.feedKey(search, pageable);

    CachedPostPage cached = postCacheService.getFeed(cacheKey);

    if (cached != null) {
      log.debug("Feed cache HIT: {}", cacheKey);
      return new PageImpl<>(cached.getContent(), pageable, cached.getTotalElements());
    }

    log.debug("Feed cache MISS: {}", cacheKey);

    Specification<Post> spec = PostSpecification.hasSearch(search)
        .and((root, query, cb) ->
            root.get("status").in(FEED_VISIBLE_STATUSES)
        );

    Page<Post> postsPage = postRepository.findAll(spec, pageable);

    Page<PostResponse> responsePage = postsPage.map(post -> toResponse(post, true));

    CachedPostPage cachedPage = new CachedPostPage(
        responsePage.getContent(),
        responsePage.getNumber(),
        responsePage.getSize(),
        responsePage.getTotalElements(),
        responsePage.getTotalPages()
    );

    postCacheService.saveFeed(cacheKey, cachedPage, Duration.ofMinutes(2));
    return responsePage;
  }

  /**
   * Возвращает посты указанного пользователя (это НЕ поиск поста по его собственному id,
   * несмотря на то, как метод назывался раньше — getById). Если у вас уже есть контроллер,
   * вызывающий старое имя getById, переименуйте вызов на getPostsByUserId.
   * Владелец видит все свои посты (включая MODERATION и REJECTED), остальные — только
   * опубликованные (ACTIVE и CLOSED).
   */
  public List<PostResponse> getPostsByUserId(Long userId) {
    boolean owner = isCurrentUser(userId);

    List<Post> posts = postRepository.findByUserId(userId).stream()
        .filter(post -> owner || FEED_VISIBLE_STATUSES.contains(post.getStatus()))
        .toList();

    if (posts.isEmpty()) {
      return List.of();
    }

    return posts.stream()
        .map(post -> toResponse(post, false))
        .toList();
  }

  /**
   * Удобный overload для контроллера, принимающего multipart-поля по отдельности.
   * @Transactional стоит и здесь, и на основном update() — раньше этот метод вызывал
   * update(id, request, images, existingUrls) через this, что было self-invocation
   * и обходило Spring-прокси: @Transactional на вызываемом методе не срабатывал.
   */
  @Transactional
  public PostResponse update(Long id, String type, String title, String address, Double latitude,
      Double longitude, String description, String category, String phone, Boolean reward,
      String rewardText, List<MultipartFile> images, String existingImagesJson) {

    PostRequest request = new PostRequest();
    request.setType(PostType.from(type));
    request.setTitle(title);
    request.setDescription(description);
    request.setCategory(category);
    request.setPhone(phone);
    request.setLatitude(latitude);
    request.setLongitude(longitude);
    request.setAddress(address);
    request.setReward(reward);
    request.setRewardText(rewardText);

    List<String> existingUrls = parseExistingImages(existingImagesJson);

    return doUpdate(id, request, images, existingUrls);
  }

  private PostResponse doUpdate(Long id, PostRequest request, List<MultipartFile> images, List<String> existingUrls) {
    // Проверка владельца выполняется до любых изменений и загрузки файлов
    Post post = findOwnedPost(id);

    post.setStatus(PostStatus.MODERATION);
    post.setTitle(request.getTitle());
    post.setDescription(request.getDescription());
    if (request.getCategory() != null) {
      post.setCategory(PostCategory.fromDisplayName(request.getCategory()));
    }
    post.setPhone(request.getPhone());
    post.setType(request.getType());
    post.setIsReward(request.getReward());
    post.setReward(request.getRewardText());

    if (request.getLatitude() != null && request.getLongitude() != null) {
      post.setLatitude(request.getLatitude());
      post.setLongitude(request.getLongitude());
      AddressInfo address = geocodingService.getAddress(
          request.getLatitude().toString(), request.getLongitude().toString());

      post.setCity(address.city());
      post.setDistrict(address.district());
    } else {
      post.setCity(request.getAddress());
    }

    List<String> keepUrls = existingUrls != null ? existingUrls : List.of();

    List<Image> toRemove = post.getImages().stream()
        .filter(img -> !keepUrls.contains(img.getUrl()))
        .toList();

    removeImages(post, toRemove);

    int uploaded = attachImages(post, images);

    Post updated = postRepository.save(post);
    log.info("Обновлён пост id={}: удалено изображений={}, добавлено={}, статус={}", id, toRemove.size(), uploaded, updated.getStatus());
    postCacheService.invalidatePosts();
    mapCacheService.clearMapMarkersCache();
    log.info("redis cache invalidated in update");
    return mapper.toResponse(updated);
  }

  @Transactional
  public void delete(Long id) {
    Post post = findOwnedPost(id);

    // Без этого файлы останутся в MinIO мусором после удаления объявления
    post.getImages().forEach(img -> deleteFileQuietly(img.getUrl()));

    postRepository.delete(post);
    log.info("Удалён пост id={}, изображений={}", id, post.getImages().size());
    postCacheService.invalidatePosts();
    mapCacheService.clearMapMarkersCache();
    log.info("redis cache invalidated in delete");
  }

  @Transactional
  public PostResponse updateStatus(Long id, String statusString) {
    Post post = findOwnedPost(id);

    // Пост на модерации или отклонённый владелец не может сам перевести в ACTIVE:
    // иначе можно обойти модерацию (edit -> MODERATION -> updateStatus(ACTIVE))
    if (!FEED_VISIBLE_STATUSES.contains(post.getStatus())) {
      log.warn("Попытка сменить статус неопубликованного поста: postId={}, статус={}", id, post.getStatus());
      throw new ApiException(ErrorCode.FORBIDDEN, "Post is not published yet", HttpStatus.FORBIDDEN);
    }

    PostStatus newStatus = parseOwnerSettableStatus(statusString);

    if (post.getStatus() != PostStatus.CLOSED && newStatus == PostStatus.CLOSED) {
      statisticsService.incrementFound();
    }

    PostStatus previousStatus = post.getStatus();
    post.setStatus(newStatus);
    Post updated = postRepository.save(post);
    log.info("Статус поста id={} изменён: {} -> {}", id, previousStatus, newStatus);
    postCacheService.invalidatePosts();
    mapCacheService.clearMapMarkersCache();
    log.info("redis cache invalidated in update status");
    return mapper.toResponse(updated);
  }

  public List<PostResponse> searchByCity(String city) {
    if (!StringUtils.hasText(city)) {
      return List.of();
    }

    Specification<Post> spec = Specification.where(PostSpecification.cityOrDistrictLike(city))
        .and((root, query, cb) -> root.get("status").in(FEED_VISIBLE_STATUSES));

    List<Post> posts = postRepository.findAll(spec);
    if (posts.isEmpty()) {
      return List.of();
    }

    return posts.stream()
        .map(post -> toResponse(post, true))
        .toList();
  }

  public List<String> getCities() {
    return postRepository.findDistinctCities(FEED_VISIBLE_STATUSES);
  }

  /**
   * Находит пост и проверяет, что текущий пользователь — его владелец.
   * NOT_FOUND, если поста нет; FORBIDDEN, если пост чужой.
   */
  private Post findOwnedPost(Long id) {
    Post post = postRepository.findById(id)
        .orElseThrow(() -> new ApiException(ErrorCode.NOT_FOUND, "Post not found", HttpStatus.NOT_FOUND));

    User currentUser = userService.getCurrentUser();
    if (!post.getUser().getId().equals(currentUser.getId())) {
      log.warn("Попытка изменить чужой пост: postId={}, userId={}", id, currentUser.getId());
      throw new ApiException(ErrorCode.FORBIDDEN, "Only the post owner can modify this post", HttpStatus.FORBIDDEN);
    }
    return post;
  }

  /**
   * true, если запрос выполняет авторизованный пользователь с указанным id.
   * Для анонимного запроса возвращает false.
   */
  private boolean isCurrentUser(Long userId) {
    try {
      User currentUser = userService.getCurrentUser();
      return currentUser != null && currentUser.getId().equals(userId);
    } catch (ApiException e) {
      return false;
    }
  }

  private PostStatus parseOwnerSettableStatus(String statusString) {
    PostStatus newStatus;
    try {
      newStatus = PostStatus.valueOf(statusString.toUpperCase());
    } catch (IllegalArgumentException e) {
      throw new ApiException(ErrorCode.VALIDATION_ERROR, "Invalid status: " + statusString + ". Must be ACTIVE or CLOSED", HttpStatus.BAD_REQUEST);
    }

    if (!FEED_VISIBLE_STATUSES.contains(newStatus)) {
      throw new ApiException(ErrorCode.VALIDATION_ERROR, "Invalid status: " + statusString + ". Must be ACTIVE or CLOSED", HttpStatus.BAD_REQUEST);
    }

    return newStatus;
  }

  /**
   * Загружает файлы в MinIO и привязывает их к посту. Возвращает количество загруженных файлов.
   */
  private int attachImages(Post post, List<MultipartFile> images) {
    if (images == null || images.isEmpty()) {
      return 0;
    }

    int count = 0;
    for (MultipartFile image : images) {
      if (image == null || image.isEmpty()) {
        continue;
      }

      String objectKey = fileStorageService.uploadFile(image);

      Image img = new Image();
      img.setUrl(objectKey); // храним ключ MinIO, а не путь на диске
      img.setPost(post);
      imageRepository.save(img);
      post.getImages().add(img);
      count++;
    }
    return count;
  }

  private void removeImages(Post post, List<Image> toRemove) {
    toRemove.forEach(img -> deleteFileQuietly(img.getUrl()));
    post.getImages().removeAll(toRemove);
  }

  private void deleteFileQuietly(String objectKey) {
    try {
      fileStorageService.deleteFile(objectKey);
    } catch (Exception e) {
      // Не блокируем основную операцию из-за мусора в хранилище — это некритично,
      // но стоит завести алерт на такие warn-логи, если их станет много.
      log.warn("Не удалось удалить файл из хранилища: {}", objectKey, e);
    }
  }

  public PostResponse toResponse(Post post, boolean includeUserRole) {
    PostResponse response = mapper.toResponse(post);
    response.setReward(post.getIsReward());
    if (includeUserRole) {
      response.setUserRole(post.getUser().getRole());
    }
    return response;
  }

  private List<String> parseExistingImages(String existingImagesJson) {
    if (existingImagesJson == null) {
      return List.of();
    }
    try {
      return Arrays.asList(objectMapper.readValue(existingImagesJson, String[].class));
    } catch (JsonProcessingException e) {
      throw new ApiException(ErrorCode.VALIDATION_ERROR, "Некорректный формат existingImages", HttpStatus.BAD_REQUEST);
    }
  }

  public PostResponse getPostOnMapById(Long postId) {
    Post post = postRepository.findById(postId)
        .orElseThrow(() -> new ApiException(ErrorCode.NOT_FOUND, "Post not found", HttpStatus.NOT_FOUND));

    // Неопубликованный пост (MODERATION, REJECTED) виден только владельцу.
    // Остальным отвечаем 404, чтобы не раскрывать, что такой id существует
    if (!FEED_VISIBLE_STATUSES.contains(post.getStatus()) && !isCurrentUser(post.getUser().getId())) {
      throw new ApiException(ErrorCode.NOT_FOUND, "Post not found", HttpStatus.NOT_FOUND);
    }

    return toResponse(post, true);
  }
}