package org.jeecg.modules.projectManagement.controller;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Map;
import java.io.IOException;
import java.io.UnsupportedEncodingException;
import java.net.URLDecoder;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import org.jeecg.common.api.vo.Result;
import org.jeecg.common.system.query.QueryGenerator;
import org.jeecg.common.util.oConvertUtils;
import org.jeecg.modules.projectManagement.entity.FdBioanalysisTemplate;
import org.jeecg.modules.projectManagement.entity.FdBioanalysisTemplateTree;
import org.jeecg.modules.projectManagement.service.IFdBioanalysisTemplateService;

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import lombok.extern.slf4j.Slf4j;

import org.jeecgframework.poi.excel.ExcelImportUtil;
import org.jeecgframework.poi.excel.def.NormalExcelConstants;
import org.jeecgframework.poi.excel.entity.ExportParams;
import org.jeecgframework.poi.excel.entity.ImportParams;
import org.jeecgframework.poi.excel.view.JeecgEntityExcelView;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import org.springframework.web.multipart.MultipartFile;
import org.springframework.web.multipart.MultipartHttpServletRequest;
import org.springframework.web.servlet.ModelAndView;
import com.alibaba.fastjson.JSON;

/**
 * @Title: Controller
 * @Description: 生物分析里程碑模板
 * @author： jeecg-boot
 * @date： 2019-08-05
 * @version： V1.0
 */
@RestController
@RequestMapping("/projectManagement/fdBioanalysisTemplate")
@Slf4j
public class FdBioanalysisTemplateController {
    @Autowired
    private IFdBioanalysisTemplateService fdBioanalysisTemplateService;

    /**
     * 分页列表查询
     *
     * @param fdBioanalysisTemplate
     * @param pageNo
     * @param pageSize
     * @param req
     * @return
     */
    @GetMapping(value = "/list")
    public Result<IPage<FdBioanalysisTemplate>> queryPageList(FdBioanalysisTemplate fdBioanalysisTemplate,
                                                              @RequestParam(name = "pageNo", defaultValue = "1") Integer pageNo,
                                                              @RequestParam(name = "pageSize", defaultValue = "10") Integer pageSize,
                                                              HttpServletRequest req) {
        Result<IPage<FdBioanalysisTemplate>> result = new Result<IPage<FdBioanalysisTemplate>>();
        QueryWrapper<FdBioanalysisTemplate> queryWrapper = QueryGenerator.initQueryWrapper(fdBioanalysisTemplate, req.getParameterMap());
        Page<FdBioanalysisTemplate> page = new Page<FdBioanalysisTemplate>(pageNo, pageSize);
        IPage<FdBioanalysisTemplate> pageList = fdBioanalysisTemplateService.page(page, queryWrapper);
        result.setSuccess(true);
        result.setResult(pageList);
        return result;
    }

    /**
     * 添加
     *
     * @param fdBioanalysisTemplate
     * @return
     */
    @PostMapping(value = "/add")
    public Result<FdBioanalysisTemplate> add(@RequestBody FdBioanalysisTemplate fdBioanalysisTemplate) {
        Result<FdBioanalysisTemplate> result = new Result<FdBioanalysisTemplate>();
        try {
            fdBioanalysisTemplateService.save(fdBioanalysisTemplate);
            result.success("添加成功！");
        } catch (Exception e) {
            e.printStackTrace();
            log.info(e.getMessage());
            result.error500("操作失败");
        }
        return result;
    }

    /**
     * 编辑
     *
     * @param fdBioanalysisTemplate
     * @return
     */
    @PutMapping(value = "/edit")
    public Result<FdBioanalysisTemplate> edit(@RequestBody FdBioanalysisTemplate fdBioanalysisTemplate) {
        Result<FdBioanalysisTemplate> result = new Result<FdBioanalysisTemplate>();
        FdBioanalysisTemplate fdBioanalysisTemplateEntity = fdBioanalysisTemplateService.getById(fdBioanalysisTemplate.getId());
        if (fdBioanalysisTemplateEntity == null) {
            result.error500("未找到对应实体");
        } else {
            boolean ok = fdBioanalysisTemplateService.updateById(fdBioanalysisTemplate);
            //TODO 返回false说明什么？
            if (ok) {
                result.success("修改成功!");
            }
        }

        return result;
    }

    /**
     * 通过id删除
     *
     * @param id
     * @return
     */
    @DeleteMapping(value = "/delete")
    public Result<FdBioanalysisTemplate> delete(@RequestParam(name = "id", required = true) String id) {
        Result<FdBioanalysisTemplate> result = new Result<FdBioanalysisTemplate>();
        FdBioanalysisTemplate fdBioanalysisTemplate = fdBioanalysisTemplateService.getById(id);
        if (fdBioanalysisTemplate == null) {
            result.error500("未找到对应实体");
        } else {
            boolean ok = fdBioanalysisTemplateService.removeById(id);
            if (ok) {
                result.success("删除成功!");
            }
        }

        return result;
    }

    /**
     * 批量删除
     *
     * @param ids
     * @return
     */
    @DeleteMapping(value = "/deleteBatch")
    public Result<FdBioanalysisTemplate> deleteBatch(@RequestParam(name = "ids", required = true) String ids) {
        Result<FdBioanalysisTemplate> result = new Result<FdBioanalysisTemplate>();
        if (ids == null || "".equals(ids.trim())) {
            result.error500("参数不识别！");
        } else {
            this.fdBioanalysisTemplateService.removeByIds(Arrays.asList(ids.split(",")));
            result.success("删除成功!");
        }
        return result;
    }

    /**
     * 通过id查询
     *
     * @param id
     * @return
     */
    @GetMapping(value = "/queryById")
    public Result<FdBioanalysisTemplate> queryById(@RequestParam(name = "id", required = true) String id) {
        Result<FdBioanalysisTemplate> result = new Result<FdBioanalysisTemplate>();
        FdBioanalysisTemplate fdBioanalysisTemplate = fdBioanalysisTemplateService.getById(id);
        if (fdBioanalysisTemplate == null) {
            result.error500("未找到对应实体");
        } else {
            result.setResult(fdBioanalysisTemplate);
            result.setSuccess(true);
        }
        return result;
    }

    /**
     * 导出excel
     *
     * @param request
     * @param response
     */
    @RequestMapping(value = "/exportXls")
    public ModelAndView exportXls(HttpServletRequest request, HttpServletResponse response) {
        // Step.1 组装查询条件
        QueryWrapper<FdBioanalysisTemplate> queryWrapper = null;
        try {
            String paramsStr = request.getParameter("paramsStr");
            if (oConvertUtils.isNotEmpty(paramsStr)) {
                String deString = URLDecoder.decode(paramsStr, "UTF-8");
                FdBioanalysisTemplate fdBioanalysisTemplate = JSON.parseObject(deString, FdBioanalysisTemplate.class);
                queryWrapper = QueryGenerator.initQueryWrapper(fdBioanalysisTemplate, request.getParameterMap());
            }
        } catch (UnsupportedEncodingException e) {
            e.printStackTrace();
        }

        //Step.2 AutoPoi 导出Excel
        ModelAndView mv = new ModelAndView(new JeecgEntityExcelView());
        List<FdBioanalysisTemplate> pageList = fdBioanalysisTemplateService.list(queryWrapper);
        //导出文件名称
        mv.addObject(NormalExcelConstants.FILE_NAME, "生物分析里程碑模板列表");
        mv.addObject(NormalExcelConstants.CLASS, FdBioanalysisTemplate.class);
        mv.addObject(NormalExcelConstants.PARAMS, new ExportParams("生物分析里程碑模板列表数据", "导出人:Jeecg", "导出信息"));
        mv.addObject(NormalExcelConstants.DATA_LIST, pageList);
        return mv;
    }

    /**
     * 通过excel导入数据
     *
     * @param request
     * @param response
     * @return
     */
    @RequestMapping(value = "/importExcel", method = RequestMethod.POST)
    public Result<?> importExcel(HttpServletRequest request, HttpServletResponse response) {
        MultipartHttpServletRequest multipartRequest = (MultipartHttpServletRequest) request;
        Map<String, MultipartFile> fileMap = multipartRequest.getFileMap();
        for (Map.Entry<String, MultipartFile> entity : fileMap.entrySet()) {
            MultipartFile file = entity.getValue();// 获取上传文件对象
            ImportParams params = new ImportParams();
            params.setTitleRows(2);
            params.setHeadRows(1);
            params.setNeedSave(true);
            try {
                List<FdBioanalysisTemplate> listFdBioanalysisTemplates = ExcelImportUtil.importExcel(file.getInputStream(), FdBioanalysisTemplate.class, params);
                for (FdBioanalysisTemplate fdBioanalysisTemplateExcel : listFdBioanalysisTemplates) {
                    fdBioanalysisTemplateService.save(fdBioanalysisTemplateExcel);
                }
                return Result.ok("文件导入成功！数据行数：" + listFdBioanalysisTemplates.size());
            } catch (Exception e) {
                log.error(e.getMessage());
                return Result.error("文件导入失败！");
            } finally {
                try {
                    file.getInputStream().close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
        return Result.ok("文件导入失败！");
    }

    /***
     * @Title:模板类型集合
            * @Description:TODO
            * @param id
            * @return org.jeecg.common.api.vo.Result<java.util.List<org.jeecg.modules.projectManagement.entity.FdBioanalysisTemplate>>
            * @exception
            * @author 陈创
            * @date 2019/11/20 10:36
            * @updatehistory:
     *   2019/11/20 10:36 新增
            */
    @GetMapping(value = "getTempletaAndItems")
    public Result<List<FdBioanalysisTemplate>> getTempletaAndItems(String id) {
        Result<List<FdBioanalysisTemplate>> result = new Result<>();
        List<FdBioanalysisTemplate> fdBioanalysisTemplateList = fdBioanalysisTemplateService.getTempletas(id);
        if (fdBioanalysisTemplateList == null || fdBioanalysisTemplateList.size() < 1) {
            result.error500("未找到对应数据");
        }
        List<FdBioanalysisTemplate> fdBioanalysisTemplateListTree = fdBioanalysisTemplateService.getTempletaTree(fdBioanalysisTemplateList);
        result.setResult(fdBioanalysisTemplateListTree);
        return result;
    }

    /***
     * @Title:模板类型树形json
            * @Description:TODO
            * @param projectId
            * @return org.jeecg.common.api.vo.Result<java.util.List<org.jeecg.modules.projectManagement.entity.FdBioanalysisTemplateTree>>
            * @exception
            * @author 陈创
            * @date 2019/11/20 10:37
            * @updatehistory:
     *   2019/11/20 10:37 新增
            */
    @GetMapping(value = "/queryTreeListTemp")
    public Result<List<FdBioanalysisTemplateTree>> queryTreeListTemp(@RequestParam(name = "projectId") String projectId) {
        Result<List<FdBioanalysisTemplateTree>> result = new Result<>();
        try {
            LambdaQueryWrapper<FdBioanalysisTemplate> lambdaQueryWrapper = new LambdaQueryWrapper<>();
            lambdaQueryWrapper.eq(FdBioanalysisTemplate::getDelFlag, "0");
            lambdaQueryWrapper.eq(FdBioanalysisTemplate::getProjectId, projectId);
            lambdaQueryWrapper.orderByAsc(FdBioanalysisTemplate::getSort);
            // lambdaQueryWrapper.orderBy(true,true,FdProjectQuotationTemplateItem::getCode);
            List<FdBioanalysisTemplate> list = fdBioanalysisTemplateService.list(lambdaQueryWrapper);
            List<FdBioanalysisTemplateTree> treeLists = new ArrayList<>();
            getTreeList(treeLists, list, null);
            findLeaf(treeLists);
            result.setResult(treeLists);
        } catch (Exception e) {
            e.fillInStackTrace();
        }
        return result;
    }

    private void getTreeList(List<FdBioanalysisTemplateTree> treeList, List<FdBioanalysisTemplate> fdlist, FdBioanalysisTemplateTree temp) {
        for (FdBioanalysisTemplate fdQuotationTemplateItem : fdlist) {
            String tempPid = fdQuotationTemplateItem.getParentId();
            FdBioanalysisTemplateTree tree = new FdBioanalysisTemplateTree(fdQuotationTemplateItem);
            if (temp == null && oConvertUtils.isEmpty(tempPid)) {
                treeList.add(tree);
                if (!tree.getIsLeaf()) {
                    getTreeList(treeList, fdlist, tree);
                }
            } else if (temp != null && tempPid != null && tempPid.equals(temp.getKeyId())) {
                temp.getChildren().add(tree);
                if (!tree.getIsLeaf()) {
                    getTreeList(treeList, fdlist, tree);
                }
            }

        }
    }

    private void findLeaf(List<FdBioanalysisTemplateTree> treeList) {
        for (FdBioanalysisTemplateTree fdQuotationTemplateItemTree : treeList) {
            if (fdQuotationTemplateItemTree.getChildren().isEmpty()) {
                fdQuotationTemplateItemTree.setLeaf(true);
                fdQuotationTemplateItemTree.setChildren(null);
            } else {
                findLeaf(fdQuotationTemplateItemTree.getChildren());
            }
        }
    }
    
    /***
     * @Title:批量修改模板数据
            * @Description:TODO
            * @param fdBioanalysisTemplateList
            * @return org.jeecg.common.api.vo.Result
            * @exception 
            * @author 陈创
            * @date 2019/11/21 11:59
            * @updatehistory:
     *   2019/11/21 11:59 新增
            */
    @RequestMapping("/updateTemplateBatch")
    public Result updateTemplateBatch(@RequestBody List<FdBioanalysisTemplate> fdBioanalysisTemplateList){
        Result result=new Result();
        try {
            fdBioanalysisTemplateService.updateTemplateBatch(fdBioanalysisTemplateList);
            result.setSuccess(true);
        } catch (Exception e) {
            e.printStackTrace();
            result.error500("操作失败："+e.getMessage());
        }
        return result;
    }

}
