package ru.soune.nocopy.service.file;

import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import ru.soune.nocopy.dto.file.FileEntityResponse;
import ru.soune.nocopy.dto.file.FileResponse;
import ru.soune.nocopy.entity.file.FileEntity;
import ru.soune.nocopy.entity.file.FileStatus;
import ru.soune.nocopy.entity.file.FileUploadSession;
import ru.soune.nocopy.entity.file.ProtectionStatus;
import ru.soune.nocopy.entity.user.User;
import ru.soune.nocopy.exception.DuplicateImageException;
import ru.soune.nocopy.exception.FileEntityNotFoundException;
import ru.soune.nocopy.repository.FileEntityRepository;
import ru.soune.nocopy.repository.SimilarImageProjection;
import ru.soune.nocopy.repository.UserRepository;
import ru.soune.nocopy.service.FileSimilarityService;
import ru.soune.nocopy.service.ImageHashService;

import java.io.File;
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.time.LocalDateTime;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

@Slf4j
@Service
@RequiredArgsConstructor
public class FileEntityService {

    private final FileEntityRepository fileEntityRepository;

    private final ImageHashService imageHashService;

    private final FileSimilarityService fileSimilarityService;

    private final UserRepository userRepository;

    @Transactional(noRollbackFor = DuplicateImageException.class)
    public FileEntity createFromUploadSession(FileUploadSession session, String checksum) {
        log.info("Creating FileEntity for upload session: {}", session.getUploadId());

        try {
            Path filePath = Paths.get(session.getFilePath());

            if (!Files.exists(filePath)) {
                throw new IOException("File not found on disk: " + filePath);
            }

            Map<String, Long> imageHash = Map.of();

            if (session.getFileType().startsWith("image")) {
                imageHash = imageHashService.calculateHash(filePath);
                List<SimilarImageProjection> duplicatedByHash = fileSimilarityService.findDuplicatedByHash(
                        imageHash.get("hi"), imageHash.get("low"));

                if (!duplicatedByHash.isEmpty()) {
                    SimilarImageProjection similarImageProjection = duplicatedByHash.get(0);

                    throw new DuplicateImageException("Duplicate", similarImageProjection.getId(),
                            similarImageProjection.getUserId());
                }
            }

            long fileSize = Files.size(filePath);
            String originalName = session.getFileName();
            String storedName = filePath.getFileName().toString();

            FileEntity fileEntity = FileEntity.builder()
                    .userId(session.getUserId())
                    .originalFileName(originalName)
                    .storedFileName(storedName)
                    .filePath(session.getFilePath())
                    .fileSize(fileSize)
                    .mimeType(session.getFileType())
                    .fileExtension(session.getExtension())
                    .checksum(checksum)
                    .uploadSessionId(session.getUploadId())
                    .status(FileStatus.ACTIVE)
                    .build();

            FileEntity saved = fileEntityRepository.save(fileEntity);

            if (!imageHash.isEmpty()) {
                imageHashService.create(saved, imageHash);
            }

            return saved;
        } catch (IOException e) {
            log.error("Failed to create FileEntity for session {}: {}",
                    session.getUploadId(), e.getMessage(), e);
            throw new RuntimeException("Failed to create file entity: " + e.getMessage(), e);
        }
    }

    @Transactional(readOnly = true)
    public FileEntityResponse getById(String fileId, int version) {
        FileEntity fileEntity = fileEntityRepository.findById(fileId)
                .orElseThrow(() -> new FileEntityNotFoundException(fileId));

        return convertToResponse(fileEntity, version);
    }

    @Transactional(readOnly = true)
    public FileEntityResponse getByUploadSessionId(String uploadSessionId, int version) {
        FileEntity fileEntity = fileEntityRepository.findByUploadSessionId(uploadSessionId)
                .orElseThrow(() -> new FileEntityNotFoundException(
                        "Not found for upload session: " + uploadSessionId));

        return convertToResponse(fileEntity, version);
    }

    @Transactional(readOnly = true)
    public FileEntityResponse getByFilePath(String filePath, int version) {
        FileEntity fileEntity = fileEntityRepository.findByFilePath(filePath)
                .orElseThrow(() -> new FileEntityNotFoundException("Path: " + filePath));

        return convertToResponse(fileEntity, version);
    }


    @Transactional(readOnly = true)
    public FileResponse getAllUserFiles(Long userId, int version) {
        List<FileEntity> fileEntities = fileEntityRepository.findByUserIdAndStatus(
                userId, FileStatus.ACTIVE);

        List<FileEntityResponse> files = fileEntities.stream()
                .map(file -> convertToResponse(file, version))
                .collect(Collectors.toList());

        long totalSize = fileEntities.stream()
                .mapToLong(FileEntity::getFileSize)
                .sum();

        return FileResponse.builder()
                .files(files)
                .totalCount(files.size())
                .totalSize(totalSize)
                .formattedTotalSize(formatFileSize(totalSize))
                .page(1)
                .pageSize(files.size())
                .build();
    }

    @Transactional(readOnly = true)
    public FileResponse getUserFiles(Long userId, int page, int pageSize, int version) {
        User user = userRepository.findById(userId).orElseThrow();
        List<FileEntity> allFiles = new ArrayList<>();

        if (user.getCompany() != null) {
            for (Long uId : userRepository.findByCompanyId(user.getCompany().getId()).stream()
                    .map(User::getId)
                    .toList()) {
                allFiles.addAll(fileEntityRepository.findByUserIdAndStatus(uId, FileStatus.ACTIVE));
            }

        } else {
            allFiles = fileEntityRepository.findByUserIdAndStatus(
                    userId, FileStatus.ACTIVE);
        }

        int start = (page - 1) * pageSize;
        int end = Math.min(start + pageSize, allFiles.size());

        if (start >= allFiles.size()) {
            return FileResponse.builder()
                    .files(List.of())
                    .totalCount(allFiles.size())
                    .totalSize(0)
                    .formattedTotalSize("0 B")
                    .page(page)
                    .pageSize(pageSize)
                    .build();
        }

        List<FileEntity> pageFiles = allFiles.subList(start, end);

        List<FileEntityResponse> files = pageFiles.stream()
                .map(file -> convertToResponse(file, version))
                .collect(Collectors.toList());

        long totalSize = allFiles.stream()
                .mapToLong(FileEntity::getFileSize)
                .sum();

        return FileResponse.builder()
                .files(files)
                .totalCount(allFiles.size())
                .totalSize(totalSize)
                .formattedTotalSize(formatFileSize(totalSize))
                .page(page)
                .pageSize(pageSize)
                .build();
    }

    @Transactional
    public FileEntity markAsDeleted(FileEntity fileEntity) throws IOException {
        fileEntity.setStatus(FileStatus.DELETED);
        fileEntity.setUpdatedAt(LocalDateTime.now());
        fileEntity.setProtectionStatus(ProtectionStatus.NOT_PROTECTED);

        Path path = Paths.get(fileEntity.getProtectedFilePath());
        Files.deleteIfExists(path);
        fileEntity.setProtectedFilePath("");

        return fileEntityRepository.save(fileEntity);
    }

    public void softDeleteFileWithHash(FileEntity fileEntity) throws IOException {
        if (fileEntity.getImageHash() != null) {
            fileEntity.setImageHash(null);
        }

        fileEntity.setStatus(FileStatus.DELETED);
        fileEntity.setUpdatedAt(LocalDateTime.now());
        fileEntity.setProtectionStatus(ProtectionStatus.NOT_PROTECTED);

        Path path = Paths.get(fileEntity.getProtectedFilePath());
        Files.deleteIfExists(path);
        fileEntity.setProtectedFilePath("");

        fileEntityRepository.save(fileEntity);
    }

    public void deleteFromDisk(FileEntity fileEntity) throws IOException {
        Path path = Paths.get(fileEntity.getFilePath());

        if (!Files.exists(path)) {
            return;
        }

        Files.delete(path);

        fileEntityRepository.delete(fileEntity);
    }

    @Transactional(readOnly = true)
    public long getUserStorageUsed(Long userId) {
        Long totalSize = fileEntityRepository.getTotalSizeByUserId(userId);
        return totalSize != null ? totalSize : 0L;
    }

    public void changeStatus(ProtectionStatus newStatus, String fileId) {
        FileEntity fileEntity = fileEntityRepository.findById(fileId)
                .orElseThrow(() -> new FileEntityNotFoundException(fileId));
        fileEntity.setProtectionStatus(newStatus);

        fileEntityRepository.save(fileEntity);
    }

    @Transactional
    public void writeProtectedFile(String id, byte[] data, String fileExt) throws IOException {
        FileEntity fileEntity = fileEntityRepository.findById(id)
                .orElseThrow(() -> new RuntimeException("File not found: " + id));

        String extension = determineFileExtension(fileExt, fileEntity);
        log.info("EXTENSION: {}", extension);
        Path protectedFilePath = prepareProtectedPath(fileEntity, extension);

        if (Files.exists(protectedFilePath)) {
            Files.delete(protectedFilePath);
        }

        Files.write(protectedFilePath, data);

        fileEntity.setProtectedFilePath(protectedFilePath.toString());
        fileEntity.setProtectedAt(LocalDateTime.now());
        fileEntity.setUpdatedAt(LocalDateTime.now());
        fileEntity.setFileExtension(extension);
        fileEntity.setProtectionStatus(ProtectionStatus.PROTECTED);

        fileEntityRepository.save(fileEntity);
    }

    public void clearTempFiles(long userId) throws IOException {
        List<FileEntity> fileByUserIdAndStatus = fileEntityRepository.findFileByUserIdAndStatus(userId, FileStatus.TEMP);

        for (FileEntity fileEntity : fileByUserIdAndStatus) {
            deleteFromDisk(fileEntity);
        }
    }

    public FileEntity findBySignature(String signature) {
        return fileEntityRepository.findBySignature(signature);
    }

    public String findFileIdByPath(String filePath) {
        return fileEntityRepository.findFileIdByFilePath(filePath);
    }

    public File getFileById(String id) {
        try {
            FileEntity fileEntity = fileEntityRepository.findById(id).orElseThrow(() ->
                    new RuntimeException("File not found: " + id));

            File file = new File(fileEntity.getFilePath());

            if (!file.exists()) {
                throw new RuntimeException("File not found on disk: " + fileEntity.getFilePath());
            }

            return file;
        } catch (Exception e) {
            log.error("Error getting file: {}", id, e);
            return null;
        }
    }

    public Path prepareProtectedPath(FileEntity fileEntity, String extension) throws IOException {
        Path originalPath = Paths.get(fileEntity.getFilePath());

        String pathStr = originalPath.toString();
        pathStr = pathStr.replaceFirst("/uploads/uploads/", "/uploads/protected/");

        Path protectedPath = Paths.get(pathStr);
        String fileName = protectedPath.getFileName().toString();

        if (extension != null) {
            String nameWithoutExt = fileName;
            int lastDotIndex = fileName.lastIndexOf('.');
            if (lastDotIndex > 0) {
                nameWithoutExt = fileName.substring(0, lastDotIndex);
            }
            fileName = nameWithoutExt + "." + extension;

            protectedPath = protectedPath.getParent().resolve(fileName);
        }

        Files.createDirectories(protectedPath.getParent());

        return protectedPath;
    }

    public void updateSignature(String signature, String fileId) throws IOException {
        FileEntity fileEntity = fileEntityRepository.findByFileId(fileId);
        fileEntity.setSignature(signature);
        fileEntity.setProtectionStatus(ProtectionStatus.PROTECTED);
        fileEntity.setUpdatedAt(LocalDateTime.now());
        fileEntity.setProtectedAt(LocalDateTime.now());
        fileEntity.setProtectedFilePath(prepareProtectedPath(fileEntity, fileEntity.getFileExtension()).toString());

        fileEntityRepository.save(fileEntity);
    }

    private boolean checkFileExistsOnDisk(String filePath) {
        try {
            return Files.exists(Paths.get(filePath));
        } catch (Exception e) {
            log.warn("Error checking file existence: {}", filePath, e);
            return false;
        }
    }

    private String determineFileExtension(String fileExt, FileEntity fileEntity) {
        if (fileExt != null) {
            return fileExt;
        } else {
            return fileEntity.getFileExtension();
        }
    }

    private FileEntityResponse convertToResponse(FileEntity fileEntity, int version) {
        boolean existsOnDisk = checkFileExistsOnDisk(fileEntity.getFilePath());
        User user = userRepository.findById(fileEntity.getUserId()).get();

        return FileEntityResponse.builder()
                .id(fileEntity.getId())
                .userId(fileEntity.getUserId())
                .originalFileName(fileEntity.getOriginalFileName())
                .storedFileName(fileEntity.getStoredFileName())
                .filePath(fileEntity.getProtectedFilePath())
                .fileSize(fileEntity.getFileSize())
                .mimeType(fileEntity.getMimeType())
                .fileExtension(fileEntity.getFileExtension())
                .checksum(fileEntity.getChecksum())
                .uploadSessionId(fileEntity.getUploadSessionId())
                .status(fileEntity.getStatus())
                .createdAt(fileEntity.getCreatedAt())
                .updatedAt(fileEntity.getUpdatedAt())
                .formattedSize(formatFileSize(fileEntity.getFileSize()))
                .downloadUrl("/api/v" + version + "/files/download/" + fileEntity.getId())
                .existsOnDisk(existsOnDisk)
                .supportId(fileEntity.getSupportId())
                .protectStatus(fileEntity.getProtectionStatus().toString())
                .fileName(fileEntity.getOriginalFileName().replace("." +
                        fileEntity.getFileExtension(), "") + "_nocopy_protected" +
                        "." + fileEntity.getFileExtension())
                .ownerName(user.getFullName())
                .ownerEmail(user.getEmail())
                .ownerCompany(user.getCompanyName())
                //TODO fix after add logic for check for protect file
                .checksCount(0)
                .fileUploadDate(fileEntity.getCreatedAt())
                .protectedFilePath(fileEntity.getProtectedFilePath())
                .build();
    }

    public String formatFileSize(long size) {
        if (size < 1024) {
            return size + " B";
        } else if (size < 1024 * 1024) {
            return String.format("%.1f KB", size / 1024.0);
        } else if (size < 1024 * 1024 * 1024) {
            return String.format("%.1f MB", size / (1024.0 * 1024.0));
        } else {
            return String.format("%.1f GB", size / (1024.0 * 1024.0 * 1024.0));
        }
    }
}