package com.cloudroam.controller.v1;

import cn.hutool.core.util.StrUtil;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.cloudroam.bo.ProjectDailyBO;
import com.cloudroam.common.LocalUser;
import com.cloudroam.common.util.PageUtil;
import com.cloudroam.dto.projectDaily.*;
import com.cloudroam.common.enumeration.DailyCommitEnum;
import com.cloudroam.common.enumeration.DailyConfirmEnum;
import com.cloudroam.common.enumeration.DailyStatusEnum;
import com.cloudroam.model.UserDO;
import com.cloudroam.service.MailService;
import com.cloudroam.service.ProjectDailyService;
import com.cloudroam.util.JsonUtil;
import com.cloudroam.vo.*;
import com.cloudroam.vo.projectDaily.ProjectDailyBoardVO;
import com.cloudroam.vo.projectDaily.ProjectDailyHourVO;
import io.github.talelin.autoconfigure.exception.ForbiddenException;
import io.github.talelin.autoconfigure.exception.NotFoundException;
import io.github.talelin.core.annotation.Logger;
import io.github.talelin.core.annotation.LoginRequired;
import io.github.talelin.core.annotation.PermissionMeta;

import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;


import org.springframework.validation.annotation.Validated;


import com.cloudroam.model.ProjectDailyDO;
import org.springframework.web.bind.annotation.*;

import java.math.BigDecimal;
import java.util.Date;
import java.util.List;

/**
* @author generator@TaoJie
* @since 2023-08-09
*/
@RestController
@RequestMapping("/v1/projectDaily")
@Validated
public class ProjectDailyController {

    @Autowired
    private ProjectDailyService projectDailyService;


    @Autowired
    private MailService mailService;

    @PostMapping("")
    @LoginRequired
    @PermissionMeta(value = "日志创建", module = "工作日志",mount = false)
    @Logger(template = "{user.nickname} 创建了日志 ")

    public CreatedVO create(@RequestBody @Validated CreateOrUpdateProjectDailyDTO validator) {
        projectDailyService.createProjectDailyWithInit(validator);
        return new CreatedVO();
    }

    @PostMapping("/saveBatch")
    @LoginRequired
    @PermissionMeta(value = "日志批量创建", module = "工作日志",mount = false)
    @Logger(template = "{user.nickname} 批量创建了日志 ")
    public CreatedVO createBatch(@RequestBody CreateBatchDTO dto) {
        if(StrUtil.isBlank(dto.getDailyList())){
            throw new ForbiddenException(10301);
        }

        projectDailyService.createProjectDailyBatchWithInit(dto);

        return new CreatedVO();
    }

    @PostMapping("/batch/task")
    @LoginRequired
    @PermissionMeta(value = "任务日志批量创建", module = "工作日志",mount = false)
    @Logger(template = "{user.nickname} 批量创建了日志 ")
    public CreatedVO createBatchNew( @Validated @RequestBody CreateBatchTaskDTO dto) {

        projectDailyService.createProjectDailyBatchWithTask(dto);

        return new CreatedVO();
    }

    @GetMapping("/existsHours")
    @LoginRequired
//    @PermissionMeta(value = "日志已存在的工时", module = "工作日志",mount = false)
//    @Logger(template = "{user.nickname} 批量创建了日志 ")
    public ProjectDailyHourVO existsHours(DailyHourDTO dto) {
        ProjectDailyHourVO projectDailyHourVO= projectDailyService.existsHours(dto);
        return projectDailyHourVO;
    }

    @PostMapping("/supplementaryBatch")
    @LoginRequired
    @PermissionMeta(value = "日志批量补录", module = "工作日志",mount = false)
    @Logger(template = "{user.nickname} 批量补录了日志 ")
    public CreatedVO supplementaryBatch(@RequestBody CreateBatchDTO dto) {
        if(StrUtil.isBlank(dto.getDailyList())){
            throw new ForbiddenException(10301);
        }

        // 将json串反序列化成数组
        List<ProjectDailyDO> list= JsonUtil.json2List(dto.getDailyList(),ProjectDailyDO.class);
        projectDailyService.supplementaryProjectDailyBatch(list);

        return new CreatedVO();
    }


    @PutMapping("/{id}")
    @LoginRequired
    @PermissionMeta(value = "日志更新", module = "工作日志",mount = false)
    @Logger(template = "{user.nickname} 更新了日志 ")
    public UpdatedVO update(@RequestBody @Validated CreateOrUpdateProjectDailyDTO validator) {
        if(StrUtil.isBlank(validator.getId())){
            throw new NotFoundException("传入的Id不能为空");
        }
        ProjectDailyDO projectDailyDO=projectDailyService.getById(validator.getId());
        if(projectDailyDO == null){
            throw new NotFoundException("日志不存在");
        }

        projectDailyService.updateProjectDailyWithInit(validator);

        return new UpdatedVO();
    }

    @PutMapping("/actualHours/{id}")
    @LoginRequired
    @PermissionMeta(value = "实际工时提交", module = "工作日志",mount = false)
    @Logger(template = "{user.nickname} 提交实际工时 ")
    public UpdatedVO updateActualHours(@PathVariable String id,@RequestBody @Validated CreateOrUpdateProjectDailyDTO validator) {
        if(StrUtil.isBlank(id)){
            throw new NotFoundException("传入的Id不能为空");
        }
        ProjectDailyDO projectDailyDO=projectDailyService.getById(id);
        if(projectDailyDO == null){
            throw new NotFoundException("日志不存在");
        }

        // 如果日志状态被关闭了，则不需要填写工时,但是需要写备注
        if(validator.getDailyStatus().equals(DailyStatusEnum.CLOSED.getCode())&&StrUtil.isBlank(validator.getRemark())){
            throw new ForbiddenException(10306);
        }else if(!validator.getDailyStatus().equals(DailyStatusEnum.CLOSED.getCode())&&(null==validator.getActualHours()||validator.getActualHours().compareTo(BigDecimal.ZERO)==0)){
            throw new ForbiddenException(10305);
        }

        validator.setId(id);

        projectDailyService.updateActualHours(validator);


        return new UpdatedVO();
    }


    @PutMapping("/actualHours/batch")
    @LoginRequired
    @PermissionMeta(value = "实际工时提交", module = "工作日志",mount = false)
    @Logger(template = "{user.nickname} 提交实际工时 ")
    public UpdatedVO updateActualHoursBatch(@RequestBody ConfirmActualBatchDTO dto) {

        boolean result=projectDailyService.updateActualHoursBatch(dto.getDailyList());
        if(result){
            return new UpdatedVO("确认工时成功");
        }else{
            return new UpdatedVO("确认工时失败");
        }

    }


    @LoginRequired
    @DeleteMapping("/{id}")
    @PermissionMeta(value = "日志删除", module = "工作日志",mount = false)
    @Logger(template = "{user.nickname} 删除了日志 ")
    public DeletedVO delete(@PathVariable String id) {
        if(StrUtil.isBlank(id)){
            throw new NotFoundException("id不能为空");
        }
        ProjectDailyDO projectDailyDO=projectDailyService.getById(id);
        if (projectDailyDO == null) {
            throw new NotFoundException("日志不存在");
        }
//        projectDailyService.removeById(id);
        projectDailyService.removeByIdLogic(id,projectDailyDO.getDailyDate());

        return new DeletedVO();
    }

    @GetMapping("/{id}")
    public ProjectDailyDO get(@PathVariable(value = "id") String id) {
        if(StrUtil.isBlank(id)){
            throw new NotFoundException("id不能为空");
        }
        return projectDailyService.getById(id);
    }

    @LoginRequired
    @GetMapping("/byDate/{dailyDate}")
    public List<ProjectDailyDO> getByDailyDate(@PathVariable(value = "dailyDate") String dailyDate) {
        if(StrUtil.isBlank(dailyDate)){
            throw new NotFoundException("dailyDate不能为空");
        }
        return projectDailyService.getByDailyDate(dailyDate);
    }


    @GetMapping("/page")
    @PermissionMeta(value = "全部日志", module = "工作日志")
    @Logger(template = "{user.nickname} 查看了工作日志列表 ")
    @LoginRequired
    public PageResponseVO<ProjectDailyBO> page(
            @Validated QueryProjectDailyDTO dto
    ) {
        // 只显示已经提交的日志
//        dto.setIsCommit(DailyCommitEnum.COMMITED.getCode());
        IPage<ProjectDailyBO> iPage=projectDailyService.getProjectDailyPage(dto);
        return PageUtil.build(iPage);
    }

    @GetMapping("/pagePersonal")
    @PermissionMeta(value = "我的日志", module = "工作日志",mount = true)
    @Logger(template = "{user.nickname} 查看了工作日志 ")
    @LoginRequired
    public PageResponseVO<ProjectDailyBO> pagePersonal(
            @Validated QueryProjectDailyDTO dto
    ) {
        UserDO userDO=LocalUser.getLocalUser();
        dto.setCreateUserId(String.valueOf(userDO.getId()));
        IPage<ProjectDailyBO> iPage=projectDailyService.getProjectDailyPage(dto);
        return PageUtil.build(iPage);
    }

    /**
     * 只是在工作日志下新增了一个工时统计菜单权限
     * @param dto
     * @return
     */
    @GetMapping("/hour/statistics")
    @PermissionMeta(value = "工时统计", module = "工作日志",mount = true)
    @Logger(template = "{user.nickname} 查看了工时统计 ")
    @LoginRequired
    public PageResponseVO<ProjectDailyBO> hourStatistics(
            @Validated QueryProjectDailyDTO dto
    ) {
        return PageUtil.build(null);
    }



    @PutMapping("/commit/{id}")
    @LoginRequired
//    @PermissionMeta(value = "日志提交", module = "工作日志")
//    @Logger(template = "{user.nickname} 提交了日志 ")
    public UpdatedVO commit(@PathVariable String id) {
        if(StrUtil.isBlank(id)){
            throw new NotFoundException("传入的Id不能为空");
        }
        ProjectDailyDO projectDailyDO=projectDailyService.getById(id);
        if(projectDailyDO == null){
            throw new NotFoundException("日志不存在");
        }


        projectDailyService.commit(id);

        return new UpdatedVO();
    }


    @PutMapping("/commit-batch")
    @LoginRequired
    @PermissionMeta(value = "日志批量提交", module = "工作日志",mount = false)
    @Logger(template = "{user.nickname} 批量提交了日志 ")
    public UpdatedVO commitBatch(@RequestBody CommitBatchDTO dto) {

        UserDO userDO = LocalUser.getLocalUser();

        QueryProjectDailyDTO projectDailyDTO=new QueryProjectDailyDTO();
        BeanUtils.copyProperties(dto,projectDailyDTO);

        // 设置当前要提交人的id
        projectDailyDTO.setCreateUserId(String.valueOf(userDO.getId()));

        List<ProjectDailyDO> dailyList=projectDailyService.getProjectDailyList(projectDailyDTO);

        if(null==dailyList||dailyList.size()==0){
            throw new ForbiddenException(10302);
        }

        projectDailyService.commitBatch(dto);

        // 邮件确认
//        mailService.sendCommitDailyMail(userDO,dto.getDailyDate());


        return new UpdatedVO();
    }





    @PutMapping("/confirm/{id}")
    @LoginRequired
    @PermissionMeta(value = "日志确认", module = "工作日志")
    @Logger(template = "{user.nickname} 确认了日志 ")
    public UpdatedVO confirm(@PathVariable String id,@RequestBody ConfirmBatchDTO dto) {
        if(StrUtil.isBlank(id)){
            throw new NotFoundException("传入的Id不能为空");
        }
        ProjectDailyDO projectDailyDO=projectDailyService.getById(id);
        if(projectDailyDO == null){
            throw new NotFoundException("日志不存在");
        }
        UserDO user = LocalUser.getLocalUser();

        projectDailyDO=new ProjectDailyDO();
        projectDailyDO.setId(id);
        if(dto.getIsConfirm().equals(DailyConfirmEnum.UNPASS.getCode())){
            projectDailyDO.setIsCommit(DailyCommitEnum.UNCOMMITED.getCode());
            projectDailyDO.setCommitTime(new Date());
            projectDailyDO.setCommitUserId(String.valueOf(user.getId()));
            projectDailyDO.setCommitUserName(user.getNickname());
        }
        projectDailyDO.setIsConfirm(dto.getIsConfirm());
        projectDailyDO.setConfirmTime(new Date());
        projectDailyDO.setConfirmUserId(String.valueOf(user.getId()));
        projectDailyDO.setConfirmUserName(user.getNickname());
        projectDailyDO.setConfirmContent(dto.getConfirmContent());

        projectDailyService.updateById(projectDailyDO);
        return new UpdatedVO();
    }


    @PutMapping("/confirm-batch")
    @LoginRequired
    @PermissionMeta(value = "日志确认", module = "工作日志",mount = false)
    @Logger(template = "{user.nickname} 确认了日志 ")
    public UpdatedVO confirmBatch(@RequestBody ConfirmBatchDTO dto) {

        UserDO userDO = LocalUser.getLocalUser();



        // 根据条件查找要批量确认的是不是有存在未提交的，如果存在未提交的则不允许确认

        List<ProjectDailyDO> unCommitDailyList=projectDailyService.getUncommitDailyList(dto);

        if(null!=unCommitDailyList && unCommitDailyList.size()>0){
            throw new ForbiddenException(10307);
        }


        // 查看当前的人是否有需要确认的


        List<ProjectDailyDO> waitConfirmDailyList=projectDailyService.getWaitConfirmDailyList(dto);

        if(null==waitConfirmDailyList||waitConfirmDailyList.size()==0){
            // 此人没有需要确认的日志
            throw new ForbiddenException(10303);
        }

        // 批量日志的确认
        projectDailyService.confirmBatch(dto);




//        if(dto.getIsConfirm().equals(DailyConfirmEnum.CONFIRM.getCode())){
//
//            projectDailyService.confirmBatch(dto);
//
//            // 邮件确认
//            // 这里判断如果用户是-1的话，则需要查找到所有有未确认的人，进行遍历
//          /* if("-1".equals(dto.getCreateUserId())){
//               // 获取所有未确认日志的人，并循环发送邮件
//               List<UserDO> userDOList=projectDailyService.getUnComfirmedPeoples(dto.getDailyDate());
//               userDOList.forEach(userDO1 ->
//                       mailService.sendConfirmDailyMail(userDO,dto.getDailyDate(),String.valueOf(userDO1.getId()),dto.getConfirmContent()));
//
//           }else{
//               mailService.sendConfirmDailyMail(userDO,dto.getDailyDate(),dto.getCreateUserId(),dto.getConfirmContent());
//
//           }*/
//
//        }else if(dto.getIsConfirm().equals(DailyConfirmEnum.UNPASS.getCode())){
//
//            projectDailyService.confirmBatch(dto);
//
//            // 邮件审核不通过
////            mailService.sendConfirmUnPassDailyMail(userDO,dto.getDailyDate(),dto.getCreateUserId(),dto.getConfirmContent());
//        }


        return new UpdatedVO();
    }



    @PutMapping("/unconfirm-batch")
    @LoginRequired
    @PermissionMeta(value = "日志未确认", module = "工作日志",mount = false)
    @Logger(template = "{user.nickname} 将日志设为了为未确认 ")
    public UpdatedVO unConfirmBatch(@RequestBody ConfirmBatchDTO dto) {

        UserDO userDO = LocalUser.getLocalUser();

        QueryProjectDailyDTO projectDailyDTO=new QueryProjectDailyDTO();
        BeanUtils.copyProperties(dto,projectDailyDTO);
//        projectDailyDTO.setIsCommit(DailyCommitEnum.COMMITED.getCode());
        projectDailyDTO.setIsConfirm(DailyConfirmEnum.CONFIRM.getCode());
        if("-1".equals(dto.getCreateUserId())){
            projectDailyDTO.setCreateUserId(null);
        }

        List<ProjectDailyDO> dailyList=projectDailyService.getProjectDailyList(projectDailyDTO);

        if(null==dailyList||dailyList.size()==0){
            // 此人没有需要确认的日志
            throw new ForbiddenException(10304);
        }

        projectDailyService.unConfirmBatch(dto);

        // 邮件确认
//        mailService.sendUnConfirmDailyMail(userDO,dto.getDailyDate(),dto.getCreateUserId());

        return new UpdatedVO();
    }



    @PutMapping("/unConfirm/{id}")
    @LoginRequired
//    @PermissionMeta(value = "日志未确认", module = "工作日志")
//    @Logger(template = "{user.nickname} 未确认了日志 ")
    public UpdatedVO unConfirm(@PathVariable String id) {
        if(StrUtil.isBlank(id)){
            throw new NotFoundException("传入的Id不能为空");
        }
        ProjectDailyDO projectDailyDO=projectDailyService.getById(id);
        if(projectDailyDO == null){
            throw new NotFoundException("日志不存在");
        }
        UserDO user = LocalUser.getLocalUser();

        projectDailyDO=new ProjectDailyDO();
        projectDailyDO.setId(id);
        projectDailyDO.setIsConfirm(DailyConfirmEnum.UNCONFIRM.getCode());
        projectDailyDO.setConfirmTime(new Date());
        projectDailyDO.setConfirmUserId(String.valueOf(user.getId()));
        projectDailyDO.setConfirmUserName(user.getNickname());

        projectDailyService.updateById(projectDailyDO);
        return new UpdatedVO();
    }


    @GetMapping("/userList")
    public List<UserDO> getAllUsers(
            @Validated QueryProjectDailyDTO dto
    ) {
        List<UserDO> list=projectDailyService.getAllUsers(dto);
        return list;
    }


    @LoginRequired
    @PermissionMeta(value = "日志看板", module = "工作日志",mount = true)
    @Logger(template = "{user.nickname} 查看了日志看板 ")
    @GetMapping("/dailyBoardList")
    public ProjectDailyBoardVO getDailyBoardList(
            @Validated QueryProjectDailyBoardDTO dto
    ) {

        return projectDailyService.getProjectDailyBoardList(dto);

    }

    @GetMapping("/dailyDateList")
    @LoginRequired
    public List<ProjectDailyDO> getDailyDateList(
            @Validated CommitBatchDTO dto
    ) {
        UserDO userDO=new UserDO();
        QueryProjectDailyDTO dailyDTO=new QueryProjectDailyDTO();
        BeanUtils.copyProperties(dto,dailyDTO);
        dailyDTO.setCreateUserId(String.valueOf(userDO.getId()));
        List<ProjectDailyDO> dailyList=projectDailyService.getProjectDailyList(dailyDTO);
        return dailyList;
    }



    @GetMapping("/dailyDatePlanTime")
    @LoginRequired
    public Double getDailyDatePlanTime(
            @Validated WorkTimeDTO dto
    ) {

        Double planTime=projectDailyService.getDailyDatePlanTime(dto);
        return planTime;
    }

    @GetMapping("/dailyDateActualTime")
    @LoginRequired
    public Double getDailyDateActualTime(
            @Validated WorkTimeDTO dto
    ) {

        Double planTime=projectDailyService.getDailyDateActualTime(dto);
        return planTime;
    }

}