package com.pz.merchant.service.impl;

import cn.hutool.core.bean.BeanUtil;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.dtflys.forest.annotation.Get;
import com.pz.common.core.domain.entity.SysUser;
import com.pz.common.core.page.TableDataInfo;
import com.pz.common.core.domain.PageQuery;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.pz.common.enums.UserType;
import com.pz.common.exception.ServiceException;
import com.pz.common.utils.StringUtils;
import com.pz.merchant.domain.Company;
import com.pz.merchant.domain.bo.EmployeesListBo;
import com.pz.merchant.domain.bo.OrderBo;
import com.pz.merchant.domain.bo.SetEmployeeWorkingHourBo;
import com.pz.merchant.domain.vo.*;
import com.pz.merchant.mapper.CompanyMapper;
import com.pz.merchant.service.ISonOrderService;
import com.pz.system.domain.TotalOrder;
import com.pz.system.domain.bo.EmployeesCompanyBo;
import com.pz.system.mapper.CityMapper;
import com.pz.system.mapper.SysUserMapper;
import com.pz.system.mapper.TotalOrderMapper;
import lombok.RequiredArgsConstructor;
import org.springframework.stereotype.Service;
import com.pz.merchant.domain.bo.EmployeesBo;
import com.pz.merchant.domain.Employees;
import com.pz.merchant.mapper.EmployeesMapper;
import com.pz.merchant.service.IEmployeesService;
import org.springframework.web.bind.annotation.GetMapping;

import java.util.*;

/**
 * 陪诊员Service业务层处理
 *
 * @author WangMin
 * @date 2023-09-11
 */
@RequiredArgsConstructor
@Service("merchantEmployeesService")
public class EmployeesServiceImpl implements IEmployeesService {

    private final EmployeesMapper baseMapper;
    private final CompanyMapper companyMapper;
    private final SysUserMapper sysUserMapper;
    private final CityMapper cityMapper;
    private final TotalOrderMapper totalOrderMapper;
    private final SonOrderServiceBuilder sonOrderServiceBuilder;

    /**
     * 查询陪诊员
     */
    @Override
    public EmployeesVo queryById(Integer id) {
        return baseMapper.selectVoById(id);
    }

    /**
     * 查询陪诊员列表
     */
    @Override
    public TableDataInfo<EmployeesVo> queryPageList(EmployeesBo bo, PageQuery pageQuery) {
        LambdaQueryWrapper<Employees> lqw = buildQueryWrapper(bo);
        Page<EmployeesVo> result = baseMapper.selectVoPage(pageQuery.build(), lqw);
        Optional.ofNullable(result.getRecords()).ifPresent(employeesVos -> {
            employeesVos.forEach(employeesVo -> {
                // 获取商户名称
                Optional.ofNullable(companyMapper.selectVoById(employeesVo.getCompanyId()))
                    .ifPresent(companyVo -> employeesVo.setCompanyName(companyVo.getName()));

                // 获取用户名称
                Optional.ofNullable(sysUserMapper.selectUserById(employeesVo.getUid().longValue())).ifPresent(
                    sysUser -> employeesVo.setUserName(sysUser.getNickName())
                );

                // 获取城市
                Optional.ofNullable(cityMapper.selectVoById(employeesVo.getCityId())).ifPresent(
                    cityVo -> employeesVo.setCityName(cityVo.getName())
                );
            });
        });
        return TableDataInfo.build(result);
    }

    /**
     * 小程序查询陪诊员列表
     */
    @Override
    public TableDataInfo<EmployeesListVo> employeesList(EmployeesListBo bo, PageQuery pageQuery) {
        QueryWrapper<Employees> wrapper = Wrappers.query();
        wrapper.like(StringUtils.isNotEmpty(bo.getEmployeeName()), "employees.name", bo.getEmployeeName())
            .eq(bo.getEmployeeType() != null, "employees.now_type", bo.getEmployeeType());
        IPage<EmployeesListVo> result = baseMapper.selectEmployeesList(pageQuery.build(), wrapper);
        return TableDataInfo.build(result);
    }


    /**
     * 查询陪诊员列表
     */
    @Override
    public List<EmployeesVo> queryList(EmployeesBo bo) {
        LambdaQueryWrapper<Employees> lqw = buildQueryWrapper(bo);
        return baseMapper.selectVoList(lqw);
    }

    private LambdaQueryWrapper<Employees> buildQueryWrapper(EmployeesBo bo) {
        Map<String, Object> params = bo.getParams();
        LambdaQueryWrapper<Employees> lqw = Wrappers.lambdaQuery();
        lqw.like(StringUtils.isNotBlank(bo.getName()), Employees::getName, bo.getName());
        lqw.eq(StringUtils.isNotBlank(bo.getStartYear()), Employees::getStartYear, bo.getStartYear());
        lqw.eq(bo.getUid() != null, Employees::getUid, bo.getUid());
        lqw.eq(bo.getStatus() != null, Employees::getStatus, bo.getStatus());
        lqw.eq(bo.getNowType() != null, Employees::getNowType, bo.getNowType());
        return lqw;
    }

    /**
     * 新增陪诊员/商户
     */
    @Override
    public Boolean insertByBo(EmployeesBo bo) {
        Employees add = BeanUtil.toBean(bo, Employees.class);
        validEntityBeforeSave(add);
        boolean flag = baseMapper.insert(add) > 0;
        if (flag) {
            bo.setId(add.getId());
        }
        return flag;
    }

    @Override
    public Boolean insertByEmployeesCompanyBo(EmployeesCompanyBo bo) {
        /**
         * 陪诊员新增
         */
        SysUser sysUser = new SysUser();
        sysUser.setUserId(bo.getUid().longValue());
        sysUser.setPhonenumber(bo.getPhone());
        if(bo.getIdentity() == 2){
            Employees add = BeanUtil.toBean(bo, Employees.class);
            add.setNowType(1);

            boolean flag = baseMapper.insert(add) > 0;
            if (flag) {
                bo.setId(add.getId());
                //修改系统表角色
                sysUser.setUserType(UserType.APP_USER.getUserType());
                sysUserMapper.updateById(sysUser);
            }
            return flag;
        }else if(bo.getIdentity() == 3){//商户新增
            Company add = BeanUtil.toBean(bo, Company.class);

            boolean flag = companyMapper.insert(add) > 0;
            if (flag) {
                bo.setId(add.getId());
                //修改系统表角色
                sysUser.setUserType(UserType.AMERCHANT_USER.getUserType());
                sysUserMapper.updateById(sysUser);
            }
            return flag;
        }
        return false;
    }

    /**
     * 修改陪诊员
     */
    @Override
    public Boolean updateByBo(EmployeesBo bo) {
        Employees update = BeanUtil.toBean(bo, Employees.class);
        validEntityBeforeSave(update);
        return baseMapper.updateById(update) > 0;
    }

    /**
     * 需求广场
     *
     * @param bo
     * @param pageQuery
     * @return
     */
    @Override
    public TableDataInfo<EmployeesVo> queryPageAppNeed(EmployeesBo bo, PageQuery pageQuery) {
        Page<EmployeesVo> result = baseMapper.selectEmployees(bo, pageQuery.build());
        Optional.ofNullable(result.getRecords()).ifPresent(EmployeesVo -> {
            EmployeesVo.forEach(t -> {
                List<TotalOrder> totalOrder = totalOrderMapper.selectList(Wrappers.<TotalOrder>lambdaQuery()
                    .eq(TotalOrder::getEmId, t.getId())
                    .eq(TotalOrder::getIsSatisfaction, 1)
                    .orderByDesc(TotalOrder::getId)
                    .last("LIMIT 1"));
                t.setTotalOrderVo(totalOrder);
            });
        });
        return TableDataInfo.build(result);
    }

    /**
     * 排行榜
     *
     * @param bo
     * @param pageQuery
     * @return
     */
    @Override
    public TableDataInfo<EmployeesVo> queryPageAppRanking(EmployeesBo bo, PageQuery pageQuery) {
        Page<EmployeesVo> result = baseMapper.selectEmployees(bo, pageQuery.build());
        Optional.ofNullable(result.getRecords()).ifPresent(EmployeesVo -> {
            EmployeesVo.forEach(t -> {
                List<TotalOrder> totalOrder = totalOrderMapper.selectList(Wrappers.<TotalOrder>lambdaQuery()
                    .eq(TotalOrder::getEmId, t.getId())
                    .eq(TotalOrder::getIsSatisfaction, 1)
                    .orderByDesc(TotalOrder::getId)
                    .last("LIMIT 1"));
                t.setTotalOrderVo(totalOrder);
            });
        });
        return TableDataInfo.build(result);
    }


    /**
     * 查询陪诊员详情
     */
    @Override
    public EmployeesVo queryByApp(Integer id) {
        EmployeesVo employeesVo = baseMapper.selectEmployeesById(id);
        List<TotalOrder> totalOrder = totalOrderMapper.selectList(Wrappers.<TotalOrder>lambdaQuery()
            .eq(TotalOrder::getEmId, employeesVo.getId())
            .eq(TotalOrder::getIsSatisfaction, 1)
            .orderByDesc(TotalOrder::getId));
        employeesVo.setTotalOrderVo(totalOrder);
        return employeesVo;
    }

    /**
     * 切换陪诊员用户身份
     *
     * @param emId 陪诊员Id
     * @return 操作结果
     */
    @Override
    public boolean switchEmployeeIdentity(Integer emId) {
        EmployeesVo employeesVo = baseMapper.selectVoById(emId);
        Objects.requireNonNull(employeesVo, "查无此人");
        Integer identity = employeesVo.getNowType();
        // 切换当前用户身份
        Integer modifyIdentity = identity == 1 ? 2 : 1;
        employeesVo.setNowType(modifyIdentity);
        return baseMapper.updateById(BeanUtil.toBean(employeesVo, Employees.class)) > 0;
    }

    /**
     * 冻结/解冻陪诊员账户
     *
     * @param emId 陪诊员Id
     * @return 操作结果
     */
    @Override
    public boolean disableOrRecover(Integer emId) {
        EmployeesVo employeesVo = baseMapper.selectVoById(emId);
        Objects.requireNonNull(employeesVo, "查无此人");
        Integer status = employeesVo.getStatus();
        if (status == 0) {
            throw new ServiceException("该用户待审核通过，暂无法修改状态");
        }
        Integer modifyStatus = status == 1 ? 2 : 1;
        employeesVo.setStatus(modifyStatus);
        return baseMapper.updateById(BeanUtil.toBean(employeesVo, Employees.class)) > 0;
    }

    /**
     * 保存前的数据校验
     */
    private void validEntityBeforeSave(Employees entity) {
        // TODO 做一些数据校验,如唯一约束
    }

    /**
     * 批量删除陪诊员
     */
    @Override
    public Boolean deleteWithValidByIds(Collection<Integer> ids, Boolean isValid) {
        if (isValid) {
            // TODO 做一些业务上的校验,判断是否需要校验
        }
        return baseMapper.deleteBatchIds(ids) > 0;
    }

    /**
     * 设置员工工作时段
     */
    @Override
    public boolean setEmployeesWorkHours(SetEmployeeWorkingHourBo bo) {
        EmployeesVo employees = baseMapper.selectVoById(bo.getEmId());
        Objects.requireNonNull(employees, "查无此人");
        LambdaUpdateWrapper<Employees> updateWrapper = Wrappers.lambdaUpdate();
        updateWrapper.set(Employees::getWorkingHours, bo.getWorkingHours())
            .eq(Employees::getId, employees.getId());
        return baseMapper.update(null, updateWrapper) > 0;
    }

    /**
     * 查询员工数据以及今日订单
     *
     * @param emId 员工ID
     * @return 今日订单数据信息
     */
    @Override
    public TodayOrderListVo queryEmployeesInfo(Integer emId) {
        TodayOrderListVo result = baseMapper.selectEmployeesInfoById(emId);
        QueryWrapper<Employees> query = Wrappers.query();
        query.apply("date_format(total_order.create_time,'%Y-%m-%d') = current_date")
            .eq("total_order.em_id", emId);
        IPage<OrderInfoVO> page = baseMapper.selectOrder(new PageQuery().build(), query);
        // 根据不同子订单装载就诊人员信息和子订单状态
        List<OrderInfoVO> orders = page.getRecords();
        orders.forEach(suborder -> {
            ISonOrderService orderService = sonOrderServiceBuilder.getSonOrderService(suborder.getBid());
            SonOrderVo orderStatus;
            if (orderService != null && (orderStatus = orderService.getSonOrderInfoByTotalId(suborder.getOrderId())) != null) {
                suborder.setUserName(orderStatus.getUserName());
                suborder.setSonOrderStatus(orderStatus.getOrderStatus());
            }
        });
        result.setTodayOrderList(orders);
        result.setTodayOrderNum(orders.size());
        return result;
    }

    /**
     * 查询所有订单
     *
     * @param bo 查询条件
     * @return 订单列表
     */
    @Override
    public TableDataInfo<OrderInfoVO> queryAllOrder(OrderBo bo, PageQuery pageQuery) {
        QueryWrapper<Employees> query = Wrappers.query();
        query.eq(bo.getEmId() != null, "total_order.em_id", bo.getEmId())
            .eq(bo.getServiceStatus() != null, "total_order.status", bo.getServiceStatus());
        IPage<OrderInfoVO> page = baseMapper.selectOrder(pageQuery.build(), query);
        // 根据不同子订单装载就诊人员信息和子订单状态
        page.getRecords().forEach(suborder -> {
            ISonOrderService orderService = sonOrderServiceBuilder.getSonOrderService(suborder.getBid());
            SonOrderVo orderStatus;
            if (orderService != null && (orderStatus = orderService.getSonOrderInfoByTotalId(suborder.getOrderId())) != null) {
                suborder.setUserName(orderStatus.getUserName());
                suborder.setSonOrderStatus(orderStatus.getOrderStatus());
            }
        });
        return TableDataInfo.build(page);
    }


}