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 jodd.util.StringUtil;
import org.springframework.security.access.prepost.PreAuthorize;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.transaction.annotation.Transactional;
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;


    @GetMapping("/huoqutuantitaocanxiangmu")
    @ApiOperation(value = "签到登记获取团体套餐项目")
    public AjaxResult huoqutuantitaocanxiangmu(@RequestParam String dwId,@RequestParam Long sex) {
      List<TjPackage> list=  tjDwGroupingService.huoqutuantitaocanxiangmu(dwId,sex);
        if (null !=list && !list.isEmpty()){
            for (TjPackage tjPackage : list) {
                List<TjProject> res=new ArrayList<>();
                LambdaQueryWrapper<TjGroupingPro> wqq=new LambdaQueryWrapper<>();
                wqq.eq(TjGroupingPro::getGroupingId,tjPackage.getPacId());
                final List<TjGroupingPro> groupingProList = groupingProService.list(wqq);
                if (null !=groupingProList && !groupingProList.isEmpty()){
                    for (TjGroupingPro pro : groupingProList) {
                        final TjProject byId = projectService.getById(pro.getProId());
                        if(null !=byId){
                            res.add(byId);
                        }
                    }
                    tjPackage.setTjProjectList(res);
                }
            }
        }
        return AjaxResult.success(list);
    }


    /**
     * 查询体检单位分组列表
     */
//@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 = "新增单位分组信息")
    @Transactional
    public AjaxResult add(@RequestBody TjDwGrouping tjDwGrouping) {
        if((null==tjDwGrouping.getGroupingName() || "".equals(tjDwGrouping.getGroupingName()))
                || (null==tjDwGrouping.getSex() || "".equals(tjDwGrouping.getSex()))){
                return AjaxResult.error("必填项不能为空!");
        }

        String id = tjDwGrouping.getId();
        if(StringUtil.isNotBlank(id)){
            TjDwGrouping dwGrouping = tjDwGroupingService.getById(tjDwGrouping.getId());
            if(null !=dwGrouping){
                if(null !=tjDwGrouping.getMapList() && !tjDwGrouping.getMapList().isEmpty()){
                    tjDwGroupingService.deleteTjDwGroupingById(tjDwGrouping.getId());
                }
            }
        }else {
            int i = tjDwGroupingService.selectTjDwGroupingBySex(tjDwGrouping.getDwDeptId(), tjDwGrouping.getSex());
            if(i>0){
                return AjaxResult.error("该性别分组已存在不可重复创建");
            }
            int wz = tjDwGroupingService.selectTjDwGroupingBySex(tjDwGrouping.getDwDeptId(),"2");
            if(wz>0 && (tjDwGrouping.getSex().contains("0") || tjDwGrouping.getSex().contains("1"))){
                return AjaxResult.error("已存在通用分组不可创建其他分组");
            }
            int n = tjDwGroupingService.selectTjDwGroupingBySex(tjDwGrouping.getDwDeptId(),"0");
            int v = tjDwGroupingService.selectTjDwGroupingBySex(tjDwGrouping.getDwDeptId(),"1");
            if((n>0 || v>0) && tjDwGrouping.getSex().contains("2")){
                return AjaxResult.error("已存在其他分组不可创建通用分组");
            }
        }

        if(null ==tjDwGrouping.getPayType()|| tjDwGrouping.getPayType().isEmpty())return AjaxResult.error("请选择结算方式!!!");

        TjDwDept dwDept = dwDeptService.getById(tjDwGrouping.getDwDeptId());
        if(null !=dwDept){
            tjDwGrouping.setDwDeptName(dwDept.getDwDeptName());
        }
        tjDwGrouping.setDwName(compService.getById(tjDwGrouping.getDwId()).getCnName());
        if(StringUtil.isBlank(tjDwGrouping.getPacName())) tjDwGrouping.setPacName(tjDwGrouping.getGroupingName());
        if (tjDwGroupingService.saveOrUpdate(tjDwGrouping)) {
            if(null !=tjDwGrouping.getMapList() && !tjDwGrouping.getMapList().isEmpty()){
                groupingProService.deletedTjGroupingProByGroupingId(tjDwGrouping.getId());
                for (Map<String, Object> map : tjDwGrouping.getMapList()) {
                    TjGroupingPro groupingPro=new TjGroupingPro();
                    groupingPro.setGroupingId(tjDwGrouping.getId());
                    groupingPro.setProPrice(new BigDecimal(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(map.get("limits").toString());
//                    groupingPro.setYsPrice(BigDecimal.valueOf(Long.parseLong(map.get("proPrice").toString()))
//                            .multiply(BigDecimal.valueOf(Long.parseLong(tjDwGrouping.getLimits()))
//                                    .divide(BigDecimal.valueOf(10))));
                    groupingPro.setYsPrice(new BigDecimal(map.get("ysPrice").toString()));
                    groupingProService.save(groupingPro);
                }
            }
            return AjaxResult.success("操作成功!");
        }
        return AjaxResult.error("操作失败!");
    }

    @GetMapping("updateGroupProLimitsByGroupId")
    @ApiOperation(value = "根据分组id修改分组项目表折扣")
    public AjaxResult updateGroupProLimitsByGroupId(@RequestParam @ApiParam(value = "分组id") String groupId,
                                                    @RequestParam @ApiParam(value = "折扣") String limits) {
        boolean a=  groupingProService.updateGroupProLimitsByGroupId(groupId,limits);
        if(a){
            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,
                                             @RequestParam(required = false) @ApiParam(value = "拼音码") String pym) {
        LambdaQueryWrapper<TjProject> wq =new LambdaQueryWrapper<>();
        wq.eq(TjProject::getProParentId,0);
        wq.eq(TjProject::getProStatus,0);
        if(null !=proName && !proName.isEmpty()){
            wq.like(TjProject::getProName,proName);
        }
        if(null !=pym && !pym.isEmpty()){
            wq.apply("LOWER(pro_eng_name) LIKE {0}", "%" + pym.toLowerCase() + "%");
        }

        List<TjProject> tjProjectList = projectService.list(wq);
        return success(tjProjectList);
    }


    @GetMapping("/huoqutuantitaocanxiangmuList")
    @ApiOperation(value = "获取所有单位团体套餐项目")
    public AjaxResult huoqutuantitaocanxiangmuList(@RequestParam(required = false) String dwId) {
        List<TjPackage> list=  tjDwGroupingService.huoqutuantitaocanxiangmuhuoqutuantitaocanxiangmuList(dwId);
        if (null !=list && !list.isEmpty()){
            for (TjPackage tjPackage : list) {
                List<TjProject> res=new ArrayList<>();
                LambdaQueryWrapper<TjGroupingPro> wqq=new LambdaQueryWrapper<>();
                wqq.eq(TjGroupingPro::getGroupingId,tjPackage.getPacId());
                final List<TjGroupingPro> groupingProList = groupingProService.list(wqq);
                if (null !=groupingProList && !groupingProList.isEmpty()){
                    for (TjGroupingPro pro : groupingProList) {
                        final TjProject byId = projectService.getById(pro.getProId());
                        if(null !=byId){
                            res.add(byId);
                        }
                    }
                    tjPackage.setTjProjectList(res);
                }
            }
        }
        return AjaxResult.success(list);
    }
}