package kr.wisestone.owl.service.impl;

import com.google.common.collect.Lists;
import kr.wisestone.owl.common.ExcelConditionCheck;
import kr.wisestone.owl.constant.Constants;
import kr.wisestone.owl.constant.MsgConstants;
import kr.wisestone.owl.domain.*;
import kr.wisestone.owl.domain.enumType.EmailType;
import kr.wisestone.owl.domain.enumType.ProjectType;
import kr.wisestone.owl.domain.enumType.ServiceType;
import kr.wisestone.owl.exception.OwlRuntimeException;
import kr.wisestone.owl.mapper.WorkspaceMapper;
import kr.wisestone.owl.repository.WorkspaceRepository;
import kr.wisestone.owl.service.*;
import kr.wisestone.owl.util.*;
import kr.wisestone.owl.vo.ExportExcelVo;
import kr.wisestone.owl.vo.WorkspaceVo;
import kr.wisestone.owl.web.form.*;
import kr.wisestone.owl.web.view.ExcelView;
import org.apache.commons.lang3.StringUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.messaging.simp.SimpMessagingTemplate;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.ui.Model;
import org.springframework.web.servlet.ModelAndView;

import java.util.*;

@Service
public class WorkspaceServiceImpl extends AbstractServiceImpl<Workspace, Long, JpaRepository<Workspace, Long>> implements WorkspaceService {

    private static final Logger log = LoggerFactory.getLogger(WorkspaceServiceImpl.class);

    @Autowired
    private WorkspaceRepository workspaceRepository;

    @Autowired
    private IssueStatusService issueStatusService;

    @Autowired
    private UserWorkspaceService userWorkspaceService;

    @Autowired
    private WorkflowService workflowService;

    @Autowired
    private IssueTypeService issueTypeService;

    @Autowired
    private SimpMessagingTemplate simpMessagingTemplate;

    @Autowired
    private WorkspaceMapper workspaceMapper;

    @Autowired
    private AttachedFileService attachedFileService;

    @Autowired
    private UserService userService;

    @Autowired
    private SystemEmailService systemEmailService;

    @Autowired
    private PriorityService priorityService;

    @Autowired
    private SeverityService severityService;

    @Autowired
    private ExcelView excelView;

    @Autowired
    private ExcelConditionCheck excelConditionCheck;

    // zenith add type
    @Value("${saas.packagetype}")
    private Integer packageType;

    @Value("${saas.maxUser}")
    private Integer maxUserCount;

    @Value("${saas.period}")
    private Integer usePeriod;

    @Value("${saas.usdkrw}")
    private Integer usdKrw;

    @Override
    protected JpaRepository<Workspace, Long> getRepository() {
        return this.workspaceRepository;
    }

    //  업무 공간 생성
    @Override
    @Transactional
    public Workspace addWorkspace(String workspaceName) {
        Workspace workspace = new Workspace();
        //  업무 공간 명 유효성 체크
        this.verifyWorkspaceName(workspaceName);
        workspace.setName(workspaceName);
        workspace.setMaxUser(this.maxUserCount);
        workspace.setStorageSize(workspace.calculateStorageSize());
        workspace.setStartDate(new Date());
        workspace.setExpireDate(DateUtil.addDays(new Date(), this.usePeriod));
        workspace.setServiceType(ServiceType.USE);

        this.workspaceRepository.saveAndFlush(workspace);
        //  시스템에서 사용할 수 있는 기본 제공 이슈 상태를 생성한다.
        this.issueStatusService.addDefaultIssueStatus(workspace);
        //  시스템에서 사용할 수 있는 기본 워크플로우를 생성한다.
        this.workflowService.addDefaultWorkflow(workspace, Arrays.asList(ProjectType.BTS_PROJECT, ProjectType.RMS_PROJECT, ProjectType.TCM_PROJECT));
        //  시스템에서 사용할 수 있는 기본 이슈 유형을 생성한다.
        this.issueTypeService.addDefaultIssueType(workspace, Arrays.asList(ProjectType.BTS_PROJECT, ProjectType.RMS_PROJECT, ProjectType.TCM_PROJECT));
        //  시스템에서 사용할 수 있는 기본 우선 순위를 생성한다.
        this.priorityService.addDefaultPriority(workspace);
        //  시스템에서 사용할 수 있는 기본 중요도를 생성한다.
        this.severityService.addDefaultSeverity(workspace);
        return workspace;
    }

    //  업무 공간 명 유효성 체크
    private void verifyWorkspaceName(String workspaceName) {
        if (StringUtils.isEmpty(workspaceName)) {
            throw new OwlRuntimeException(
                    this.messageAccessor.getMessage(MsgConstants.WORKSPACE_NOT_NAME));
        }

        if (workspaceName.length() > 50) {
            throw new OwlRuntimeException(
                    this.messageAccessor.getMessage(MsgConstants.WORKSPACE_NAME_MAX_LENGTH_OUT));
        }
    }

    //  업무 공간에서 사용자 제외
    @Override
    @Transactional
    public void out(WorkspaceForm workspaceForm) {
        /*List<User> users = this.userService.findByIdIn(workspaceForm.getUserIds());
        Workspace workspace = this.workspaceRepository.findOne(this.userService.getUser(this.webAppUtil.getLoginId()).getLastWorkspaceId());
        List<String> userEmails = Lists.newArrayList();

        users.parallelStream().forEach(user -> {
            userEmails.add(user.getAccount());
        });

        // 해당 업무 공간에 존재하는 모든 프로젝트에서 제외
        this.projectRoleUserService.outWorkspaceModifyProjectRole(workspace, userEmails);
        //  이전에 보낸 초대 정보 삭제
        this.userInviteService.deleteUserInvite(workspace.getId(), userEmails);
        //  업무 공간 사용자 연결 정보 삭제
        this.userWorkspaceService.deleteUserWorkspace(workspace, workspaceForm.getUserIds());
        //  이슈의 담당자였으면 해당 이슈에서 담당자 제외
        this.issueUserService.outWorkspaceModifyAssignee(workspace, userEmails);

        //  업무 공간 제외 이메일 알림
        String[] sendUsers = userEmails.toArray(new String[userEmails.size()]);
        Map<String, Object> content = new HashMap<>();
        content.put("workspaceName", workspace.getName());

        this.systemEmailService.sendEmail(sendUsers, EmailType.WORKSPACE_OUT, content);*/
    }

    //  정기 결제가 완료된 후 업무 공간 만료일, 최대 사용자 수, 저장 공간, 사용 가능 트래픽을 업데이트 한다.
    @Override
    @Transactional
    public Workspace updateWorkspace(Workspace workspace, PaymentForm paymentForm) {
        Date nextExpireDate = workspace.calculateNextPaymentDate(paymentForm.getType(), workspace.getExpireDate());
        Date expireDate = DateUtil.convertStrToDate(DateUtil.convertDateToStr(nextExpireDate, "yyyy-MM-dd") + " 23:59:59");
        workspace.setStartDate(new Date());
        workspace.setExpireDate(expireDate);
        workspace.setMaxUser(paymentForm.getBuyUser());
        workspace.setStorageSize(workspace.calculateStorageSize());
        workspace.setUseTraffic(0L);
        workspace.setServiceType(ServiceType.USE);
        return this.workspaceRepository.saveAndFlush(workspace);
    }

    //  추가 결제 완료 후 최대 사용자 수, 저장 공간을 업데이트한다.
    @Override
    @Transactional
    public Workspace updateWorkspaceByImmediatePayment(Workspace workspace, int buyUser) {
        workspace.setMaxUser(buyUser);
        workspace.setStorageSize(workspace.calculateStorageSize());
        return this.workspaceRepository.saveAndFlush(workspace);
    }

    //  정기 결제일이 된 업무 공간 목록을 가져온다. - 스케쥴링에서 사용함
    @Override
    @Transactional(readOnly = true)
    public List<Workspace> findSubscribeImmediateExpireDate() {
        String today = DateUtil.convertDateToYYYYMMDD(DateUtil.addDays(new Date(), -1));
        Date todayFrom = DateUtil.convertStrToDate(today + " 00:00:00");
        Date todayTo = DateUtil.convertStrToDate(today + " 23:59:59");
        return this.workspaceRepository.findSubscribeImmediateExpireDate(todayFrom, todayTo);
    }

    //  사용자 및 사용 가능 용량 초기화
    @Override
    @Transactional
    public void initMaxUserAndStorageSize(Workspace workspace) {
        workspace.setMaxUser(0);
        workspace.setStorageSize(0L);
        workspace.setServiceType(ServiceType.UNUSED);   //  사용 안함으로 변경
        workspace.setPayment(null); //  이전 결제 정보 삭제
        this.workspaceRepository.saveAndFlush(workspace);
    }

    //  업무 공간 정기 결제 취소 - 정기 결제 정보 삭제
    @Override
    @Transactional
    public void cancelWorkspacePayment(Workspace workspace) {
        workspace.setPayment(null);
        this.workspaceRepository.saveAndFlush(workspace);
    }

    //  최초 설치한 관리자가 생성한 업무 공간를 가져온다.
    @Override
    @Transactional(readOnly = true)
    public Workspace getPrimaryWorkspace() {
        Long workspaceid = 0L;
        List<User> users = this.userService.findAdmin();

        if(users.size() > 0 )
        {
            User adminUser = users.get(0);
            workspaceid = adminUser.getLastWorkspaceId();
        }

        if (workspaceid == 0) {
            return null;
        }

        Workspace workspace = this.findOne(workspaceid);

        if (workspace == null) {
            throw new OwlRuntimeException(
                    this.messageAccessor.getMessage(MsgConstants.WORKSPACE_NOT_EXIST));
        }

        return workspace;
    }

    //  아이디에 해당하는 업무 공간를 가져온다.
    @Override
    @Transactional(readOnly = true)
    public Workspace getWorkspace(Long id) {
        if (id == null) {
            throw new OwlRuntimeException(
                    this.messageAccessor.getMessage(MsgConstants.WORKSPACE_NOT_EXIST));
        }

        Workspace workspace = this.findOne(id);

        if (workspace == null) {
            throw new OwlRuntimeException(
                    this.messageAccessor.getMessage(MsgConstants.WORKSPACE_NOT_EXIST));
        }

        return workspace;
    }

    //  참여하고 있는 업무 공간 목록을 가져온다.
    @Override
    @Transactional(readOnly = true)
    public void find(Map<String, Object> resJsonData) {
        List<Workspace> workspaces = this.workspaceRepository.findByUserId(this.webAppUtil.getLoginId());
        List<WorkspaceVo> workspaceVos = Lists.newArrayList();

        for (Workspace workspace : workspaces) {
            WorkspaceVo workspaceVo = ConvertUtil.copyProperties(workspace, WorkspaceVo.class);
            workspaceVos.add(workspaceVo);
        }

        resJsonData.put(Constants.RES_KEY_CONTENTS, workspaceVos);
    }

    //  자신이 관리하는 업무 공간를 가져온다.
    @Override
    @Transactional(readOnly = true)
    public void findPrimaryWorkspace(Map<String, Object> resJsonData) {

        boolean bHavePrimaryWorkspace = false;

        Workspace primaryWorkspace =  this.getPrimaryWorkspace();

        if(primaryWorkspace != null) {
            bHavePrimaryWorkspace = true;
        }

        resJsonData.put(Constants.RES_KEY_CONTENTS, bHavePrimaryWorkspace);
    }

    //  자신이 관리하는 업무 공간를 가져온다.
    @Override
    @Transactional(readOnly = true)
    public void findMyWorkspace(Map<String, Object> resJsonData) {

        UserWorkspace userWorkspace = this.userWorkspaceService.findWorkspaceManager(this.webAppUtil.getLoginId()); //워크스페이스 관리자
        if(userWorkspace == null){
            userWorkspace = this.userWorkspaceService.findMyWorkspace(this.webAppUtil.getLoginId());
        }
        Workspace workspace = userWorkspace.getWorkspace();

        WorkspaceVo workspaceVo = ConvertUtil.copyProperties(workspace, WorkspaceVo.class);
        workspaceVo.setServiceType((workspace.getServiceType().toString()));
        workspaceVo.setExpireDateTerm(DateUtil.getDateDiff(new Date(), workspace.getExpireDate())); //  추가 결제를 진행할 때 금액 계산을 위해 사용

        //  zenith edit
        //  packagetype을 저장한다.
        workspaceVo.setPackageType(this.packageType);

        //  업무 공간 사용 가능 기간
        this.checkRemainPeriod(workspace, workspaceVo);
        //  현재 사용 용량
        this.checkUseStorageSize(workspace, workspaceVo);
        //  참여 사용자
        this.checkActiveUserCount(workspace, workspaceVo);
        //  참여 대기 사용자
        this.checkStandByUserCount(workspace, workspaceVo);
        //  환율 정보
        workspaceVo.setUsdKrw(this.usdKrw);

        resJsonData.put(Constants.RES_KEY_CONTENTS, workspaceVo);
    }

    // zenith edit
    private long getRemainPeriod(Date fromDate, Date toDate) {
        long lRemainDays = 0;

        // zenith edit packageType 1 이상이명, 만료일이 없음. (local version)
        if (this.packageType > 0) {
            lRemainDays = 9999;
        }
        else
        {
            Integer totalDate = DateUtil.getDateDiff(fromDate, toDate);
            //  사용 가능 기간은 0보다 적을 경우 0으로 표시
            if (totalDate < 0) {
                totalDate = 0;
            }

            lRemainDays = totalDate.longValue();
        }

        return lRemainDays;
    }

    //  업무 공간 사용 가능 기간
    private void checkRemainPeriod(Workspace workspace, WorkspaceVo workspaceVo) {

        long lRemainDays = getRemainPeriod(new Date(), workspace.getExpireDate());

        workspaceVo.setTotalDate(lRemainDays);
    }

    //  현재 사용 용량
    private void checkUseStorageSize(Workspace workspace, WorkspaceVo workspaceVo) {
        //  업무 공간에서 사용중인 저장 용량을 조회한다.
        Long useStorageSize = this.attachedFileService.findUseStorage(workspace);

        if (useStorageSize == null) {
            useStorageSize = 0L;
        }
        workspaceVo.setUseStorageSize(useStorageSize);
    }

    //  참여 사용자
    private void checkActiveUserCount(Workspace workspace, WorkspaceVo workspaceVo) {
        Integer userCount = this.userWorkspaceService.countByWorkspaceIdAndUseYn(workspace.getId(), true);
        workspaceVo.setActiveUser(userCount);
    }

    //  참여 대기 사용자
    private void checkStandByUserCount(Workspace workspace, WorkspaceVo workspaceVo) {
        Integer userCount = this.userWorkspaceService.countByWorkspaceIdAndUseYn(workspace.getId(), false);
        workspaceVo.setStandByUser(userCount);
    }


    //  사용자가 회원 탈퇴를 진행하면 업무 공간에 있는 정보를 삭제한다.
    @Override
    @Transactional
    public void removeWorkspace(Workspace workspace, User user) {
        //  삭제되는 업무 공간에 참여하고 있는 사용자
        List<String> updateTargetUsers = this.findUpdateLastWorkspaceTargetUser(workspace);
        String workspaceName = workspace.getName();

        Map<String, Object> deleteWorkspaceMap = new HashMap<>();
        deleteWorkspaceMap.put("workspaceId", workspace.getId());
        //  업무 공간에 연관된 테이블을 삭제하기 위해 id 값을 추출한다.
        this.setWorkspaceRelationIds(workspace, deleteWorkspaceMap);
        //  업무 공간에 있는 모든 정보를 삭제한다.
        this.workspaceMapper.deleteWorkspace(deleteWorkspaceMap);
        //  업무 공간 삭제시 이슈에 첨부된 파일을 시스템에서 삭제한다.
        this.attachedFileService.deleteWorkspaceCascadeAttachedFile(workspace);

        //  업무 공간을 사용하지 못하도록 한다.
        workspace.setStorageSize(0L);   //  저장 가능 공간 0으로 변경
        workspace.setMaxUser(0);   //  사용 가능 인원 0으로 변경
        workspace.setServiceType(ServiceType.UNUSED);   //  업무 공간 서비스를 사용 안함으로 변경
        this.workspaceRepository.flush();

        for (String account : updateTargetUsers) {
            //  업무 공간에 참여하던 사용자에게 업무 공간 삭제 알림 및 화면 새로고침
            this.simpMessagingTemplate.convertAndSendToUser(account, "/notification/workspace-remove", this.messageAccessor.getMessage(MsgConstants.WORKSPACE_OUT, workspaceName));
        }
    }

    //  업무 공간에 연관된 테이블을 삭제하기 위해 id 값을 추출한다.
    private void setWorkspaceRelationIds(Workspace workspace, Map<String, Object> deleteWorkspaceMap) {
        List<Long> workflowIds = Lists.newArrayList();

        for (Workflow workflow : workspace.getWorkflows()) {
            workflowIds.add(workflow.getId());
        }

        deleteWorkspaceMap.put("workflowIds", workflowIds);

        List<Long> userInviteIds = Lists.newArrayList();

        for (UserInvite userInvite : workspace.getUserInvites()) {
            userInviteIds.add(userInvite.getId());
        }

        deleteWorkspaceMap.put("userInviteIds", userInviteIds);

        List<Long> projectIds = Lists.newArrayList();
        List<Long> projectRoleIds = Lists.newArrayList();

        for (Project project : workspace.getProjects()) {
            projectIds.add(project.getId());
            for (ProjectRole projectRole : project.getProjectRoles()) {
                projectRoleIds.add(projectRole.getId());
            }
        }

        deleteWorkspaceMap.put("projectIds", projectIds);
        deleteWorkspaceMap.put("projectRoleIds", projectRoleIds);

        List<Long> customFieldIds = Lists.newArrayList();

        for (CustomField customField : workspace.getCustomFields()) {
            customFieldIds.add(customField.getId());
        }

        deleteWorkspaceMap.put("customFieldIds", customFieldIds);
    }

    //  삭제되는 업무 공간에 참여하고 있는 사용자
    private List<String> findUpdateLastWorkspaceTargetUser(Workspace workspace) {
        List<String> updateTargetUsers = Lists.newArrayList();  //  해당 업무 공간을 마지막으로 접근한 사용자 목록

        List<UserWorkspace> userWorkspaces = this.userWorkspaceService.findByWorkspaceIdAndManagerYn(workspace.getId(), false);

        for (UserWorkspace userWorkspace : userWorkspaces) {
            User user = userWorkspace.getUser();

            if (workspace.getId().equals(user.getLastWorkspaceId())) {
                updateTargetUsers.add(user.getAccount());
            }
            //  해당 사용자가 관리하는 업무 공간을 마지막으로 접근한 업무 공간 정보로 업데이트한다.
            this.userService.updateLastDefaultWorkspace(workspace, user);
        }

        return updateTargetUsers;
    }

    //  업무 공간 명을 수정한다.
    @Override
    @Transactional
    public void modifyWorkspace(WorkspaceForm workspaceForm) {
        Workspace workspace = this.getWorkspace(workspaceForm.getWorkspaceId());

        //  업무 공간 명 유효성 체크
        this.verifyWorkspaceName(workspaceForm.getName());

        workspace.setName(workspaceForm.getName());
        this.workspaceRepository.saveAndFlush(workspace);
    }

    //  사용 기간이 만료된 업무 공간을 찾아 용량, 최대 사용자, 서비스 유형을 변경한다.
    @Override
    @Transactional
    public void expireWorkspace() {

        // zenith edit packageType 0 이상이면, 만료일이 없음. (local version)
        if(this.packageType > 0) {
            String today = DateUtil.convertDateToYYYYMMDD(DateUtil.addDays(new Date(), -1));
            Date todayFrom = DateUtil.convertStrToDate(today + " 00:00:00");
            Date todayTo = DateUtil.convertStrToDate(today + " 23:59:59");
            //  결제일이 도래된 업무 공간 목록을 가져온다.
            List<Workspace> workspaces = this.workspaceRepository.findExpireDate(todayFrom, todayTo);

            for (Workspace workspace : workspaces) {
                //  사용기간이 만료된 업무 공간의 관리자가 아닌 사용자를 추출하여 마지막 접근한 업무 공간 정보를 변경한다.
                this.userWorkspaceService.limitExpireUserWorkspace(workspace);

                List<UserWorkspace> managerUserWorkspace = this.userWorkspaceService.findByWorkspaceIdAndManagerYn(workspace.getId(), true);

                for (UserWorkspace userWorkspace : managerUserWorkspace) {
                    Map<String, Object> workspaceMap = new HashMap<>();
                    workspaceMap.put("workspaceName", workspace.getName());
                    workspaceMap.put("userName", userWorkspace.getUser().getName());
                    workspaceMap.put("expireDate", DateUtil.convertDateToYYYYMMDD(workspace.getExpireDate()));

                    //  업무 공간 관리자에게 사용 기간 만료 알림
                    this.systemEmailService.directEmail(new String[]{userWorkspace.getUser().getAccount()}, EmailType.WORKSPACE_EXPIRE, workspaceMap, null);
                }

                //  업무 공간 최대 사용자 및 사용 가능 용량 초기화
                this.initMaxUserAndStorageSize(workspace);
            }
        }
    }

    //  업무 공간 만료 안내 메일을 보낸다.
    @Override
    @Transactional(readOnly = true)
    public void expireAlarmWorkspace() {
        //  7일 후 만료인 업무 공간 담당자에게 메일 보내기
        this.sendExpireAlarmWorkspace(7);
        //  3일 후 만료인 업무 공간 담당자에게 메일 보내기
        this.sendExpireAlarmWorkspace(3);
    }

    private void sendExpireAlarmWorkspace(int dayCount) {
        String day = DateUtil.convertDateToYYYYMMDD(DateUtil.addDays(new Date(), dayCount));
        Date dayFrom = DateUtil.convertStrToDate(day + " 00:00:00");
        Date dayTo = DateUtil.convertStrToDate(day + " 23:59:59");

        //  만료일이 도래된 업무 공간을 가져온다.
        List<Workspace> workspaces = this.workspaceRepository.findExpireDate(dayFrom, dayTo);

        for (Workspace workspace : workspaces) {
            List<UserWorkspace> userWorkspaces = this.userWorkspaceService.findByWorkspaceIdAndManagerYn(workspace.getId(), true);

            if (userWorkspaces.size() > 0) {
                Map<String, Object> workspaceMap = new HashMap<>();
                workspaceMap.put("workspaceName", workspace.getName());
                workspaceMap.put("expireDate", DateUtil.convertDateToYYYYMMDD(workspace.getExpireDate()));
                workspaceMap.put("dayCount", dayCount);
                workspaceMap.put("name", userWorkspaces.get(0).getUser().getName());

                //  업무 공간 관리자에게 사용 기간 만료 예정일 알림
                this.systemEmailService.directEmail(new String[]{userWorkspaces.get(0).getUser().getAccount()}, EmailType.WORKSPACE_EXPIRE_ALARM, workspaceMap, null);
            }
        }
    }


    //  사용하고 있는 업무 공간이 활성 상태인지 확인한다. 사용 공간에서 로그인한 사용자가 비활성인지 확인한다.
    @Override
    @Transactional
    public void checkUseWorkspace() {
        User user = this.webAppUtil.getLoginUserObject();
        Workspace workspace = this.getWorkspace(user.getLastWorkspaceId());

        this.checkUseWorkspace(user, workspace.getId());
    }

    //  사용하고 있는 업무 공간이 활성 상태인지 확인한다. 사용 공간에서 로그인한 사용자가 비활성인지 확인한다.
    @Override
    @Transactional
    public void checkUseWorkspace(User user) {
        Workspace workspace = this.getWorkspace(user.getLastWorkspaceId());

        this.checkUseWorkspace(user, workspace.getId());
    }

    //  사용하고 있는 업무 공간이 활성 상태인지 확인한다. 사용 공간에서 로그인한 사용자가 비활성인지 확인한다.
    @Override
    @Transactional
    public Workspace checkUseWorkspace(User user, Long workspaceId) {
        if (user == null) {
            throw new OwlRuntimeException(
                    this.messageAccessor.getMessage(MsgConstants.USER_NOT_EXIST));
        }

        if (workspaceId == null) {
            throw new OwlRuntimeException(
                    this.messageAccessor.getMessage(MsgConstants.WORKSPACE_NOT_EXIST));
        }

        Workspace workspace = this.getWorkspace(workspaceId);

        if (workspace.getServiceType().equals(ServiceType.UNUSED)) {
            throw new OwlRuntimeException(
                    this.messageAccessor.getMessage(MsgConstants.WORKSPACE_USE_PERIOD_EXCESS));
        }

        UserWorkspace userWorkspace = this.userWorkspaceService.findByUserIdAndWorkspaceId(user.getId(), workspace.getId());

        if (!userWorkspace.getUseYn()) {
            //  해당 사용자가 관리하는 업무 공간를 마지막 접근 업무 공간로 변경한다.
            this.userService.updateLastMyWorkspace(userWorkspace.getUser());

            //  비활성 사용자는 더이상 해당 업무 공간에 있으면 안된다.
            this.simpMessagingTemplate.convertAndSendToUser(user.getAccount(), "/notification/workspace-remove", this.messageAccessor.getMessage(MsgConstants.WORKSPACE_OUT, workspace.getName()));

            throw new OwlRuntimeException(
                    this.messageAccessor.getMessage(MsgConstants.WORKSPACE_INCLUDE_DISABLED));
        }

        return workspace;
    }

    //  사용 공간에서 로그인한 사용자가 비활성인지 확인하고 비활성일 경우 엑셀 다운로드를 금지한다.
    @Override
    @Transactional
    public ModelAndView checkUseExcelDownload(Model model) {
        try {
            //  사용하고 있는 업무 공간이 활성 상태인지 확인한다. 사용 공간에서 로그인한 사용자가 비활성인지 확인한다.
            this.checkUseWorkspace();
        }
        catch (OwlRuntimeException e) {
            //  업무 공간 활성 체크에서 Exception 이 전송되어 이 부분에서 Exception 메세지를 전송하지 않는다.
            ExportExcelVo excelInfo = this.excelConditionCheck.makeEmptyDownloadExcel();
            excelInfo.setFileName(this.messageAccessor.message("common.excelDownloadNotPossibleExcludedFromTheWorkspace")); // 업무 공간에서 참여가 제외되어 엑셀 다운로드가 불가능합니다.
            model.addAttribute(Constants.EXCEL, excelInfo);
            return new ModelAndView(this.excelView);
        }

        return null;
    }

    //  트래픽 사용량을 저장하고 초과할 경우에는 해당 업무 공간에서 다운로드를 일시적으로 금지한다.
    @Override
    @Transactional
    public boolean checkUseTraffic(Long fileSize) {

        // zenith edit packageType 0 이상이면, 트래픽 제약이 없음. (local version)
        if(this.packageType > 0) {
            Workspace workspace = this.getWorkspace(this.userService.getUser(this.webAppUtil.getLoginId()).getLastWorkspaceId());

            //  트래픽은 사용 공간의 3배로 준다.
            if (workspace.getUseTraffic() > workspace.getStorageSize() * 3) {
                return false;
            }

            Long useTraffic = workspace.getUseTraffic() + fileSize;
            workspace.setUseTraffic(useTraffic);
            this.workspaceRepository.saveAndFlush(workspace);
        }
        
        return true;
    }

    //  업무 공간의 남은 사용 기간을 조회한다.
    @Override
    @Transactional(readOnly = true)
    public Map<String, Object> getWorkspaceExpireDay() {
        Map<String, Object> workspaceMap = new HashMap<>();
        Workspace workspace = this.getWorkspace(this.userService.getUser(this.webAppUtil.getLoginId()).getLastWorkspaceId());
        workspaceMap.put("name", workspace.getName());
        // zenith edit
        workspaceMap.put("expireDay", getRemainPeriod(new Date(), workspace.getExpireDate()));

        return workspaceMap;
    }
}