package com.ltkj.web.controller.system;

import java.math.BigDecimal;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Map;
import javax.annotation.Resource;
import javax.servlet.http.HttpServletResponse;

import cn.hutool.extra.pinyin.PinyinUtil;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.ltkj.framework.config.MatchUtils;
import com.ltkj.hosp.domain.*;
import com.ltkj.hosp.service.*;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import io.swagger.annotations.ApiParam;
import org.springframework.security.access.prepost.PreAuthorize;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import com.ltkj.common.annotation.Log;
import com.ltkj.common.core.controller.BaseController;
import com.ltkj.common.core.domain.AjaxResult;
import com.ltkj.common.enums.BusinessType;
import com.ltkj.common.utils.poi.ExcelUtil;
import com.ltkj.common.core.page.TableDataInfo;

/**
 * 体检单位分组Controller
 *
 * @author ltkj_赵佳豪&李格
 * @date 2023-08-07
 */
@RestController
@RequestMapping("/hosp/dwgrouping")
@Api(tags = "PC端--团体--体检单位分组接口")
public class TjDwGroupingController extends BaseController {
    @Autowired
    private ITjDwGroupingService tjDwGroupingService;

    @Autowired
    private ITjDwDeptService dwDeptService;
    @Autowired
    private ITjGroupingProService groupingProService;

    @Resource
    private ITjPackageService tjPackageService;
    @Resource
    private ITjPackageProjectService ppservice;
    @Resource
    private ITjProjectService projectService;

    @Resource
    private IDictCompService compService;

    /**
     * 查询体检单位分组列表
     */
//@PreAuthorize("@ss.hasPermi('hosp:grouping:list')")
    @GetMapping("/list")
    @ApiOperation(value = "查询单位分组信息列表")
    public TableDataInfo list(TjDwGrouping tjDwGrouping) {
        startPage();
        List<TjDwGrouping> list = tjDwGroupingService.selectTjDwGroupingList(tjDwGrouping);
        return getDataTable(list);
    }

    /**
     * 导出体检单位分组列表
     */
    @PreAuthorize("@ss.hasPermi('hosp:grouping:export')")
    @Log(title = "体检单位分组", businessType = BusinessType.EXPORT)
    @PostMapping("/export")
    public void export(HttpServletResponse response, TjDwGrouping tjDwGrouping) {
        List<TjDwGrouping> list = tjDwGroupingService.selectTjDwGroupingList(tjDwGrouping);
        ExcelUtil<TjDwGrouping> util = new ExcelUtil<TjDwGrouping>(TjDwGrouping.class);
        util.exportExcel(response, list, "体检单位分组数据");
    }

    /**
     * 获取体检单位分组详细信息
     */
    @GetMapping(value = "/{id}")
    @ApiOperation(value = "查询单位分组详细信息")
    public AjaxResult getInfo(@PathVariable("id") String id) {
        TjDwGrouping dwGrouping = tjDwGroupingService.getById(id);
        if(null !=dwGrouping){
            dwGrouping.setGroupingProList(groupingProService.list(new LambdaQueryWrapper<TjGroupingPro>().eq(TjGroupingPro::getGroupingId,id)));
        }
        return success(dwGrouping);
    }

    /**
     * 新增体检单位分组
     */
    @PostMapping
    @ApiOperation(value = "新增单位分组信息")
    public AjaxResult add(@RequestBody TjDwGrouping tjDwGrouping) {
        tjDwGrouping.setDwDeptName(compService.getById(tjDwGrouping.getDwId()).getCnName());
        if (tjDwGroupingService.saveOrUpdate(tjDwGrouping)) {
            if(null !=tjDwGrouping.getMapList() && tjDwGrouping.getMapList().size()>0){
//                groupingProService.remove(new LambdaQueryWrapper<TjGroupingPro>().eq(TjGroupingPro::getGroupingId,tjDwGrouping.getId()));
                groupingProService.deletedTjGroupingProByGroupingId(tjDwGrouping.getId());
                for (Map<String, Object> map : tjDwGrouping.getMapList()) {
                    TjGroupingPro groupingPro=new TjGroupingPro();
                    groupingPro.setGroupingId(tjDwGrouping.getId());
                    groupingPro.setProPrice(BigDecimal.valueOf(Long.parseLong(map.get("proPrice").toString())));
                    groupingPro.setProId(map.get("proId").toString());
                    groupingPro.setProName(map.get("proName").toString());
                    groupingPro.setProPyName(PinyinUtil.getFirstLetter(map.get("proName").toString(),""));
                    groupingPro.setLimits(tjDwGrouping.getLimits());
                    groupingPro.setYsPrice(BigDecimal.valueOf(Long.parseLong(map.get("proPrice").toString()))
                            .multiply(BigDecimal.valueOf(Long.parseLong(tjDwGrouping.getLimits()))
                                    .divide(BigDecimal.valueOf(10))));
                    groupingProService.save(groupingPro);
                }
            }
            return AjaxResult.success("操作成功!");
        }
        return AjaxResult.error("操作失败!");
    }

    /**
     * 删除体检单位分组
     */
    @DeleteMapping("/{ids}")
    @ApiOperation(value = "删除单位分组信息")
    public AjaxResult remove(@PathVariable String[] ids) {
        if (tjDwGroupingService.removeByIds(Arrays.asList(ids))) {
            for (String id : ids) {
                groupingProService.remove(new LambdaQueryWrapper<TjGroupingPro>().eq(TjGroupingPro::getGroupingId,id));
            }
            return AjaxResult.success("删除成功!");
        }
        return AjaxResult.error("删除失败!");
    }


    /**
     * 查询体检套餐列表
     */
    @GetMapping("getTjPackageList")
    @ApiOperation(value = "查询体检套餐列表")
    public AjaxResult getTjPackageList(@RequestParam(required = false) @ApiParam(value = "套餐名") String pacName) {

        LambdaQueryWrapper<TjPackage>wq=new LambdaQueryWrapper<>();
        wq.eq(TjPackage::getPacStatus,0);
        if(null !=pacName && !pacName.equals("")){
            wq.like(TjPackage::getPacName,pacName);
        }
        List<TjPackage> packageList = tjPackageService.list(wq);
        getTjPackageList(packageList);
        return AjaxResult.success(packageList);
    }

    private void getTjPackageList(List<TjPackage> tjPackageList) {
        if (null != tjPackageList && tjPackageList.size() > 0) {
            for (TjPackage aPackage : tjPackageList) {
                List<TjProject> tjProjectList = new ArrayList<>();
                List<TjPackageProject> pplist = ppservice.getTjPackageProjectListByPacId(String.valueOf(aPackage.getPacId()));
                StringBuilder allProName = new StringBuilder();
                String allSonName = null;
                if (null != pplist) {
                    for (TjPackageProject packageProject : pplist) {
                        TjProject tjProject = projectService.selectTjProjectByProId(packageProject.getProId());
                        if (null != tjProject) {
                            allProName.append(tjProject.getProName()).append("；");
                            String name = projectService.appendTjProjectName(String.valueOf(packageProject.getProId()));
                            allSonName = name;
                            tjProject.setAllSonProName(name);
                            tjProjectList.add(tjProject);
                        }
                    }
                }
                aPackage.setTjProjectList(tjProjectList);
                aPackage.setAllProName(allProName.toString());
                aPackage.setAllSonName(allSonName);
            }
        }
    }

    /**
     * 根据套餐id获取项目集合
     */
    @GetMapping("/getTjParentProjectListByPacId")
    @ApiOperation(value = "根据套餐id获取体检套餐项目详细信息")
    public AjaxResult getTjParentProjectListByPacId(@ApiParam(value = "体检套餐id") @RequestParam Long pacId) {
        if (pacId != null) {
            List<TjProject> tjProjectList = projectService.getTjParentProjectListByPacId(String.valueOf(pacId));
            return success(tjProjectList);
        }
        return error("套餐ID不能为空");
    }

    /**
     * 根据套餐id获取项目集合
     */
    @GetMapping("/getTjParentProjectList")
    @ApiOperation(value = "获取体检单项项目信息")
    public AjaxResult getTjParentProjectList(@RequestParam(required = false) @ApiParam(value = "单项名") String proName) {
        LambdaQueryWrapper<TjProject> wq =new LambdaQueryWrapper<>();
        wq.eq(TjProject::getProParentId,0);
        if(null !=proName && !proName.equals("")){
            wq.like(TjProject::getProName,proName);
        }
         List<TjProject> tjProjectList = projectService.list(wq);
        return success(tjProjectList);
    }
}