package com.ltkj.web.controller.mall;


import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.ltkj.common.core.domain.AjaxResult;
import com.ltkj.common.core.page.TableDataInfo;
import com.ltkj.framework.config.UserHoder;
import com.ltkj.hosp.domain.*;
import com.ltkj.hosp.service.*;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.web.bind.annotation.*;

import javax.annotation.Resource;
import java.util.List;
import java.util.stream.Collectors;

/**
 * @Company: 西安路泰科技有限公司
 * @Author: zjh
 * @Date: 2023/7/26 08:53
 */


@RestController
@RequestMapping("/cus/history")
@Api(tags = "体检小程序端问诊记录接口")
public class WxTjAskMedicalHistoryController {

    @Resource
    private ITjAskMedicalHistoryService tjAskMedicalHistoryService;
    @Resource
    private ITjAskHistorysService historysService;
    @Resource
    private ITjCustomerService customerService;
    @Resource
    private ITjCustomerService tjCustomerService;

    @Autowired
    private ITjHarmTypeService tjHarmTypeService;

    @Autowired
    private ITjAskWorkLogService tjAskWorkLogService;
    @Autowired
    private ITjHarmTypeLogService tjHarmTypeLogService;

    @Resource
    private ITjOrderService tjOrderService;


    /**
     * 小程序根据客户身份证号获取问诊详细信息
     */
    @GetMapping(value = "/appGetInfoById")
    @ApiOperation(value = "小程序根据客户身份证号获取问诊详细信息")
    public AjaxResult appGetInfoById(@RequestParam("cusIdCard") String cusIdCard) {
        LambdaQueryWrapper<TjCustomer> wqqq = new LambdaQueryWrapper<>();
        wqqq.eq(TjCustomer::getCusIdcard, cusIdCard);
        TjCustomer customer = tjCustomerService.getOne(wqqq);
        if (customer != null) {
            LambdaQueryWrapper<TjOrder> wq = new LambdaQueryWrapper<>();
            wq.eq(TjOrder::getUserId, customer.getCusId());
            wq.orderByDesc(TjOrder::getCreateTime);
            wq.last("limit 1");
            TjOrder order = tjOrderService.getOne(wq);

            if (order != null) {
                LambdaQueryWrapper<TjAskMedicalHistory> wq1 = new LambdaQueryWrapper<>();
                wq1.eq(TjAskMedicalHistory::getTjNum, order.getTjNumber());
                TjAskMedicalHistory one = tjAskMedicalHistoryService.getOne(wq1);
                if (one != null) {
                    one.setTjCategory(order.getTjCategory());
                    //查询病史记录和职业记录
                    LambdaQueryWrapper<TjAskWorkLog> wqq = new LambdaQueryWrapper<>();
                    wqq.eq(TjAskWorkLog::getTjNumber, order.getTjNumber());
                    final List<TjAskWorkLog> list = tjAskWorkLogService.list(wqq);
                    one.setWorkLogs(list);

                    for (TjAskWorkLog askWorkLog : list) {
                        LambdaQueryWrapper<TjHarmTypeLog> wqq1 = new LambdaQueryWrapper<>();
                        wqq1.eq(TjHarmTypeLog::getWorkId, askWorkLog.getId());
                        final List<TjHarmTypeLog> list1 = tjHarmTypeLogService.list(wqq1);

                        List<String> skuNos = list1.stream()
                                .map(TjHarmTypeLog::getAid)
                                .collect(Collectors.toList());

                        askWorkLog.setHarmTypeLogs(skuNos);
                    }
                    LambdaQueryWrapper<TjAskHistorys> wqq111 = new LambdaQueryWrapper<>();
                    wqq111.eq(TjAskHistorys::getAskId, one.getAskId());
                    final List<TjAskHistorys> list11 = historysService.list(wqq111);
                    one.setTjAskHistorysList(list11);

                    return AjaxResult.success(one);
                } else {
                    TjAskMedicalHistory a = new TjAskMedicalHistory();
                    a.setTjCategory(order.getTjCategory());
                    a.setCusId(customer.getCusId());
                    a.setTjNum(order.getTjNumber());
                    TjCustomer byId = customerService.getById(a.getCusId());
                    if (byId != null) {
                        a.setCusName(byId.getCusName());
                    }
                    return AjaxResult.success(a);
                }
            }
        }
        return AjaxResult.success("0");

    }

    /**
     * 小程序新增修改问诊
     */
    @ApiOperation(value = "小程序端新增问诊记录信息接口")
    @PostMapping("/appEdit")
    @Transactional
    public AjaxResult appEdit(@RequestBody TjAskMedicalHistory tjAskMedicalHistory) {
        LambdaQueryWrapper<TjAskMedicalHistory> wq = new LambdaQueryWrapper<>();
        wq.eq(TjAskMedicalHistory::getTjNum, tjAskMedicalHistory.getTjNum());
        final TjAskMedicalHistory one = tjAskMedicalHistoryService.getOne(wq);
        if (one==null){
            tjAskMedicalHistory.setFromBy("小程序端");
            tjAskMedicalHistory.setCreateId(String.valueOf(UserHoder.getWxuser().getId()));
            if (tjAskMedicalHistoryService.save(tjAskMedicalHistory)) {
                List<TjAskHistorys> tjAskHistorysList = tjAskMedicalHistory.getTjAskHistorysList();
                if (tjAskHistorysList != null && tjAskHistorysList.size() > 0) {
                    //添加病史
                    for (TjAskHistorys tjAskHistorys : tjAskMedicalHistory.getTjAskHistorysList()) {
                        tjAskHistorys.setAskId(tjAskMedicalHistory.getAskId());
                        if (!historysService.save(tjAskHistorys)) {
                            return AjaxResult.error("添加失败");
                        }
                    }
                    //添加职业病史
                    final List<TjAskWorkLog> workLogs = tjAskMedicalHistory.getWorkLogs();
                    if (workLogs != null) {
                        for (TjAskWorkLog workLog : workLogs) {
                            workLog.setAskId(tjAskMedicalHistory.getAskId());
                            workLog.setCusId(tjAskMedicalHistory.getCusId());
                            workLog.setCusName(tjAskMedicalHistory.getCusName());
                            workLog.setTjNumber(tjAskMedicalHistory.getTjNum());
                            final boolean save = tjAskWorkLogService.save(workLog);
                            if (!save) {
                                return AjaxResult.error();
                            }
                            List<String> harmTypeLogs = workLog.getHarmTypeLogs();
                            if (harmTypeLogs != null) {
                                for (String harmTypeLog : harmTypeLogs) {
                                    final TjHarmType byId = tjHarmTypeService.getById(harmTypeLog);
                                    if (byId != null) {
                                        TjHarmTypeLog log = new TjHarmTypeLog();
                                        log.setAid(byId.getAid());
                                        log.setCusId(tjAskMedicalHistory.getCusId());
                                        log.setCusName(tjAskMedicalHistory.getCusName());
                                        log.setTjNumber(tjAskMedicalHistory.getTjNum());
                                        log.setWorkId(workLog.getId());
                                        final boolean b = tjHarmTypeLogService.save(log);
                                        if (!b) {
                                            return AjaxResult.error("添加失败");
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
                return AjaxResult.success("添加成功!");
            }
        }else {
            //新增修改没问题  这块牵扯删除 没有更好的办法  所以采取先删后加
            //删除原来的职业和病史
            LambdaQueryWrapper<TjAskWorkLog> wq1 = new LambdaQueryWrapper<>();
            wq1.eq(TjAskWorkLog::getTjNumber, tjAskMedicalHistory.getTjNum());
            tjAskWorkLogService.remove(wq1);
            //删除原来的病史
            LambdaQueryWrapper<TjAskHistorys> wq2 = new LambdaQueryWrapper<>();
            wq2.eq(TjAskHistorys::getAskId, one.getAskId());
            historysService.remove(wq2);
            //删除原来的病史
            LambdaQueryWrapper<TjHarmTypeLog> wq3 = new LambdaQueryWrapper<>();
            wq3.eq(TjHarmTypeLog::getTjNumber, tjAskMedicalHistory.getTjNum());
            tjHarmTypeLogService.remove(wq3);


            tjAskMedicalHistory.setFromBy("小程序端");
            tjAskMedicalHistory.setUpdateId(String.valueOf(UserHoder.getWxuser().getId()));
            if (tjAskMedicalHistoryService.updateById(tjAskMedicalHistory)) {
                List<TjAskHistorys> tjAskHistorysList = tjAskMedicalHistory.getTjAskHistorysList();
                if (tjAskHistorysList != null && tjAskHistorysList.size() > 0) {
                    //修改病史
                    for (TjAskHistorys tjAskHistorys : tjAskMedicalHistory.getTjAskHistorysList()) {
                        tjAskHistorys.setAskId(tjAskMedicalHistory.getAskId());
                        if (!historysService.save(tjAskHistorys)) {
                            return AjaxResult.error("添加失败");
                        }
//                        if (tjAskHistorys.getDiseaseId()==null){
//                            if (!historysService.save(tjAskHistorys)) {
//                                return AjaxResult.error("添加失败");
//                            }
//                        }else {
//                            if (!historysService.updateById(tjAskHistorys)) {
//                                return AjaxResult.error("修改失败");
//                            }
//                        }

                    }
                    //修改职业病史
                    final List<TjAskWorkLog> workLogs = tjAskMedicalHistory.getWorkLogs();
                    if (workLogs != null) {
                        for (TjAskWorkLog workLog : workLogs) {
                            workLog.setAskId(tjAskMedicalHistory.getAskId());
                            workLog.setCusId(tjAskMedicalHistory.getCusId());
                            workLog.setCusName(tjAskMedicalHistory.getCusName());
                            workLog.setTjNumber(tjAskMedicalHistory.getTjNum());
                            final boolean save = tjAskWorkLogService.save(workLog);
                            if (!save) {
                                return AjaxResult.error("添加失败");
                            }
//                            if (workLog.getId()==null){
//                                final boolean save = tjAskWorkLogService.save(workLog);
//                                if (!save) {
//                                    return AjaxResult.error("添加失败");
//                                }
//                            }else {
//                                final boolean save = tjAskWorkLogService.updateById(workLog);
//                                if (!save) {
//                                    return AjaxResult.error("修改失败");
//                                }
//                            }
                            List<String> harmTypeLogs = workLog.getHarmTypeLogs();
                            if (harmTypeLogs != null) {
                                for (String harmTypeLog : harmTypeLogs) {
                                    final TjHarmType byId = tjHarmTypeService.getById(harmTypeLog);
                                    if (byId != null) {
                                        TjHarmTypeLog log = new TjHarmTypeLog();
                                        log.setAid(byId.getAid());
                                        log.setCusId(tjAskMedicalHistory.getCusId());
                                        log.setCusName(tjAskMedicalHistory.getCusName());
                                        log.setTjNumber(tjAskMedicalHistory.getTjNum());
                                        log.setWorkId(workLog.getId());
                                        final boolean b = tjHarmTypeLogService.save(log);
                                        if (!b) {
                                            return AjaxResult.error("添加失败");
                                        }
//                                        if (log.getId()==null){
//                                            final boolean b = tjHarmTypeLogService.save(log);
//                                            if (!b) {
//                                                return AjaxResult.error("添加失败");
//                                            }
//                                        }else {
//                                            final boolean b = tjHarmTypeLogService.updateById(log);
//                                            if (!b) {
//                                                return AjaxResult.error("修改失败");
//                                            }
//                                        }

                                    }
                                }
                            }
                        }
                    }
                }
                return AjaxResult.success("修改成功!");
            }
        }
        return AjaxResult.error("操作失败!");
    }

    /**
     * 查询职业病列表
     */
    @GetMapping("/getHarmTypeList")
    public AjaxResult getHarmTypeList(TjHarmType tjHarmType) {
        LambdaQueryWrapper<TjHarmType> wq = new LambdaQueryWrapper<>();
        if (tjHarmType.getHarmCode() != null) {
            wq.like(TjHarmType::getHarmCode, tjHarmType.getHarmCode());
        }
        if (tjHarmType.getHarmType() != null) {
            wq.like(TjHarmType::getHarmType, tjHarmType.getHarmType());
        }
        if (tjHarmType.getHarmPinYin() != null) {
            wq.like(TjHarmType::getHarmPinYin, tjHarmType.getHarmPinYin());
        }
        List<TjHarmType> list = tjHarmTypeService.list(wq);
        return AjaxResult.success(list);
    }


}