package com.ltkj.web.controller.system;

import javax.annotation.Resource;
import javax.servlet.http.HttpServletResponse;
import cn.hutool.core.date.DateUtil;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.ltkj.common.enums.DataSourceType;
import com.ltkj.framework.config.MatchUtils;
import com.ltkj.framework.datasource.DynamicDataSourceContextHolder;
import com.ltkj.hosp.domain.TjReservation;
import com.ltkj.hosp.mapper.TestMapper;
import com.ltkj.hosp.service.*;
import com.ltkj.hosp.sqlDomain.LtkjMiddleDetail;
import com.ltkj.hosp.sqlDomain.LtkjMiddleHead;
import com.ltkj.hosp.sqlDomain.LtkjTjPat;
import com.ltkj.system.service.ISysConfigService;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import io.swagger.annotations.ApiParam;
import org.springframework.util.DigestUtils;
import org.springframework.web.bind.annotation.*;
import com.ltkj.common.core.controller.BaseController;
import com.ltkj.common.core.domain.AjaxResult;
import com.ltkj.hosp.domain.TjCustomer;
import com.ltkj.common.utils.poi.ExcelUtil;
import com.ltkj.common.core.page.TableDataInfo;

import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;


/**
 * 客户信息Controller
 *
 * @author ltkj
 * @date 2022-11-17
 */
@RestController
@RequestMapping("/hosp/customer")
@Api(tags = "客户管理接口")
public class TjCustomerController extends BaseController {
    @Resource
    private ITjCustomerService tjCustomerService;

    @Resource
    private ITjReservationService tjReservationService;

    @Resource
    private ISysConfigService sysConfigService;

    @Resource
    private TestMapper testMapper;
    @Resource
    private TjvLtkjvtjpatService tjvLtkjvtjpatService;
    @Resource
    private LtkjMiddleHeadService headService;
    @Resource
    private LtkjMiddleDetailService middleDetailService;
    @Resource
    private ITjOrderService tjOrderService;

    @GetMapping("/newGetTjPat")
    @ApiOperation(value = "查询his数据库返回新的数据")
    public AjaxResult newGetTjPat(@RequestParam(required = false)String pacCode,
                                  @RequestParam(required = false)String pacName,
                                  @RequestParam(required = false)String pacRemark) {
        List<Map<String, Object>> maps = testMapper.newGetTjPat(pacCode,pacName,pacRemark);
        DynamicDataSourceContextHolder.clearDataSourceType();
//        List<Map<String, Object>> list=new ArrayList<>();
//        if(null !=maps && maps.size()>0){
//            for (Map<String, Object> map : maps) {
//                String pacCode1 = map.get("pacCode").toString();
//                List<String> s = tjOrderService.selectTjOrderByCardId1();
//                if(null !=s && s.size()>0){
//                    if(s.contains(pacCode1)){
////                        maps.remove(map);
//                        continue;
//                    }
//                    list.add(map);
//                }
//            }
//        }
        List<String> strings = tjOrderService.selectTjOrderByCardId1();
        if(null !=strings && strings.size()>0){
            List<Map<String, Object>> collect = maps.stream()
                    .filter(item ->  !strings.contains(item.get("pacCode").toString())).collect(Collectors.toList());
            return AjaxResult.success(collect);
        }
        return AjaxResult.success(maps);
//        return AjaxResult.success(maps);
    }



    /**
     * 根据身份证号获取用户信息
     */
    @PostMapping(value = "/cusIdcard")
    @ApiOperation(value = "根据身份证号获取用户信息")
//    @Log(title = "客户身份信息", businessType = BusinessType.EXPORT)
    public AjaxResult getInfoByIdCard(@RequestParam @ApiParam(value = "客户身份证号") String cusIdcard) {
        if (!"".equals(cusIdcard) && cusIdcard != null) {
            //判断身份证号格式是否正确
//            if(cusIdcard.length()==18){
//                if (! MatchUtils.isIdCard(cusIdcard)) {
//                    return AjaxResult.error("身份证号码错误");
//                }
//            }
//            if(cusIdcard.length()==9){
//                if (!MatchUtils.cardValidates(cusIdcard)) {
//                    return AjaxResult.error("身份证号码错误");
//                }
//            }
            //根据配置调取存储过程 将临时表数据存入预约表2023.12.12
            final String getInfoFromSqlData = sysConfigService.selectConfigByKey("getInfoFromSqlData");
            if ("Y".equals(getInfoFromSqlData)){
                //根据身份证号从his查信息
                LtkjTjPat tjPatByIdCard = testMapper.getTjPatByIdCard(cusIdcard);
                if(null != tjPatByIdCard){
                    String fcardNo = tjPatByIdCard.getFcardNo();
                    if(null !=fcardNo && !fcardNo.equals("")){
                        fcardNo=fcardNo.trim();
                        tjPatByIdCard.setFcardNo(fcardNo);
                    }else {
                        fcardNo=cusIdcard.trim();
                        tjPatByIdCard.setFcardNo(fcardNo);
                    }
                    //根据身份证号从数据库拿信息 没有的话保存
                    LtkjTjPat ltkjTjPat = tjvLtkjvtjpatService.getLtkjTjPatByCusIdCard(cusIdcard);
                    if(null==ltkjTjPat){
                        tjvLtkjvtjpatService.save(tjPatByIdCard);
                    }
                    DynamicDataSourceContextHolder.clearDataSourceType();
                    //再根据身份证号写customer表
                    TjCustomer tjCustomer = tjCustomerService.getTjCustomerByCusIdCard(tjPatByIdCard.getFcardNo());
                    if(null == tjCustomer){
                        //为空的话掉存储过程保存到客户表
                        testMapper.getTjPatByCusId(cusIdcard);
                        LambdaQueryWrapper<TjCustomer> qw = new LambdaQueryWrapper<>();
                        qw.eq(TjCustomer::getCusIdcard, tjPatByIdCard.getFcardNo());
                        TjCustomer customer = tjCustomerService.getOne(qw);
                        customer.setReservationId(customer.getCardId());
                        extracted(customer);
                        return success(customer);
                    }else {
                        String cardId = tjPatByIdCard.getFcardId();
                        if(null !=cardId && !cardId.equals("0")){
                            int i = tjOrderService.selectTjOrderByCardId(cardId);
                            if(i>0){
                                return AjaxResult.error("不可重复签到");
                            }

                        }
                        tjCustomer.setReservationId(tjCustomer.getCardId());
                        tjCustomer.setCardId(tjPatByIdCard.getFcardId());
                        tjCustomerService.updateById(tjCustomer);
                        extracted(tjCustomer);
                        return success(tjCustomer);
                    }

                }
            }
            //end====2023.12.12
            LambdaQueryWrapper<TjReservation> wq = new LambdaQueryWrapper<>();
            wq.eq(TjReservation::getIdCard, cusIdcard);
            wq.eq(TjReservation::getIsExpire, 2);
            TjReservation tjReservation = tjReservationService.getOne(wq);
            if (tjReservation != null) {
                if (DateUtil.endOfDay(new Date()).before(tjReservation.getReservationTime())) {
                    return AjaxResult.error("未到预约时间");
                }
                if (null != tjReservation.getReservationTime() && DateUtil.endOfDay(tjReservation.getReservationTime()).before(new Date())) {
                    tjReservation.setIsExpire(1);
                    tjReservationService.updateById(tjReservation);
                    return AjaxResult.error("对不起您的预约已超时请重新预约");
                }
                LambdaQueryWrapper<TjCustomer> qw = new LambdaQueryWrapper<>();
                qw.eq(TjCustomer::getCusIdcard, cusIdcard);
                TjCustomer tjCustomer1 = tjCustomerService.getOne(qw);
                if (tjCustomer1 != null) {
                    tjCustomer1.setTjType(tjReservation.getTjType());
                    tjCustomer1.setCusName(tjReservation.getName());
                    tjCustomer1.setCusSex(Long.valueOf(tjReservation.getSex()));
                    tjCustomer1.setCusBrithday(tjReservation.getBirthday());
                    tjCustomer1.setCusPhone(tjReservation.getPhoe());
                    tjCustomer1.setCusEmail(tjReservation.getEmail());
                    tjCustomer1.setCusAddr(tjReservation.getAddress());
                    tjCustomer1.setCusMarryStatus(String.valueOf(tjReservation.getMarriage()));
                    tjCustomer1.setCusNational(String.valueOf(tjReservation.getNation()));

                    tjCustomer1.setIdType(tjReservation.getIdType());
                    tjCustomer1.setAge(tjReservation.getAge());
                    tjCustomer1.setAgeUnit(tjReservation.getAgeUnit());
                    tjCustomer1.setCareer(tjReservation.getCareer());

                    tjCustomerService.updateById(tjCustomer1);
                    tjCustomer1.setTeamNo(tjReservation.getTeamNo());
                    tjCustomer1.setCompId(tjReservation.getCompanyId());
                    tjCustomer1.setReservationId(tjReservation.getId());
                    tjCustomer1.setDiscount(tjReservation.getDiscount());
                    tjCustomer1.setGroupingId(tjReservation.getGroupingId());
                    return success(tjCustomer1);
                }
                TjCustomer tjCustomer = new TjCustomer();
                tjCustomer.setCusIdcard(tjReservation.getIdCard());
                tjCustomer.setCusName(tjReservation.getName());
                tjCustomer.setCusSex(Long.valueOf(tjReservation.getSex()));
                tjCustomer.setCusBrithday(tjReservation.getBirthday());
                tjCustomer.setCusPhone(tjReservation.getPhoe());
                tjCustomer.setCusEmail(tjReservation.getEmail());
                tjCustomer.setCusAddr(tjReservation.getAddress());
                tjCustomer.setCusMarryStatus(String.valueOf(tjReservation.getMarriage()));
                tjCustomer.setCusNational(String.valueOf(tjReservation.getNation()));

                tjCustomer.setIdType(tjReservation.getIdType());
                tjCustomer.setAge(tjReservation.getAge());
                tjCustomer.setAgeUnit(tjReservation.getAgeUnit());
                tjCustomer.setCareer(tjReservation.getCareer());
                tjCustomer.setDwPhone(tjReservation.getDwPhone());
                tjCustomer.setCardId(tjReservation.getCardId());
                tjCustomer.setIndexCard(tjReservation.getIndexCard());

                //截取密码自动生成set进去
                String substring = cusIdcard.substring(cusIdcard.length() - 6);
                substring = DigestUtils.md5DigestAsHex(substring.getBytes());
                tjCustomer.setCusPassword(substring);
                tjCustomer.setTjType(tjReservation.getTjType());
                tjCustomerService.save(tjCustomer);
                tjCustomer.setTeamNo(tjReservation.getTeamNo());
                tjCustomer.setCompId(tjReservation.getCompanyId());
                tjCustomer.setReservationId(tjReservation.getId());
                tjCustomer.setDiscount(tjReservation.getDiscount());
                tjCustomer.setGroupingId(tjReservation.getGroupingId());
                return success(tjCustomer);
            }
            LambdaQueryWrapper<TjCustomer> qw = new LambdaQueryWrapper<>();
            qw.eq(TjCustomer::getCusIdcard, cusIdcard);
            TjCustomer tjCustomer = tjCustomerService.getOne(qw);
            return AjaxResult.success("暂无预约信息",tjCustomer);
        }
        return error("身份证号不存在");
    }

    private void extracted(TjCustomer customer) {
        //从his表抓数据
        LtkjMiddleHead pat = testMapper.getMiddleHeadByPartId(customer.getCardId());
        if (null != pat) {
            LambdaQueryWrapper<LtkjMiddleHead> wq1=new LambdaQueryWrapper<>();
            wq1.eq(LtkjMiddleHead::getFeadId,customer.getCardId());
            headService.remove(wq1);
            LambdaQueryWrapper<LtkjMiddleDetail> wq0=new LambdaQueryWrapper<>();
            wq0.eq(LtkjMiddleDetail::getFheadId,pat.getFeadId());
            middleDetailService.remove(wq0);
            List<LtkjMiddleDetail> list = testMapper.getMiddleDetailByFeadId(pat.getFeadId());
            DynamicDataSourceContextHolder.setDataSourceType(DataSourceType.MASTER.name());
            LtkjMiddleHead o = headService.getMiddleHeadByPartId(customer.getCardId());
            if(o==null){
                headService.save(pat);
                for (LtkjMiddleDetail ltkjMiddleDetail : list) {
                    middleDetailService.save(ltkjMiddleDetail);
                }
            }
            testMapper.saveTjProByCusId(customer.getCardId(), customer.getCusIdcard());
        }
        DynamicDataSourceContextHolder.clearDataSourceType();
    }


    /**
     * 查询客户信息列表
     */
//    @PreAuthorize("@ss.hasPermi('hosp:customer:list')")
    @GetMapping("/list")
    @ApiOperation(value = "查看客户列表")
    public TableDataInfo list(TjCustomer tjCustomer) {
        startPage();
        List<TjCustomer> list = tjCustomerService.selectTjCustomerList(tjCustomer);
        if(null !=list && list.size()>0){
            for (TjCustomer customer : list) {
                customer.setCusName(MatchUtils.hideCusName(customer.getCusName()));
                customer.setCusPhone(MatchUtils.hidePhoneNum(customer.getCusPhone()));
                customer.setCusIdcard(MatchUtils.hideIdCardNum(customer.getCusIdcard()));
            }
        }
        return getDataTable(list);
    }

    /**
     * 导出客户信息列表
     */
    //@PreAuthorize("@ss.hasPermi('hosp:customer:export')")
    //@Log(title = "客户信息", businessType = BusinessType.EXPORT)
    @PostMapping("/export")
    public void export(HttpServletResponse response, TjCustomer tjCustomer) {
        List<TjCustomer> list = tjCustomerService.selectTjCustomerList(tjCustomer);
        ExcelUtil<TjCustomer> util = new ExcelUtil<TjCustomer>(TjCustomer.class);
        util.exportExcel(response, list, "客户信息数据");
    }

    /**
     * 获取客户信息详细信息
     */
    //@PreAuthorize("@ss.hasPermi('hosp:customer:query')")
    @GetMapping(value = "/{cusId}")
    @ApiOperation(value = "根据客户id获取客户详情")
    public AjaxResult getInfo(@PathVariable("cusId") @ApiParam(value = "客户id") Long cusId) {
        return success(tjCustomerService.selectTjCustomerByCusId(cusId));
    }

    /**
     * 新增客户信息
     */
    @PostMapping
    @ApiOperation(value = "新增客户")
    public AjaxResult add(@RequestBody @ApiParam(value = "客户对象信息") TjCustomer tjCustomer) {
        if (null == tjCustomer.getCusIdcard() || null == tjCustomer.getCusPhone()) {
            return AjaxResult.error("请输入身份证号或手机号");
        }
        String cusIdcard = tjCustomer.getCusIdcard();

        boolean b=true;
        if(null !=tjCustomer.getIdType()){
            if(tjCustomer.getIdType().equals("1")){
                b = MatchUtils.isIdCard(cusIdcard);
            }
//            else {
//                b = MatchUtils.cardValidate(cusIdcard, tjCustomer.getIdType());
//            }
        }else {
            return AjaxResult.error("请选择证件类型");
        }
        if(!b) return AjaxResult.error("证件号有误");

        //判断身份证号格式是否正确
        if (!(MatchUtils.isMobileNO(tjCustomer.getCusPhone())))
            return AjaxResult.error("手机号错误");

        LambdaQueryWrapper<TjCustomer> wq = new LambdaQueryWrapper<>();
        wq.eq(TjCustomer::getCusIdcard, cusIdcard);
        TjCustomer customer = tjCustomerService.getOne(wq);
        if (customer != null) {
//            BeanUtils.copyBeanProp(tjCustomer, customer);
//            String substring = cusIdcard.substring(cusIdcard.length() - 6);
//            substring = DigestUtils.md5DigestAsHex(substring.getBytes());
//            customer.setCusPassword(substring);
//            customer.setCusBrithday(DateUtil.parse(MatchUtils.getBirthDayByIdCard(tjCustomer.getCusIdcard()), "yyyy-MM-dd"));
//            return AjaxResult.success(tjCustomerService.updateById(customer));
            return AjaxResult.error("该人员已存在");
        }
        String substring = cusIdcard.substring(cusIdcard.length() - 6);
        substring = DigestUtils.md5DigestAsHex(substring.getBytes());
        tjCustomer.setCusPassword(substring);
        if(tjCustomer.getIdType().equals("1")){
            tjCustomer.setCusBrithday(DateUtil.parse(MatchUtils.getBirthDayByIdCard(tjCustomer.getCusIdcard()), "yyyy-MM-dd"));
        }
        tjCustomer.setCusNumber(0L);
        if (tjCustomerService.save(tjCustomer)) {
            return AjaxResult.success(tjCustomer);
        }
        return AjaxResult.error();
    }

    /**
     * 修改客户信息
     */
    //@PreAuthorize("@ss.hasPermi('hosp:customer:edit')")
    //@Log(title = "客户信息", businessType = BusinessType.UPDATE)
    @PutMapping
    @ApiOperation(value = "修改客户信息")
    public AjaxResult edit(@RequestBody @ApiParam(value = "客户对象") TjCustomer tjCustomer) {

        String cusPhone = tjCustomer.getCusPhone();
        if (null == cusPhone) {
            return AjaxResult.error("手机号不能为空");
        }
        /*LambdaQueryWrapper<TjCustomer> wq = new LambdaQueryWrapper<>();
        wq.eq(TjCustomer::getCusPhone, cusPhone);
        TjCustomer customer = tjCustomerService.getOne(wq);
        if (customer != null) {
            return AjaxResult.error("该手机号已被使用!");
        }*/
        tjCustomer.setCusPhone(cusPhone);
        return toAjax(tjCustomerService.updateTjCustomer(tjCustomer));
    }

    /**
     * 删除客户信息
     */
    //@PreAuthorize("@ss.hasPermi('hosp:customer:remove')")
    //@Log(title = "客户信息", businessType = BusinessType.DELETE)
    @DeleteMapping("/{cusIds}")
    @ApiOperation(value = "删除客户")
    public AjaxResult remove(@PathVariable @ApiParam(value = "所删除客户的id") Long[] cusIds) {
        return toAjax(tjCustomerService.deleteTjCustomerByCusIds(cusIds));
    }
}