package com.whyc.service;

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.github.pagehelper.PageHelper;
import com.github.pagehelper.PageInfo;
import com.whyc.dto.Response;
import com.whyc.mapper.TechnicalSpecificationMapper;
import com.whyc.pojo.TechnicalSpecification;
import com.whyc.pojo.TechnicalSpecificationLockLog;
import com.whyc.util.ActionUtil;
import com.whyc.util.CommonUtil;
import com.whyc.util.DateUtil;
import org.apache.commons.lang3.StringUtils;
import org.apache.poi.openxml4j.exceptions.InvalidFormatException;
import org.apache.poi.ss.usermodel.Cell;
import org.apache.poi.ss.usermodel.Sheet;
import org.apache.poi.ss.usermodel.Workbook;
import org.apache.poi.ss.usermodel.WorkbookFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.web.multipart.MultipartFile;

import javax.annotation.Resource;
import java.io.File;
import java.io.IOException;
import java.io.InputStream;
import java.text.ParseException;
import java.util.Date;
import java.util.List;

@Service
public class TechnicalSpecificationService {
    @Resource
    private TechnicalSpecificationMapper mapper;

    @Autowired
    private DocUserService userService;

    @Autowired
    private ProductHistoryService productHistoryService;

    @Autowired
    private TechnicalSpecificationLockLogService lockLogService;

    public Response<Object> excelParse(InputStream inputStream) throws IOException, InvalidFormatException, ParseException {
        TechnicalSpecification specification = new TechnicalSpecification();

        Workbook workbook = null;
        workbook = WorkbookFactory.create(inputStream);
        inputStream.close();
        //取第一个sheet表
        Sheet sheet = workbook.getSheetAt(0);
        /*int lastRowNum = sheet.getLastRowNum();
        //校准lastRowNum
        for (int i = 8; i <= lastRowNum; i++) {
            if(sheet.getRow(i).getCell(1).getStringCellValue().equals("发布说明")){
                lastRowNum = i;
                break;
            }
        }*/
        //这里是固定的行8
        int lastRowNum = 8;
        //取固定部分值
        specification.setFileName(sheet.getRow(2).getCell(2).getStringCellValue());
        String typeStr = sheet.getRow(3).getCell(2).getStringCellValue();
        String[] typeArr = typeStr.split(" ");
        for (int i = 0; i < typeArr.length; i++) {
            //excel单元格中的✔对应字符,这里是R不是þ
            if(typeArr[i].startsWith("R")){
                specification.setType(typeArr[i].replace("R","").trim());
                break;
            }
        }
        specification.setVersion(sheet.getRow(4).getCell(2).getStringCellValue());
        specification.setBasedVersion(sheet.getRow(4).getCell(4).getStringCellValue());

        specification.setOwner(sheet.getRow(5).getCell(2).getStringCellValue());
        Cell cellFilingDate = sheet.getRow(5).getCell(4);
        if(cellFilingDate.getCellType() == Cell.CELL_TYPE_NUMERIC){
            Date dateCellValue = cellFilingDate.getDateCellValue();
            specification.setFilingDate(DateUtil.YYYY_MM_DD.format(dateCellValue));
            System.out.println(dateCellValue);
        }else {
            cellFilingDate.setCellType(Cell.CELL_TYPE_STRING);
            specification.setFilingDate(cellFilingDate.getStringCellValue());
        }
        //最后一行,取发布说明
        specification.setReleaseNotes(sheet.getRow(8).getCell(2).getStringCellValue());

        //行num=7是适用机型
        int applyModelNum = 7;
        //取第3列,第5列
        Cell cell = sheet.getRow(applyModelNum).getCell(2);
        cell.setCellType(Cell.CELL_TYPE_STRING);
        String stringCellValue = cell.getStringCellValue();
        if(StringUtils.isNotBlank(stringCellValue)){
            specification.setApplyMaterialCode(CommonUtil.codeAutoFill(stringCellValue));
        }
        specification.setApplyModel(sheet.getRow(applyModelNum).getCell(4).getStringCellValue());
        String customCode = sheet.getRow(applyModelNum).getCell(6).getStringCellValue();
        if(StringUtils.isBlank(customCode)){ //如果为空或者空字符串,则统一为""
            customCode = "";
        }
        specification.setApplyCustomCode(customCode);

        return new Response().setII(1,true,specification,"文件解析成功");

    }
    @Transactional
    public Response upload(MultipartFile file1, MultipartFile file2, TechnicalSpecification specification) throws IOException {
        //附件
        String file1Name = file1.getOriginalFilename();
        //excel
        String file2Name = file2.getOriginalFilename();
        //非空校验: 文件名,文件类型,版本,负责人,归档日期,物料编码,规格型号
        if(
            StringUtils.isBlank(specification.getFileName())
            || StringUtils.isBlank(specification.getType())
            || StringUtils.isBlank(specification.getVersion())
            || StringUtils.isBlank(specification.getOwner())
            || StringUtils.isBlank(specification.getFilingDate())
            || StringUtils.isBlank(specification.getApplyMaterialCode())
            || StringUtils.isBlank(specification.getApplyModel())
        ){
            return new Response().set(1,false,"文件名,文件类型,版本,负责人,归档日期,物料编码,规格型号 中至少有一项为空");
        }

        //校验规格书附件名称=说明书中的文件名称+版本号
        String fileNameUnion = specification.getFileName() + specification.getVersion();
        String attachmentName = file1Name.substring(0,file1Name.lastIndexOf("."));
        if(!(fileNameUnion).equals(attachmentName)){
            return new Response().set(1,false,"附件的命名与技术规格书excel内的文件名+版本号称不一致");
        }
        //校验负责人是否存在
        boolean checkExists = userService.checkExists(specification.getOwner());
        if(!checkExists){
            return new Response().set(1,false,"负责人不存在");
        }
        //校验产品是否存在
        boolean productCheckExists = productHistoryService.checkExists(specification.getApplyMaterialCode(), specification.getApplyCustomCode());
        if(!productCheckExists){
            return new Response().set(1,false,"规格书适用机型不存在");
        }
        //是否需要校验相同机型是否存在同版本号的? TODO

        Date date = new Date();
        String dateUnion = DateUtil.YYYY_MM_DD_HH_MM_SS_UNION.format(date);
        //文件重命名(严格遵守名称规则的情况下不会重名)
        file1Name = file1Name.substring(0,file1Name.lastIndexOf(".")) + "_" + dateUnion +file1Name.substring(file1Name.lastIndexOf("."));
        file2Name = file2Name.substring(0,file2Name.lastIndexOf(".")) + "_" + dateUnion +file2Name.substring(file2Name.lastIndexOf("."));
        //存储路径
        String rootFile = CommonUtil.getRootFile();
        String specificationDir = rootFile + "technical_specification" + File.separator + specification.getOwner()+ File.separator + specification.getFileName();
        String specificationHttpUrl = specificationDir.substring(specificationDir.lastIndexOf("doc_file"+ File.separator + "technical_specification"));
        File specificationDirFile = new File(specificationDir);
        if(!specificationDirFile.exists()){
            specificationDirFile.mkdirs();
        }
        file1.transferTo(new File(specificationDir+File.separator+file1Name));
        file2.transferTo(new File(specificationDir+File.separator+file2Name));
        //设置路径

        specification.setFileUrl(specificationHttpUrl+File.separator+file1Name);
        specification.setExcelUrl(specificationHttpUrl+File.separator+file2Name);
        specification.setCreateTime(date);
        specification.setUploadUser(ActionUtil.getUser().getName());
        //锁定-负责人才能解锁
        specification.setLockFlag(1);
        mapper.insert(specification);
        //锁定适用机型的生效版本
        lockOtherByAppliedProduct(specification);
        //锁定日志
        TechnicalSpecificationLockLog lockLog = new TechnicalSpecificationLockLog();
        lockLog.setUserName("系统");
        lockLog.setTechnicalSpecificationId(specification.getId());
        lockLog.setReason("系统默认锁定,新版本技术规则书上传");
        lockLog.setCreateTime(date);
        lockLog.setStatus(0);
        lockLogService.add(lockLog);
        return new Response().set(1,true,"上传完成");
    }

    private void lockOtherByAppliedProduct(TechnicalSpecification specification) {
        //先查询
        QueryWrapper<TechnicalSpecification> query = Wrappers.query();
        query.eq("apply_material_code",specification.getApplyMaterialCode());
        query.eq("apply_custom_code", specification.getApplyCustomCode());
        query.eq("lock_flag",0);
        query.last(" limit 1");
        TechnicalSpecification specificationToBeLocked = mapper.selectOne(query);
        if(specificationToBeLocked !=null){ //存在生效的,需要被锁定
            specificationToBeLocked.setLockFlag(1);
            mapper.updateById(specificationToBeLocked);
            //锁定日志
            TechnicalSpecificationLockLog lockLog = new TechnicalSpecificationLockLog();
            lockLog.setUserName("系统");
            lockLog.setTechnicalSpecificationId(specificationToBeLocked.getId());
            lockLog.setReason("系统默认锁定,新版本技术规则书上传,旧版本锁定");
            lockLog.setCreateTime(new Date());
            lockLog.setStatus(0);
            lockLogService.add(lockLog);
        }


        UpdateWrapper<TechnicalSpecification> update = Wrappers.update();
        update.set("lock_flag",1);
        //update.set("lock_reason","系统默认锁定,新版本技术规则书上传,旧版本锁定");
        update.eq("apply_material_code",specification.getApplyMaterialCode());
        update.eq("apply_custom_code", specification.getApplyCustomCode());

        update.eq("lock_flag",0);
        update.last(" limit 1");

        mapper.update(null,update);
    }

    @Transactional
    public Response updateLock(int id, int lockFlag, String reason) {
        Date date = new Date();
        String userName = ActionUtil.getUser().getName();
        TechnicalSpecification specificationInDB = get(id);
        if(!userName.equals(specificationInDB.getOwner())){
            return new Response().set(1,false,"非负责人无法解锁");
        }
        //校验解锁时,存在解锁版本,无法解锁
        if(lockFlag == 0){
            TechnicalSpecification availableVersion = getAvailableVersion(specificationInDB.getApplyMaterialCode(),specificationInDB.getApplyCustomCode());
            if(availableVersion!=null){
                if(!availableVersion.getOwner().equals(userName)) {
                    return new Response().set(1, false, "存在生效版本,无法解锁. 目前生效版本负责人为" + availableVersion.getOwner() + ",生效版本为:" + availableVersion.getVersion());
                }else{
                    //锁定目前生效版本
                    availableVersion.setLockFlag(1);
                    mapper.updateById(availableVersion);
                    //锁定日志
                    TechnicalSpecificationLockLog lockLog = new TechnicalSpecificationLockLog();
                    lockLog.setUserName(userName);
                    lockLog.setTechnicalSpecificationId(id);
                    lockLog.setReason("新版本解锁,此旧版本锁定");
                    lockLog.setCreateTime(date);
                    lockLog.setStatus(0);
                    lockLogService.add(lockLog);
                }
            }
        }
        specificationInDB.setLockFlag(lockFlag);
        mapper.updateById(specificationInDB);
        //锁定/解锁日志
        TechnicalSpecificationLockLog lockLog = new TechnicalSpecificationLockLog();
        lockLog.setUserName(userName);
        lockLog.setTechnicalSpecificationId(id);
        lockLog.setReason(reason);
        lockLog.setCreateTime(date);
        lockLog.setStatus(lockFlag==1?0:1);
        lockLogService.add(lockLog);
        return new Response().set(1, true, "更新完成");
    }

    private TechnicalSpecification getAvailableVersion(String applyMaterialCode, String applyCustomCode) {
        QueryWrapper<TechnicalSpecification> query = Wrappers.query();
        query.eq("apply_material_code",applyMaterialCode);
        query.eq("apply_custom_code",applyCustomCode);
        query.eq("lock_flag",0);
        query.last(" limit 1");
        return mapper.selectOne(query);
    }

    private TechnicalSpecification get(int id){
        return mapper.selectById(id);
    }

    //查询技术规格书
    public Response getInfo(String applyMaterialCode, String applyModel, String applyCustomCode, String owner, Integer lockFlag
                            ,int pageNum, int pageSize) {
        PageHelper.startPage(pageNum,pageSize);
        QueryWrapper<TechnicalSpecification> query = Wrappers.query();
        if(applyMaterialCode!=null&&!applyMaterialCode.isEmpty()){
            query.like("apply_material_code",applyMaterialCode);
        }
        if(applyModel!=null&&!applyModel.isEmpty()){
            query.like("apply_model",applyModel);
        }
        if(applyCustomCode!=null){
            if(applyCustomCode.equals("")){
                query.eq("apply_custom_code",applyCustomCode);
            }else{
                query.like("apply_custom_code",applyCustomCode);
            }
        }
        if(owner!=null&&!owner.isEmpty()){
            query.like("owner",owner);
        }
        if(lockFlag!=null){
            query.eq("lock_flag",lockFlag);
        }
        List<TechnicalSpecification> list=mapper.selectList(query);
        //标识每条记录适用机型可用的版本的负责人是不是这条记录的负责人
        if(list!=null&&list.size()>0){
            for (TechnicalSpecification t:list) {
                TechnicalSpecification enableTe=getEnableVersion(t);
                if(enableTe!=null){
                   if(enableTe.getOwner().equals(t.getOwner())){
                       t.setFlag(1);
                   }else{
                       t.setFlag(0);
                   }
                }else {
                    t.setFlag(1);
                }
            }
        }
        PageInfo pageInfo=new PageInfo(list);
        return new Response().setII(1,list!=null,pageInfo,"查询技术规格书");
    }
    //查询每条记录适用机型可用的版本
    public TechnicalSpecification getEnableVersion(TechnicalSpecification t){
        QueryWrapper wrapper=new QueryWrapper();
        wrapper.eq("apply_material_code",t.getApplyMaterialCode());
        wrapper.eq("apply_model",t.getApplyModel());
        wrapper.eq("apply_custom_code",t.getApplyCustomCode());
        wrapper.last("limit 1");
        TechnicalSpecification enableTe=mapper.selectOne(wrapper);
        return enableTe;
    }

   //查询指定技术规格书的所有版本
    public Response getVersionByInfo(String applyMaterialCode, String applyModel, String applyCustomCode) {
        QueryWrapper<TechnicalSpecification> query = Wrappers.query();
        if(applyMaterialCode!=null&&!applyMaterialCode.isEmpty()){
            query.eq("apply_material_code",applyMaterialCode);
        }
        if(applyModel!=null&&!applyModel.isEmpty()){
            query.eq("apply_model",applyModel);
        }
        if(applyCustomCode!=null){
            query.eq("apply_custom_code",applyCustomCode);
        }
        List<TechnicalSpecification> list=mapper.selectList(query);
        //标识每条记录适用机型可用的版本的负责人是不是这条记录的负责人
        if(list!=null&&list.size()>0){
            for (TechnicalSpecification t:list) {
                TechnicalSpecification enableTe=getEnableVersion(t);
                if(enableTe!=null){
                    if(enableTe.getOwner().equals(t.getOwner())){
                        t.setFlag(1);
                    }else{
                        t.setFlag(0);
                    }
                }else {
                    t.setFlag(1);
                }
            }
        }
        return new Response().setII(1,list!=null,list,"查询指定技术规格书的所有版本");
    }
}