package com.pz.merchant.service.impl;

import cn.hutool.core.bean.BeanUtil;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
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.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.CompanyBalanceBo;
import com.pz.merchant.domain.bo.CompanyBo;
import com.pz.merchant.domain.bo.ModifyCompanyInfoBo;
import com.pz.merchant.domain.vo.*;
import com.pz.merchant.mapper.CompanyMapper;
import com.pz.merchant.service.ICompanyService;
import com.pz.merchant.service.ISonOrderService;
import com.pz.system.domain.Income;
import com.pz.system.domain.SysUserRole;
import com.pz.system.domain.bo.DataViewBo;
import com.pz.system.domain.bo.WithdrawDepositBo;
import com.pz.system.domain.vo.DataViewVo;
import com.pz.system.mapper.CityMapper;
import com.pz.system.mapper.IncomeMapper;
import com.pz.system.mapper.SysUserMapper;
import com.pz.system.mapper.SysUserRoleMapper;
import com.pz.system.service.ISysUserService;
import lombok.RequiredArgsConstructor;
import org.springframework.stereotype.Service;


import java.math.BigDecimal;
import java.util.*;

/**
 * 商户Service业务层处理
 *
 * @author WangMin
 * @date 2023-09-11
 */
@RequiredArgsConstructor
@Service("merchantCompanyService")
public class CompanyServiceImpl implements ICompanyService {

    private final CompanyMapper baseMapper;

    private final CityMapper cityMapper;

    private final SysUserMapper userMapper;

    private final SonOrderServiceBuilder sonOrderServiceBuilder;

    private final IncomeMapper incomeMapper;

    private final SysUserMapper sysUserMapper;

    private final ISysUserService iSysUserService;

    private final SysUserRoleMapper userRoleMapper;

    /**
     * 查询商户
     */
    @Override
    public CompanyVo queryById(Integer id) {
        return baseMapper.selectVoById(id);
    }

    /**
     * 查询商户列表
     */
    @Override
    public TableDataInfo<CompanyVo> queryPageList(CompanyBo bo, PageQuery pageQuery) {
        LambdaQueryWrapper<Company> lqw = buildQueryWrapper(bo);
        Page<CompanyVo> result = baseMapper.selectVoPage(pageQuery.build(), lqw);
        Optional.ofNullable(result.getRecords()).ifPresent(
            companyVos -> {
                companyVos.forEach(companyVo -> {
                    companyVo.setValue(companyVo.getId());
                    companyVo.setText(companyVo.getName());
                    Optional.ofNullable(cityMapper.selectVoById(companyVo.getCityId()))
                        .ifPresent(cityVo -> {
                            companyVo.setCityName(cityVo.getName());
                        });
                });
            }
        );
        return TableDataInfo.build(result);
    }

    /**
     * 查询商户列表
     */
    @Override
    public List<CompanyVo> queryList(CompanyBo bo) {
        LambdaQueryWrapper<Company> lqw = buildQueryWrapper(bo);
        return baseMapper.selectVoList(lqw);
    }

    /**
     * pc查询商户列表
     * @param bo
     * @return
     */
    @Override
    public List<CompanyVo> queryListP(CompanyBo bo) {
        LambdaQueryWrapper<Company> lqw = buildQueryWrapper(bo);
        return baseMapper.selectVoList(lqw);
    }

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

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

    /**
     * 修改商户
     */
    @Override
    public Boolean updateByBo(CompanyBo bo) {
        Company update = BeanUtil.toBean(bo, Company.class);
        validEntityBeforeSave(update);
        SysUser sysUser = new SysUser();
        sysUser.setUserId(update.getUid().longValue());
        if(update.getStatus() == 0 || update.getStatus() == 2){
            sysUser.setUserType(UserType.XCX_USER.getUserType());
            sysUserMapper.updateById(sysUser);
            userRoleMapper.delete(new LambdaQueryWrapper<SysUserRole>().eq(SysUserRole::getUserId, sysUser.getUserId()));
        }else if(update.getStatus() == 1){
            sysUser.setUserType(UserType.AMERCHANT_USER.getUserType());
            sysUserMapper.updateById(sysUser);
            // 新增用户与角色管理
            SysUserRole ur = new SysUserRole();
            ur.setUserId(sysUser.getUserId());
            ur.setRoleId(3L);
            userRoleMapper.insert(ur);
        }
        return baseMapper.updateById(update) > 0;
    }

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

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

    /**
     * 修改商户名称/头像 信息
     *
     * @param bo 商户信息
     * @return 操作结果
     */
    @Override
    public boolean modifyCompanySimpleInfo(ModifyCompanyInfoBo bo) {
        CompanyVo companyVo = baseMapper.selectVoById(bo.getCompanyId());
        Objects.requireNonNull(companyVo, "该商户不存在");
        boolean companyFlag = true;
        if (StringUtils.isNotEmpty(bo.getCompanyName())) {
            LambdaUpdateWrapper<Company> companyWrapper = Wrappers.lambdaUpdate();
            companyWrapper.set(Company::getName, bo.getCompanyName())
                .eq(Company::getId, companyVo.getId());
            companyFlag = baseMapper.update(null, companyWrapper) > 0;
        }
        boolean userFlag = true;
        if (StringUtils.isNotEmpty(bo.getAvatar())) {
            LambdaUpdateWrapper<SysUser> userWrapper = Wrappers.lambdaUpdate();
            userWrapper.set(SysUser::getAvatar, bo.getAvatar())
                .eq(SysUser::getUserId, companyVo.getUid());
            userFlag = userMapper.update(null, userWrapper) > 0;
        }
        return companyFlag && userFlag;
    }

    /**
     * 查询商户信息
     *
     * @param companyId 商户ID
     * @return 商户信息
     */
    @Override
    public CompanyAppVo queryCompanyDataForApp(Integer companyId) {
        return baseMapper.selectCompanyDataForApp(companyId);
    }

    /**
     * 查询商户今日收益以及所有已完成订单
     *
     * @param companyId 商户ID
     * @param page      分页设置
     * @return 商户财务统计
     */
    @Override
    public FinanceStatisticVo queryFinanceStatistic(Integer companyId, PageQuery page) {
        BigDecimal todayDeal = Optional.ofNullable(baseMapper.selectFinanceStatistic(companyId)).orElse(BigDecimal.ZERO);
        FinanceStatisticVo result = new FinanceStatisticVo();
        result.setTodayDeal(todayDeal.floatValue());
        QueryWrapper<Company> query = Wrappers.query();
        query.eq("employees.company_id", companyId)
            .eq("total_order.status", 2); // 查询已完成的订单数据
        IPage<FinanceOrderInfoVo> pageResult = baseMapper.selectAllOrder(page.build(), query);
        result.setTotal(pageResult.getTotal());
        // 根据不同子订单装载就诊人员信息和子订单状态
        pageResult.getRecords().forEach(suborder -> {
            ISonOrderService orderService = sonOrderServiceBuilder.getSonOrderService(suborder.getBusinessId());
            SonOrderVo orderStatus;
            if (orderService != null && (orderStatus = orderService.getSonOrderSimpleDataByTotalId(suborder.getOrderId())) != null) {
                suborder.setUserName(orderStatus.getUserName());
                suborder.setSonOrderStatus(orderStatus.getOrderStatus());
            }
        });
        result.setOrders(pageResult.getRecords());
        return result;
    }

    /**
     * 查询账户余额
     *
     * @param bo   查询参数
     * @param page 分页结果
     * @return 商户余额及提现记录
     */
    @Override
    public CompanyBalanceVo queryCompanyBalance(CompanyBalanceBo bo, PageQuery page) {
        CompanyBalanceVo result = new CompanyBalanceVo();
        CompanyVo companyVo = baseMapper.selectVoById(bo.getCompanyId());
        Objects.requireNonNull(companyVo, "未查询到商户信息");
        result.setBalance(Float.valueOf(companyVo.getBalance()));
        result.setFreezeBalance(Float.valueOf(companyVo.getFreezeBalance()));
        result.setTotalRevenue(Float.valueOf(companyVo.getTotalRevenue()));
        LambdaUpdateWrapper<Income> wrapper = Wrappers.lambdaUpdate();
        wrapper.eq(bo.getCompanyId() != null, Income::getEcId, bo.getCompanyId())
            .eq(bo.getIncomeStatus() != null, Income::getStatus, bo.getIncomeStatus());
        IPage<CompanyIncomeVo> incomePage = incomeMapper.selectCompanyIncome(page.build(), wrapper);
        result.setTotal(incomePage.getTotal());
        result.setIncomes(incomePage.getRecords());
        return result;
    }

    /**
     * 商户提现
     *
     * @param bo 提现数据
     * @return 提现结果
     */
    @Override
    public boolean withdrawDeposit(WithdrawDepositBo bo) {
        Company company = baseMapper.selectById(bo.getId());
        Objects.requireNonNull(company, "未检查到账户");
        BigDecimal money = new BigDecimal(Optional.ofNullable(company.getBalance()).orElse("0"));
        BigDecimal balance = money.subtract(bo.getAmount());
        if (balance.compareTo(BigDecimal.ZERO) < 0) {
            throw new ServiceException("可用余额不足");
        }
        BigDecimal freeze = new BigDecimal(Optional.ofNullable(company.getFreezeBalance()).orElse("0"));
        freeze = freeze.add(bo.getAmount());
        LambdaUpdateWrapper<Company> wrapper = Wrappers.lambdaUpdate();
        wrapper.set(Company::getBalance, balance)
            .set(Company::getFreezeBalance, freeze)
            .eq(Company::getId, company.getId());
        // 目前不满足资质，拒绝提现操作
        throw new UnsupportedOperationException("资质不足，无法提现");
        // return baseMapper.update(null, wrapper) > 0;
    }

    @Override
    public DataViewVo dataCompany(DataViewBo dataViewBo) {
        return baseMapper.selectDataView(dataViewBo);
    }

    @Override
    public int selectCompanyById(Long userId) {
        return baseMapper.selectVoOne(new LambdaQueryWrapper<Company>().eq(Company::getUid, userId)).getId();
    }
}