ProjectService.java

package com.kwcapstone.Service;

import com.kwcapstone.Domain.Dto.Request.EmailInviteRequestDto;
import com.kwcapstone.Domain.Dto.Request.ProjectDeleteRequestDto;
import com.kwcapstone.Domain.Dto.Request.ProjectNameEditRequestDto;
import com.kwcapstone.Domain.Dto.Response.*;
import com.kwcapstone.Domain.Entity.*;
import com.kwcapstone.Repository.*;
import com.kwcapstone.Security.PrincipalDetails;
import lombok.RequiredArgsConstructor;
import org.bson.types.ObjectId;
import org.springframework.http.HttpStatus;
import org.springframework.security.core.annotation.AuthenticationPrincipal;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.web.server.ResponseStatusException;

import java.time.LocalDateTime;
import java.util.ArrayList;
import java.util.List;
import java.util.Optional;
import java.util.UUID;
import java.util.stream.Collectors;

@Service
@Transactional
@RequiredArgsConstructor
public class ProjectService {
    private final ProjectRepository projectRepository;
    private final InviteRepository inviteRepository;

    private final EmailService emailService;
    private final MemberRepository memberRepository;
    private final MemberToProjectRepository memberToProjectRepository;
    private final NoticeRepository noticeRepository;

    // 이메일로 프로젝트에 사용자 추가하기
    public InviteEmailResponseDto addByEmailUser(PrincipalDetails principalDetails,
                               String projectId, EmailInviteRequestDto emailInviteRequestDto) {
        ObjectId memberId = principalDetails.getId();
        Optional<Member> member = memberRepository.findById(memberId);

        if(!member.isPresent()) {
            throw new ResponseStatusException(HttpStatus.NOT_FOUND, "잘못된 ObjectId 형식입니다.");
        }

        //사용자 추가할 때 projectId에 memberId가 회원가입 처리가 되어있어야 함.
        Project project = getProject(projectId);

        // 1. 초대 코드 생성 (UUID 또는 토큰)
        String inviteCode = UUID.randomUUID().toString();

        // 2. 이메일 전송 - 이거 올릴땐 다른 주소로 해야함. www.moaba.site로
        String inviteLink = "https://www.moaba.site/main/project/" + projectId + "/accept?code=" + inviteCode;

        String inviterName = principalDetails.getUsername();
        String projectName = project.getProjectName();

        Optional<Member> isMember = memberRepository.findByEmail(emailInviteRequestDto.getEmail());
        if (!isMember.isPresent()) {
            throw new ResponseStatusException(HttpStatus.NOT_FOUND, "회원가입된 사용자가 아닙니다.");
        }

        emailService.sendProjectInviteMessage(
                emailInviteRequestDto.getEmail(),
                inviteLink,
                inviterName,
                projectName
        );

        saveInviteCode(inviteCode, projectId, emailInviteRequestDto.getEmail(), memberId);

        // 코드 보내고 모아바 웹에 알림 보내기
        String noticeTitle = inviterName + "님이 " + projectName + " 프로젝트에 초대하였습니다.";

        Notice notice = Notice.builder()
                .title(noticeTitle)
                .url(inviteLink)
                .createAt(LocalDateTime.now())
                .isRead(false)
                .official(false)
                .userId(isMember.get().getMemberId())
                .senderId(memberId)
                .build();

        noticeRepository.save(notice);

        return new InviteEmailResponseDto(
                projectId,
                emailInviteRequestDto.getEmail(),
                inviteCode
        );
    }

    // 프로젝트 찾기
    private Project getProject(String projectId) {
        ObjectId objProjectId = new ObjectId(projectId);

        Optional<Project> project = projectRepository.findByProjectId(objProjectId);

        if(!project.isPresent()) {
            throw new ResponseStatusException(HttpStatus.NOT_FOUND, "프로젝트를 찾을 수 없습니다.");
        }

        return project.get();
    }

    private void saveInviteCode(String inviteCode, String projectId, String email, ObjectId userId) {
        Invite invite = Invite.builder()
                    .inviteCode(inviteCode)
                    .projectId(new ObjectId(projectId))
                    .email(email)
                    .userId(userId)
                    .createdAt(LocalDateTime.now())
                    .expiredAt(LocalDateTime.now().plusHours(72))  // 유효시간 : 3일
                    .build();

        inviteRepository.save(invite);
    }

    // 초대 수락
    public void acceptInvite(PrincipalDetails principalDetails, String projectId, String code) {
        ObjectId memberId = principalDetails.getId();
        Optional<Member> isMember = memberRepository.findById(memberId);

        if(!isMember.isPresent()) {
            throw new ResponseStatusException(HttpStatus.NOT_FOUND, "초대 수락 전 로그인을 먼저 하세요.");
        }

        // 초대 코드 검증
        Invite invite = validateInviteCode(code, projectId);

        Member invitedMember = memberRepository.findByEmail(invite.getEmail())
                .orElseThrow(() -> new ResponseStatusException(HttpStatus.NOT_FOUND, "가입된 사용자가 아닙니다."));

        // principalDetails에서 ID를 가져와서 초대된 사용자의 ID와 비교
        if (!invitedMember.getMemberId().equals(principalDetails.getId())) {
            throw new ResponseStatusException(HttpStatus.FORBIDDEN, "초대된 사용자가 아닙니다.");
        }

        //project가 있는지를 확인하기
        ObjectId projectObjectId = new ObjectId(projectId);
        Optional<Project> project = projectRepository.findByProjectId(projectObjectId);
        if(!project.isPresent()) {
            throw new ResponseStatusException(HttpStatus.NOT_FOUND, "프로젝트를 찾을 수 없습니다.");
        }

        //member가 있는지 확인하기
        Member member = memberRepository.findByMemberId(principalDetails.getId())
                .orElseThrow(() -> new ResponseStatusException(HttpStatus.NOT_FOUND, "사용자를 찾을 수 없습니다."));

        // 이미 추가된 프로젝트의 경우 예외처리
        if (memberToProjectRepository.existsByProjectIdAndMemberId(projectObjectId, memberId)) {
            throw new ResponseStatusException(HttpStatus.CONFLICT, "이미 추가된 프로젝트입니다.");
        }

        //관계 추가하기
        MemberToProject memberToProject = MemberToProject.builder()
                .projectId(new ObjectId(projectId))
                .memberId(member.getMemberId())
                .build();
        memberToProjectRepository.save(memberToProject);

        //member에도 관계성 추가
        if (member.getProjectIds() == null) {
            member.setProjectIds(new ArrayList<>());
        }
        member.getProjectIds().add(new ObjectId(projectId));
        memberRepository.save(member);
    }

    //유효성 검사
    private Invite validateInviteCode(String code, String projectId) {
        Invite invite = inviteRepository.findByInviteCode(code)
                .orElseThrow(() -> new ResponseStatusException(HttpStatus.NOT_FOUND, "유효하지 않은 초대 코드입니다."));

        if (!invite.getProjectId().toString().equals(projectId)) {
            throw new ResponseStatusException(HttpStatus.NOT_FOUND, "초대 코드가 잘못되었습니다.");
        }

        if(invite.getExpiredAt().isBefore(LocalDateTime.now())){
            throw new ResponseStatusException(HttpStatus.GONE, "초대 코드가 만료되었습니다.");
        }

        return invite;
    }

    // 프로젝트 삭제 기능
    public void deleteProject(PrincipalDetails principalDetails, List<ProjectDeleteRequestDto> deleteRequestList) {
        ObjectId memberId = principalDetails.getId();

        for (ProjectDeleteRequestDto dto : deleteRequestList) {
            ObjectId projectId = dto.getProjectId();
            String type = dto.getType().toLowerCase();

            Optional<Project> project = projectRepository.findByProjectId(projectId);
            if(!project.isPresent()){
                throw new ResponseStatusException(HttpStatus.NOT_FOUND, "프로젝트를 찾을 수 없습니다.");
            }

            if (!project.get().getCreator().equals(memberId)) {
                throw new ResponseStatusException(HttpStatus.FORBIDDEN, "프로젝트 삭제 권한이 없습니다.");
            }

            if (type.equals("project")) {
                projectRepository.deleteByProjectId(projectId);
                memberToProjectRepository.deleteByProjectId(projectId);
            } else if (type.equals("record")) {
                project.get().setZipFile(null);
                project.get().setScript(null);
                projectRepository.save(project.get());
            } else if (type.equals("summary")) {
                project.get().setSummary(null);
                projectRepository.save(project.get());
            } else {
                throw new ResponseStatusException(HttpStatus.BAD_REQUEST, "유효하지 않은 삭제 타입입니다.");
            }
        }
    }

    //프로젝트 이름 수정
    public ProjectNameEditResponseDto editProjectName(String projectId,
                                                      ProjectNameEditRequestDto projectNameEditRequestDto){
        ObjectId ObjprojectId = new ObjectId(projectId);

        Optional<Project> project = projectRepository.findByProjectId(ObjprojectId);

        if(!project.isPresent()){
            throw new ResponseStatusException(HttpStatus.NOT_FOUND, "프로젝트를 찾을 수 없습니다.");
        }

        project.get().editName(projectNameEditRequestDto.getProjectName());
        projectRepository.save(project.get());

        return new ProjectNameEditResponseDto(
                projectId,
                project.get().getProjectName());
    }

    //프로젝트 공유 모달 띄우기
    public GetProjectShareModalResponseDto getProjectShareModal(String projectId,
                                                                PrincipalDetails principalDetails) {
        ObjectId memberId = principalDetails.getId();
        ObjectId ObjprojectId = new ObjectId(projectId);

        Optional<Project> project = projectRepository.findByProjectId(ObjprojectId);

        if(!project.isPresent()){
            throw new ResponseStatusException(HttpStatus.NOT_FOUND, "프로젝트를 찾을 수 없습니다.");
        }

        //inviteLink
        String inviteUrl = "https://www.moaba.site/project/" + projectId;

        //참여자 목록 가져오기
        List<MemberToProject> connections = memberToProjectRepository.findByProjectId(ObjprojectId);

        if(connections == null){
            throw new ResponseStatusException(HttpStatus.INTERNAL_SERVER_ERROR, "프로젝트 참여자 목록에 null 값입니다.");
        }

        List<MemberInfoDto> sharedMembers = connections.stream()
                .map(conn -> {
                    Member member = memberRepository.findByMemberId(conn.getMemberId())
                            .orElseThrow(() -> new ResponseStatusException(HttpStatus.NOT_FOUND, "참여자 목록에서 회원 정보를 찾을 수 없는 참가자가 존재합니다."));

                    //회의 생성자일때
                    if((project.get().getCreator()).equals(conn.getMemberId())) {
                        return new MemberInfoDto(member.getName(), "회의 생성자");
                    }else{
                        return new MemberInfoDto(member.getName(), "참석자");
                    }

                }).sorted((a, b) -> {
                    // "회의 생성자"가 먼저 오도록 정렬
                    if (a.getRole().equals("회의 생성자")) return -1;
                    if (b.getRole().equals("회의 생성자")) return 1;
                    return 0;
                }).collect(Collectors.toList());

        return new GetProjectShareModalResponseDto(inviteUrl, sharedMembers);
    }

    //프로젝트 공유링크로 들어왔을 때 사용자 추가
    public boolean addByLink(PrincipalDetails principalDetails,
                                                  String projectId){
        ObjectId memberId = principalDetails.getId();
        if(memberId == null){
            throw new ResponseStatusException(HttpStatus.INTERNAL_SERVER_ERROR, "토큰에서 넘겨진 memberId 가 null 입니다.");
        }

        ObjectId objProjectId = new ObjectId(projectId);
        Optional<Project> project = projectRepository.findByProjectId(objProjectId);
        if(!project.isPresent()){
            throw new ResponseStatusException(HttpStatus.NOT_FOUND, "프로젝트를 찾을 수 없습니다.");
        }

        //이미 참여중인가?
        boolean alreadyJoined = memberToProjectRepository.existsByProjectIdAndMemberId(objProjectId, memberId);

        if(alreadyJoined){
            return true;
        }

        //참가자 등록
        MemberToProject mapping = MemberToProject.builder()
                .projectId(objProjectId)
                .memberId(memberId)
                .build();

        memberToProjectRepository.save(mapping);

        //사용자 객체에도 pojectid
        Optional<Member> member = memberRepository.findByMemberId(memberId);

        if(!member.isPresent()){
           throw new ResponseStatusException(HttpStatus.NOT_FOUND, "존재하지 않는 MemberId 입니다.");
        }

        if(member.get().getProjectIds() == null){
            member.get().setProjectIds(new ArrayList<>());
        }

        member.get().getProjectIds().add(objProjectId);
        memberRepository.save(member.get());


        return false;
    }

    //프로젝트 status 띄우기
    public ProjectStatusResponseDto getProjectStatus(PrincipalDetails principalDetails,
                                                        String projectId){
        ObjectId memberId = principalDetails.getId();
        if(memberId == null){
            throw new ResponseStatusException(HttpStatus.INTERNAL_SERVER_ERROR, "토큰에서 넘겨진 memberId 가 null 입니다.");
        }

        ObjectId objProjectId = new ObjectId(projectId);
        Optional<Project> project = projectRepository.findByProjectId(objProjectId);
        if(!project.isPresent()){
            throw new ResponseStatusException(HttpStatus.NOT_FOUND, "프로젝트를 찾을 수 없습니다.");
        }

        ObjectId creatorId = project.get().getCreator();
        String creatorName = memberRepository.findByMemberId(creatorId)
                .map(Member::getName)
                .orElse("알 수 없음");

        String projectStatus = project.get().getStatus();

        String projectName = project.get().getProjectName();
        LocalDateTime updatedAt = project.get().getUpdatedAt();

        return new ProjectStatusResponseDto(projectId, creatorName, projectStatus, projectName, updatedAt);
    }

    //프로젝트 추출
    public ExportProjectResponseDto exportProject(PrincipalDetails principalDetails,
                                                  String projectId,
                                                  ExportKind kind){
        ObjectId memberId = principalDetails.getId();
        Optional<Member> member = memberRepository.findByMemberId(memberId);
        if(!member.isPresent()){
            throw new ResponseStatusException(HttpStatus.UNAUTHORIZED, "토큰에 있는 memberId 정보가 db에 존재하지 않습니다.");
        }


        ObjectId ObjProject = new ObjectId(projectId);
        Optional<Project> project = projectRepository.findByProjectId(ObjProject);
        if(!project.isPresent()){
            throw new ResponseStatusException(HttpStatus.NOT_FOUND, "프로젝트를 찾을 수 없습니다.");
        }

        String projectUrl = "";

        //kind에 따라서 프로젝트 추출하기
        switch (kind) {
            case MINDMAP -> {
                // MindMap 추출 로직
                projectUrl = project.get().getProjectImage();
            }
            case SUMMARY -> {
                // Summary 추출 로직
                projectUrl = project.get().getSummary().getSummaryUrl();
            }
            case RECORDING -> {
                // Recording 추출 로직
                projectUrl = project.get().getZipFile().getZipUrl();
            }
            default -> throw new IllegalArgumentException("Unsupported export kind: " + kind);
        }

        return new ExportProjectResponseDto(projectId, projectUrl);
    }
}