package com.skua.modules.data.controller;

import java.io.IOException;
import java.io.UnsupportedEncodingException;
import java.net.URLDecoder;
import java.util.Arrays;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

import javax.annotation.Resource;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import org.apache.shiro.SecurityUtils;
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.jdbc.core.JdbcTemplate;
import org.springframework.web.bind.annotation.DeleteMapping;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.PutMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.multipart.MultipartFile;
import org.springframework.web.multipart.MultipartHttpServletRequest;
import org.springframework.web.servlet.ModelAndView;

import com.alibaba.fastjson.JSON;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.skua.core.api.ISysBaseAPI;
import com.skua.core.api.vo.LoginUser;
import com.skua.core.api.vo.Result;
import com.skua.core.aspect.annotation.AutoLog;
import com.skua.core.context.BaseContextHandler;
import com.skua.core.context.SpringContextUtils;
import com.skua.core.query.QueryGenerator;
import com.skua.core.util.ConvertUtils;
import com.skua.core.util.UUIDGenerator;
import com.skua.modules.data.entity.FDataItem;
import com.skua.modules.data.service.IFDataItemService;
import com.skua.modules.report.entity.FReportItem;
import com.skua.modules.report.service.IFReportItemService;

import cn.hutool.core.util.PinyinUtil;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import lombok.extern.slf4j.Slf4j;

 /**
 * 数据项
 */
@Slf4j
@Api(tags="数据项管理")
@RestController
@RequestMapping("/dataitem/fDataItem")
public class FDataItemController {
	@Autowired
	private IFDataItemService fDataItemService;
	@Autowired
	private ISysBaseAPI iSysBaseAPI;
	@Resource
    private IFReportItemService fReportItemService;
	 /**
	  * 列表查询无分页
	  * @param fDataItem
	  * @param req
	  * @return
	  */
	 @AutoLog(value = "数据项无分页列表")
	 @ApiOperation(value="数据项无分页列表", notes="数据项无分页列表")
	 @GetMapping(value = "/listNoPage")
	 public Result<List<FDataItem>> queryNoPageList(FDataItem fDataItem, HttpServletRequest req) {
		 Result<List<FDataItem>> result = new Result<List<FDataItem>>();
		 // 查询集团数据项
		 String userId = BaseContextHandler.getUserId(); // 查询用户ID
		 String orgCode = iSysBaseAPI.getOrgCodeById(userId);// 查询当前用户所在集团
		 fDataItem.setCreateDept(orgCode);
		 QueryWrapper<FDataItem> queryWrapper = QueryGenerator.initQueryWrapper(fDataItem, req.getParameterMap());
		 List<FDataItem> pageList = fDataItemService.list(queryWrapper);
		 result.setSuccess(true);
		 result.setResult(pageList);
		 return result;
	 }

	 @AutoLog(value = "数据项列表-按分类")
	 @ApiOperation(value="数据项列表-按分类", notes="数据项列表-按分类")
	 @GetMapping(value = "/listByType")
	 public Result<List<FDataItem>> listByType(@RequestParam(name="typeId",required=true) String typeId,HttpServletRequest req) {
		 Result<List<FDataItem>> result = new Result<List<FDataItem>>();
		 FDataItem fDataItem = new FDataItem();
		 fDataItem.setDataType(typeId);
		 // 查询集团数据项
		 String userId = BaseContextHandler.getUserId(); // 查询用户ID
		 String orgCode = iSysBaseAPI.getOrgCodeById(userId);// 查询当前用户所在集团
		 fDataItem.setCreateDept(orgCode);
		 QueryWrapper<FDataItem> queryWrapper = QueryGenerator.initQueryWrapper(fDataItem, req.getParameterMap());
		 List<FDataItem> pageList = fDataItemService.list(queryWrapper);
		 result.setSuccess(true);
		 result.setResult(pageList);
		 return result;
	 }

	/**
	  * 分页列表查询
	 * @param fDataItem
	 * @param pageNo
	 * @param pageSize
	 * @param req
	 * @return
	 */
	@AutoLog(value = "数据项-分页列表查询")
	@ApiOperation(value="数据项-分页列表查询", notes="数据项-分页列表查询")
	@GetMapping(value = "/list")
	public Result<IPage<FDataItem>> queryPageList(FDataItem fDataItem,
									  @RequestParam(name="pageNo", defaultValue="1") Integer pageNo,
									  @RequestParam(name="pageSize", defaultValue="10") Integer pageSize,
									  HttpServletRequest req) {
		Result<IPage<FDataItem>> result = new Result<IPage<FDataItem>>();
		// 查询集团数据项
		String userId = BaseContextHandler.getUserId(); // 查询用户ID
		String orgCode = iSysBaseAPI.getOrgCodeById(userId);// 查询当前用户所在集团
		fDataItem.setCreateDept(orgCode);
		QueryWrapper<FDataItem> queryWrapper = QueryGenerator.initQueryWrapper(fDataItem, req.getParameterMap());
		Page<FDataItem> page = new Page<FDataItem>(pageNo, pageSize);
		IPage<FDataItem> pageList = fDataItemService.page(page, queryWrapper);
		result.setSuccess(true);
		result.setResult(pageList);
		return result;
	}

	/**
	  *   添加
	 * @param fDataItem
	 * @return
	 */
	@AutoLog(value = "数据项-添加")
	@ApiOperation(value="数据项-添加", notes="数据项-添加")
	@PostMapping(value = "/add")
	public Result<FDataItem> add(@RequestBody FDataItem fDataItem) {
		Result<FDataItem> result = new Result<FDataItem>();
		// 查询集团数据项
		String userId = BaseContextHandler.getUserId(); // 查询用户ID
		String orgCode = iSysBaseAPI.getOrgCodeById(userId);// 查询当前用户所在集团
		String dataCode = PinyinUtil.getAllFirstLetter(fDataItem.getDataName());

		fDataItem.setDataCode(dataCode + UUIDGenerator.creatUUID().substring(0,4));
		fDataItem.setCreateDept(orgCode);
		fDataItem.setDepartId(iSysBaseAPI.getDeptIdByCode(orgCode));
		try {
			fDataItemService.save(fDataItem);
			result.success("添加成功！");
		} catch (Exception e) {
			log.error(e.getMessage(),e);
			result.error500("操作失败");
		}
		return result;
	}

	/**
	  *  编辑
	 * @param fDataItem
	 * @return
	 */
	@AutoLog(value = "数据项-编辑")
	@ApiOperation(value="数据项-编辑", notes="数据项-编辑")
	@PutMapping(value = "/edit")
	public Result<FDataItem> edit(@RequestBody FDataItem fDataItem) {
		synchronized (fDataItem) {
			Result<FDataItem> result = new Result<FDataItem>();
			FDataItem fDataItemEntity = fDataItemService.getById(fDataItem.getId());
			if(fDataItemEntity==null) {
				result.error500("未找到对应实体");
			}else {
				boolean ok = fDataItemService.updateById(fDataItem);
				if(ok) {
					result.success("修改成功!");
				}
			}
			return result;
		}
	}

	/**
	  *   通过id删除
	 * @param id
	 * @return
	 */
	@AutoLog(value = "数据项-通过id删除")
	@ApiOperation(value="数据项-通过id删除", notes="数据项-通过id删除")
	@DeleteMapping(value = "/delete")
	public Result<?> delete(@RequestParam(name="id",required=true) String id) {
		try {
			int rowCount = checkAlgorithmCode(id);
			if(rowCount>0) {
				return Result.ok("该指标被应用到算法指标库，禁止删除！");
			}else {
				fDataItemService.removeById(id);
				//级联删除报表配置指标副本
				QueryWrapper<FReportItem> queryWrapper = new QueryWrapper<FReportItem>();
				queryWrapper.eq("item_id", id);
				fReportItemService.remove(queryWrapper);
				return Result.ok("删除成功!");
			}
		} catch (Exception e) {
			log.error("删除失败",e.getMessage());
			return Result.error("删除失败!");
		}
	}
	
	public int checkAlgorithmCode(String ids) {
		JdbcTemplate masterDB = (JdbcTemplate)SpringContextUtils.getBean("master");
		String[] idArray = ids.split(",");
		String idSqlPart = Arrays.stream(idArray).map(id -> "'" + id + "'").collect(Collectors.joining(","));
		//判定删除指标是否在标准算法库计算指标库中应用，如果被应用则不允许删除
		Map<String, Object> checkMap = masterDB.queryForMap("SELECT\r\n" + 
				"	count(*) AS num\r\n" + 
				"FROM\r\n" + 
				"	sys_algorithm_library_detail\r\n" + 
				"WHERE\r\n" + 
				"	field_type = '2'\r\n" + 
				"AND library_id IN (\r\n" + 
				"	SELECT\r\n" + 
				"		id\r\n" + 
				"	FROM\r\n" + 
				"		sys_algorithm_library\r\n" + 
				")\r\n" + 
				"AND index_code in ("+idSqlPart+") ");
		return ConvertUtils.getInt(checkMap.get("num"));
	}

	/**
	  *  批量删除
	 * @param ids
	 * @return
	 */
	@AutoLog(value = "数据项-批量删除")
	@ApiOperation(value="数据项-批量删除", notes="数据项-批量删除")
	@DeleteMapping(value = "/deleteBatch")
	public Result<FDataItem> deleteBatch(@RequestParam(name="ids",required=true) String ids) {
		Result<FDataItem> result = new Result<FDataItem>();
		if(ids==null || "".equals(ids.trim())) {
			result.error500("参数不识别！");
		}else {
			int rowCount = checkAlgorithmCode(ids);
			if(rowCount>0) {
				return result.error500("该指标被应用到算法指标库，禁止删除！");
			}else {
				this.fDataItemService.removeByIds(Arrays.asList(ids.split(",")));
				return result.success("删除成功!");
			}
			
		}
		return result;
	}

	/**
	  * 通过id查询
	 * @param id
	 * @return
	 */
	@AutoLog(value = "数据项-通过id查询")
	@ApiOperation(value="数据项-通过id查询", notes="数据项-通过id查询")
	@GetMapping(value = "/queryById")
	public Result<FDataItem> queryById(@RequestParam(name="id",required=true) String id) {
		Result<FDataItem> result = new Result<FDataItem>();
		FDataItem fDataItem = fDataItemService.getById(id);
		if(fDataItem==null) {
			result.error500("未找到对应实体");
		}else {
			result.setResult(fDataItem);
			result.setSuccess(true);
		}
		return result;
	}

  /**
      * 导出excel
   *
   * @param request
   * @param response
   */
  @RequestMapping(value = "/exportXls")
  public ModelAndView exportXls(HttpServletRequest request, HttpServletResponse response) {
	  //获取当前用户
	  LoginUser sysUser = (LoginUser) SecurityUtils.getSubject().getPrincipal();
      // Step.1 组装查询条件
      QueryWrapper<FDataItem> queryWrapper = null;
      try {
          String paramsStr = request.getParameter("paramsStr");
          if (ConvertUtils.isNotEmpty(paramsStr)) {
              String deString = URLDecoder.decode(paramsStr, "UTF-8");
              FDataItem fDataItem = JSON.parseObject(deString, FDataItem.class);
              queryWrapper = QueryGenerator.initQueryWrapper(fDataItem, request.getParameterMap());
          }
      } catch (UnsupportedEncodingException e) {
          e.printStackTrace();
      }

      //Step.2 AutoPoi 导出Excel
      ModelAndView mv = new ModelAndView(new JeecgEntityExcelView());
      List<FDataItem> pageList = fDataItemService.list(queryWrapper);
      //导出文件名称
      mv.addObject(NormalExcelConstants.FILE_NAME, "数据项列表");
      mv.addObject(NormalExcelConstants.CLASS, FDataItem.class);
      mv.addObject(NormalExcelConstants.PARAMS, new ExportParams("数据项列表数据", "导出人:"+sysUser.getRealname(), "导出信息"));
      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<FDataItem> listFDataItems = ExcelImportUtil.importExcel(file.getInputStream(), FDataItem.class, params);
              fDataItemService.saveBatch(listFDataItems);
              return Result.ok("文件导入成功！数据行数:" + listFDataItems.size());
          } catch (Exception e) {
              log.error(e.getMessage(),e);
              return Result.error("文件导入失败:"+e.getMessage());
          } finally {
              try {
                  file.getInputStream().close();
              } catch (IOException e) {
                  e.printStackTrace();
              }
          }
      }
      return Result.ok("文件导入失败！");
  }

}