package com.dbnt.kcgfilemanager.service;

import com.dbnt.kcgfilemanager.config.LogStatus;
import com.dbnt.kcgfilemanager.mapper.BoardMapper;
import com.dbnt.kcgfilemanager.model.*;
import com.dbnt.kcgfilemanager.repository.*;
import lombok.RequiredArgsConstructor;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.web.multipart.MultipartFile;

import java.io.File;
import java.io.IOException;
import java.util.*;

@Service
@RequiredArgsConstructor
public class BoardService {

  private final FileInfoService fileInfoService;
  private final BoardCategoryService boardCategoryService;

  private final BoardMapper boardMapper;

  private final BoardRepository boardRepository;
  private final BoardCategoryRepository boardCategoryRepository;
  private final BoardLogRepository boardLogRepository;
  private final FileInfoRepository fileInfoRepository;
  private final HashTagRepository hashTagRepository;
  private final HashTagLinkRepository hashTagLinkRepository;
  private final UserInfoRepository userInfoRepository;

  @Value("${spring.servlet.multipart.location}")
  private String locationPath;

  public List<SearchResult> fullSearchBoardContent(List<Integer> categorySeqList, Board board) {
    board.setRowCnt(Integer.MAX_VALUE);
    List<SearchResult> results = new ArrayList<>();

    for(int categorySeq : categorySeqList){
      SearchResult searchResult = new SearchResult();
      BoardCategory category = boardCategoryRepository.findById(categorySeq).orElse(null);
      searchResult.setSearchCategoryName(boardCategoryService.getPageTitle(categorySeq));
      if(category.getDepth() != 4){
        category.setChildCategoryList(boardCategoryService.selectBoardCategoryAll(categorySeq, category.getDepth()+1));
        board.setCategoryList(setBoardCategoryToLastDepth(new ArrayList<>(), category));
      }else{
        board.setCategoryList(new ArrayList<>());
        board.getCategoryList().add(category);
      }

      searchResult.setContentList(selectContentList(board));
      results.add(searchResult);
    }
    return results;
  }

  @Transactional
  public Integer saveContent(Board content){
    Integer contentSeq = boardRepository.save(content).getContentSeq();
    saveBoardLog(content.getContentSeq(), LogStatus.WRITE, content.getTitle(), content.getCreateId());
    saveHashTagLink(contentSeq, content.getHashTagStr());
    saveUploadFiles(content, content.getCreateId());
    return contentSeq;
  }

  @Transactional
  public Integer updateContent(Board updateContent, List<Integer> fileSeqList, UserInfo userInfo) {
    int contentSeq = updateContent.getContentSeq();
    Board savedContent = boardRepository.findById(contentSeq).orElse(null);
    savedContent.setCategorySeq(updateContent.getCategorySeq());
    savedContent.setTitle(updateContent.getTitle());
    savedContent.setStatus(updateContent.getStatus());
    savedContent.setDescription(updateContent.getDescription());
    saveBoardLog(contentSeq, LogStatus.MODIFY, null, userInfo.getUserId());
    deleteHashTagLink(contentSeq);
    saveHashTagLink(contentSeq, updateContent.getHashTagStr());
    if(fileSeqList!=null){
      deleteFileInfo(contentSeq, fileSeqList, userInfo.getUserId());
    }
    if(updateContent.getFileList()!=null){
      saveUploadFiles(updateContent, userInfo.getUserId());
    }
    return contentSeq;
  }

  private void saveBoardLog(Integer contentSeq, LogStatus status, String description, String createId){
    BoardLog lastLog = boardLogRepository.findTopByContentSeqOrderByLogSeqDesc(contentSeq).orElse(null);
    BoardLog log = new BoardLog();
    log.setContentSeq(contentSeq);
    log.setLogSeq(lastLog == null?1:(lastLog.getLogSeq()+1));
    log.setLogStatus(status.name());
    log.setDescription(description);
    log.setCreateId(createId);
    boardLogRepository.save(log);
  }

  private HashTag saveHashTag(String tagName){
    HashTag tag = new HashTag();
    tag.setTagName(tagName);
    return hashTagRepository.save(tag);
  }

  private void saveHashTagLink(Integer contentSeq, String hashTagStr){
    String[] hashTagAry = hashTagStr.trim().replaceAll(",", "").split("#");
    for(String tagName : hashTagAry){
      if(!tagName.equals("")){
        HashTag tag = hashTagRepository.findByTagName(tagName).orElse(null);
        if(tag==null){
          tag = saveHashTag(tagName);
        }
        HashTagLink link = new HashTagLink();
        link.setContentSeq(contentSeq);
        link.setTagSeq(tag.getTagSeq());
        hashTagLinkRepository.save(link);
      }
    }
  }
  private void saveUploadFiles(Board content, String userId){
    FileInfo lastFileInfo = fileInfoRepository.findTopByContentSeqOrderByFileSeqDesc(content.getContentSeq()).orElse(null);
    int fileSeq = lastFileInfo==null?1:(lastFileInfo.getFileSeq()+1);
    for(MultipartFile file : content.getFileList()){
      String saveName = UUID.randomUUID().toString();
      String path = locationPath+boardCategoryService.makeFilePath(content.getCategorySeq());

      File saveFile = new File(path+File.separator+saveName);
      if(file.getSize()!=0){ // 저장될 파일 확인
        if(!saveFile.exists()){ // 저장될 경로 확인
          if(saveFile.getParentFile().mkdirs()){
            try{
              saveFile.createNewFile();
            }catch (IOException e){
              e.printStackTrace();
            }
          }
        }
        try {
          file.transferTo(saveFile);
        }catch (IllegalStateException | IOException e){
          e.printStackTrace();
        }
      }

      String originalFilename = file.getOriginalFilename();
      int extentionIdx = originalFilename.lastIndexOf(".");
      FileInfo fileInfo = new FileInfo();
      fileInfo.setContentSeq(content.getContentSeq());
      fileInfo.setFileSeq(fileSeq++);
      fileInfo.setOriginalName(originalFilename.substring(0, extentionIdx));
      fileInfo.setExtention(originalFilename.substring(extentionIdx+1));
      fileInfo.setConversionName(saveName);
      fileInfo.setFileSize(calculationSize(file.getSize()));
      fileInfo.setSavePath(path);
      fileInfoRepository.save(fileInfo);
      saveBoardLog(content.getContentSeq(), LogStatus.FILE_ADD, fileInfo.getFullName(), userId);
    }
  }

  public List<Board> selectContentList(Board board) {
    return boardMapper.selectContentList(board);
  }
  public Integer selectContentListCnt(Board board) {
    return boardMapper.selectContentListCnt(board);
  }

  @Transactional
  public Board selectContentByContentSeqAndViewCntUp(Integer contentSeq) {
    Board target = selectContent(contentSeq);
    if(!target.getStatus().equals("D")){
      target.setViewCnt(target.getViewCnt()+1);
    }
    return target;
  }
  public Board selectContent(int contentSeq){
    Board content = boardRepository.findById(contentSeq).orElse(null);
    content.setCreateName(userInfoRepository.findByUserId(content.getCreateId()).orElse(null).getUserId());
    return content;
  }
  public Board selectContentModifyInfo(int contentSeq){
    Board content = selectContent(contentSeq);
    content = selectContentForeignAttribute(content);
    StringBuilder hashTagStr = new StringBuilder();
    for(HashTag tag : content.getHashTagList()){
      hashTagStr.append("#").append(tag.getTagName()).append(", ");
    }
    if(!hashTagStr.toString().equals("")) {
      hashTagStr = new StringBuilder(hashTagStr.substring(0, hashTagStr.length() - 2));
      content.setHashTagStr(hashTagStr.toString());
    }
    return content;
  }
  public List<FileInfo> selectDownloadFileInfoList(Integer contentSeq, List<Integer> fileSeqList, String userId) {
    List<FileInfo> fileList = fileInfoRepository.findByContentSeqOrderByFileSeqAsc(contentSeq);
    List<FileInfo> targetList = new ArrayList<>();
    for(FileInfo file: fileList){
      if(fileSeqList.contains(file.getFileSeq())){
        targetList.add(file);
        saveBoardLog(contentSeq, LogStatus.FILE_DOWN, file.getFullName(), userId);
      }
    }
    return targetList;
  }
  public FileInfo selectDownloadFileInfo(Integer contestSeq, Integer fileSeq, String userId){
    FileInfo fileInfo = fileInfoRepository.findById(new FileInfo.FileInfoId(contestSeq, fileSeq)).orElse(null);
    saveBoardLog(contestSeq, LogStatus.FILE_DOWN, fileInfo.getFullName(), userId);
    return fileInfo;
  }

  public List<BoardLog> selectContentLog(Integer contentSeq){
    return boardMapper.selectBoardLogFromContentSeq(contentSeq);
  }

  public Board selectContentForeignAttribute(Board target) {
    target.setHashTagList(boardMapper.selectHashTagListFromContentSeq(target.getContentSeq()));
    target.setChildFileList(fileInfoRepository.findByContentSeqOrderByFileSeqAsc(target.getContentSeq()));
    return target;
  }

  @Transactional
  public Integer deleteContent(Board content, UserInfo user) {
    int contentSeq = content.getContentSeq();
    content = boardRepository.findById(contentSeq).orElse(null);
    content.setTitle("삭제된 게시물");
    content.setDescription(null);
    content.setStatus("D");
    saveBoardLog(contentSeq, LogStatus.DELETE, null, user.getUserId());
    deleteHashTagLink(contentSeq);
    fileInfoService.deleteFileInfoAll(contentSeq);
    return contentSeq;
  }

  public Board setHashTagSearch(Board board, List<String> tagNameList){
    List<HashTag> tagList = new ArrayList<>();
    StringBuilder sb = new StringBuilder();
    for(String tagName: tagNameList){
      HashTag tag = new HashTag();
      tag.setTagName(tagName);
      tagList.add(tag);
      sb.append(tagName).append(",");
    }
    board.setHashTagList(tagList);
    String hashTagStr = sb.toString();
    board.setHashTagStr(hashTagStr.substring(0, hashTagStr.length()-1));
    return board;
  }

  private List<BoardCategory> setBoardCategoryToLastDepth(List<BoardCategory> categoryList, BoardCategory category){
    for(BoardCategory child: category.getChildCategoryList()){
      if(child.getDepth()==4){
        categoryList.add(child);
      }
      setBoardCategoryToLastDepth(categoryList, child);
    }
    return categoryList;
  }

  private void deleteHashTagLink(int contentSeq){
    List<HashTagLink> tagLinkList = hashTagLinkRepository.findByContentSeq(contentSeq);
    hashTagLinkRepository.deleteAll(tagLinkList);
  }

  private void deleteFileInfo(Integer contentSeq, List<Integer> fileSeqList, String userId){
    List<FileInfo> fileInfoList = fileInfoRepository.findByContentSeqOrderByFileSeqAsc(contentSeq);
    for(FileInfo fileInfo: fileInfoList){
      if(fileSeqList.contains(fileInfo.getFileSeq())){
        fileInfoService.deleteStoredFile(new File(fileInfo.getSavePath(), fileInfo.getConversionName()));
        saveBoardLog(contentSeq, LogStatus.FILE_REMOVE, fileInfo.getFullName(), userId);
        fileInfoRepository.delete(fileInfo);
      }
    }
  }

  private String calculationSize(double fileSize){
    String[] units = {"bytes", "KB", "MB", "GB", "TB", "PB"};
    double unitSelector = Math.floor(Math.log(fileSize)/Math.log(1024));
    return Math.round((fileSize/Math.pow(1024, unitSelector))*100)/100d+" "+units[(int)unitSelector];
  }

  public List<BoardLog> selectBoardLogList(BoardLog boardLog) {
    return boardMapper.selectBoardLogList(boardLog);
  }

  public Integer selectBoardLogListCnt(BoardLog boardLog) {
    return boardMapper.selectBoardLogListCnt(boardLog);
  }

  public List<HashMap<String, Object>> getDiskInfoList() {
    /*설정된 경로의 용량 확인*/
    List<HashMap<String, Object>> diskInfoList = new ArrayList<>();
    File storage = new File(locationPath);
    double totalSize = storage.getTotalSpace();
    double useSize = storage.getUsableSpace();
    double freeSize = totalSize - useSize;

    HashMap<String, Object> diskInfo = new HashMap<>();
    diskInfo.put("driveName", storage.getAbsolutePath());
    diskInfo.put("totalSize", calculationSize(totalSize));
    diskInfo.put("useSize", calculationSize(useSize));
    diskInfo.put("freeSize", calculationSize(freeSize));
    diskInfo.put("useSizePer", Math.round(useSize/totalSize*10000)/100d);
    diskInfoList.add(diskInfo);
    return diskInfoList;
    /*전체 저장공간 확인*/
    /*File[] drives = File.listRoots();
    List<HashMap<String, Object>> diskInfoList = new ArrayList<>();
    for(File drive : drives) {
      double totalSize = drive.getTotalSpace();
      double useSize = drive.getUsableSpace();
      double freeSize = totalSize - useSize;

      HashMap<String, Object> diskInfo = new HashMap<>();
      diskInfo.put("driveName", drive.getAbsolutePath());
      diskInfo.put("totalSize", calculationSize(totalSize));
      diskInfo.put("useSize", calculationSize(useSize));
      diskInfo.put("freeSize", calculationSize(freeSize));
      diskInfo.put("useSizePer", Math.round(useSize/totalSize*10000)/100d);
      diskInfoList.add(diskInfo);
    }
    return diskInfoList;*/
  }
}