package com.ylx.web.controller.massage;

import java.util.*;
import java.util.concurrent.TimeUnit;
import java.util.regex.Pattern;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import cn.hutool.json.JSONObject;
import com.alibaba.fastjson.JSON;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.ylx.common.annotation.Log;
import com.ylx.common.constant.CacheConstants;
import com.ylx.common.constant.Constants;
import com.ylx.common.core.controller.BaseController;
import com.ylx.common.core.domain.AjaxResult;
import com.ylx.common.core.domain.R;
import com.ylx.common.core.domain.model.LoginUser;
import com.ylx.common.core.domain.model.WxLoginUser;
import com.ylx.common.core.domain.model.aliyun.SMSVerificationCode;
import com.ylx.common.core.domain.model.aliyun.SendSmsComponents;
import com.ylx.common.core.domain.model.aliyun.SendSmsEnum;
import com.ylx.common.core.page.TableDataInfo;
import com.ylx.common.core.redis.RedisCache;
import com.ylx.common.enums.BusinessType;
import com.ylx.common.exception.user.CaptchaException;
import com.ylx.common.exception.user.CaptchaExpireException;
import com.ylx.common.utils.MessageUtils;
import com.ylx.common.utils.SecurityUtils;
import com.ylx.common.utils.StringUtils;
import com.ylx.common.utils.poi.ExcelUtil;
import com.ylx.framework.manager.AsyncManager;
import com.ylx.framework.manager.factory.AsyncFactory;
import com.ylx.framework.web.service.WxTokenService;
import com.ylx.massage.domain.MaProject;
import com.ylx.massage.domain.MaTechnician;
import com.ylx.massage.domain.dto.*;
import com.ylx.massage.domain.vo.*;
import com.ylx.massage.service.IMaProjectService;
import com.ylx.massage.service.IMaTechnicianService;
import com.ylx.project.domain.Project;
import com.ylx.servicecategory.domain.ServiceCategory;
import com.ylx.servicecategory.service.ServiceCategoryService;
import com.ylx.system.service.ISysConfigService;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.security.access.prepost.PreAuthorize;
import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.util.ObjectUtils;
import org.springframework.web.bind.annotation.*;
import com.ylx.common.annotation.Log;
import com.ylx.common.core.controller.BaseController;
import com.ylx.common.core.domain.AjaxResult;
import com.ylx.common.enums.BusinessType;
import com.ylx.massage.domain.MaTechnician;
import com.ylx.massage.service.IMaTechnicianService;
import com.ylx.common.utils.poi.ExcelUtil;
import com.ylx.common.core.page.TableDataInfo;
import org.springframework.web.multipart.MultipartFile;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.validation.Valid;
import java.util.List;
import java.util.Objects;
import java.util.Random;
import java.util.concurrent.TimeUnit;
import java.util.regex.Pattern;

import static jdk.nashorn.internal.runtime.regexp.joni.Config.log;

/**
 * 技师Controller
 *
 * @author ylx
 * @date 2024-03-22
 */
@Api("技师管理")
@Slf4j
@RestController
@RequestMapping("/technician/technician")
public class MaTechnicianController extends BaseController {
    @Autowired
    private IMaTechnicianService maTechnicianService;

    @Autowired
    private StringRedisTemplate redisTemplate;

    @Autowired
    private SendSmsComponents sendSms;
    @Autowired
    private ServiceCategoryService serviceCategoryService;
    @Autowired
    private IMaProjectService maProjectService;
    @Autowired
    private ISysConfigService configService;
    @Autowired
    private RedisCache redisCache;
    @Autowired
    private WxTokenService wxTokenService;


    public static final String PHONE_THREEUSERPARTCLIENT_CODE_KEY = "sys:clientLogin:phone:";

    @GetMapping("/sendMsg")
    @ApiOperation(value = "短信发送", notes = "短信发送")
    public Result sendMsg(@RequestParam String phone, HttpServletRequest request) {
        if (org.apache.commons.lang3.StringUtils.isEmpty(phone)) {
            return Result.error("手机号不能为空");
        }
        Random rand = new Random();
        // randNumber 将被赋值为一个 MIN 和 MAX 范围内的随机数
        int randNumber = rand.nextInt(9999 - 1000 + 1) + 1000;
        // 保存验证码到redis
        redisTemplate.opsForValue()
                .set("userH5:order:phone:" + phone, String.valueOf(randNumber), 5L
                        , TimeUnit.MINUTES);
        try {
            SMSVerificationCode smsVerificationCode = new SMSVerificationCode(String.valueOf(randNumber));
            String jsonString = JSON.toJSONString(smsVerificationCode);
            sendSms.sendSms(phone, SendSmsEnum.SMS_220650024, jsonString);
            return Result.ok("发送成功");
        } catch (Exception e) {
            e.printStackTrace();
        }
        return Result.ok("发送成功");
    }

    /**
     * 商户登录接口
     *
     * @param thirdPartyLoginsVo
     * @return Result<WxLoginUser>
     */
    @ApiOperation(value = "商户登录", notes = "商户登录")
    @PostMapping(value = "/clientLogin")
    @Transactional
    public Result<WxLoginUser> login(@RequestBody ThirdPartyLoginsVo thirdPartyLoginsVo) throws Exception {
        // 获取登录用户信息
        Result<WxLoginUser> result = new Result<>();

        // 校验手机号是否为空
        if (StringUtils.isEmpty(thirdPartyLoginsVo.getPhone())) {
            return result.error500("请输入手机号");
        }

        // 校验用户是否存在且有效
        LambdaQueryWrapper<MaTechnician> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.eq(MaTechnician::getTePhone, thirdPartyLoginsVo.getPhone());
        MaTechnician maTechnician = maTechnicianService.getOne(queryWrapper);
        // 校验用户是否有效
        if (ObjectUtils.isEmpty(maTechnician)) {
            return result.error500("商户不存在,请先注册");
        }

        if (thirdPartyLoginsVo.getCodeSwitch()) {
            // 短信验证
            String msg = redisTemplate.opsForValue().get(PHONE_THREEUSERPARTCLIENT_CODE_KEY + thirdPartyLoginsVo.getPhone());
            if (StringUtils.isEmpty(msg)) {
                return Result.error("验证码已失效");
            }

            if (!thirdPartyLoginsVo.getPhoneMsg().equals(msg)) {
                return Result.error("短信验证码不正确");
            }
        } else {
            // 初始化加密工具
            BCryptPasswordEncoder encoder = new BCryptPasswordEncoder();
            // 验证：比对是否匹配
            boolean isOk = encoder.matches(thirdPartyLoginsVo.getPassWord(), maTechnician.getTePassword());
            /*if (!isOk) {
                return Result.error("密码错误");
            }*/
        }
        WxLoginUser wxUser = new WxLoginUser();
        BeanUtils.copyProperties(maTechnician, wxUser);
        // 生成并返回令牌
        String token = wxTokenService.createToken(wxUser);
        log.info("token的值：{}", token);
        if (token == null || token.isEmpty()) {
            return Result.error("生成令牌失败");
        }
        //给我把token的值保存到redis中
        redisTemplate.opsForValue().set(wxUser.getCOpenid(), token, 180, TimeUnit.MINUTES);
        wxUser.setToken(token);
        // 返回用户信息
        // 记录登录信息
        AsyncManager.me().execute(AsyncFactory.recordLogininfor(wxUser.getCOpenid(), Constants.LOGIN_SUCCESS, MessageUtils.message("user.login.success")));
        result.setResult(wxUser);
        // 登录成功删除验证码
        redisTemplate.delete(PHONE_THREEUSERPARTCLIENT_CODE_KEY + thirdPartyLoginsVo.getPhone());

        result.success("登录成功");
        return result;
    }

    /**
     * 商户忘记密码接口
     */
    @PostMapping("/resetPassword")
    @ApiOperation("商户忘记密码接口")
    public Result<?> resetPassword(@RequestBody ThirdPartyLoginsVo thirdPartyLoginsVo) {
        // 核心正则表达式：
        // ^ 表示开头，$ 表示结尾
        // [a-zA-Z0-9] 表示只能是字母或数字
        // {8,20} 表示长度必须在8到20之间
        String regex = "^[a-zA-Z0-9]{8,20}$";
        boolean isMatch = Pattern.matches(regex, thirdPartyLoginsVo.getPassWord().trim());
        if (!isMatch) {
            // 根据需求返回指定的异常提示
            return Result.error("请输入8-20位数字/字母组合");
        }
        // 短信验证
        String msg = redisTemplate.opsForValue().get(PHONE_THREEUSERPARTCLIENT_CODE_KEY + thirdPartyLoginsVo.getPhone());
        if (StringUtils.isEmpty(msg)) {
            return Result.error("验证码已失效");
        }
        if (msg != null && msg.startsWith("\"") && msg.endsWith("\"")) {
            msg = msg.substring(1, msg.length() - 1);
        }
        if (!thirdPartyLoginsVo.getPhoneMsg().equals(msg)) {
            return Result.error("短信验证码不正确");
        }
        // 重置密码逻辑
        LambdaUpdateWrapper<MaTechnician> updateWrapper = new LambdaUpdateWrapper<>();
        updateWrapper.eq(MaTechnician::getTePhone, thirdPartyLoginsVo.getPhone());
        updateWrapper.set(MaTechnician::getTePassword, thirdPartyLoginsVo.getPassWord());
        maTechnicianService.update(updateWrapper);
        redisTemplate.delete(PHONE_THREEUSERPARTCLIENT_CODE_KEY + thirdPartyLoginsVo.getPhone());
        return Result.ok("重置密码成功");
    }

    /**
     * 校验图形验证码接口
     */
    @PostMapping("/getValidateCaptcha")
    @ApiOperation("校验图形验证码接口")
    public Result<?> getValidateCaptcha(@RequestBody ValidateCaptchaDto req) {
        validateCaptcha(req.getPhone(), req.getCode(), req.getUuid());
        return Result.ok("校验成功");
    }

    /**
     * 商户入驻申请接口
     *
     * @param req
     * @return Result<?>
     */
    @PostMapping("/apply")
    @ApiOperation("商户入驻申请接口")
    public Result<?> apply(@RequestBody MaTechnicianAppAddVo req) {
        try {
            // 1. 基础参数校验
            if (StringUtils.isAnyBlank(req.getTeName(), req.getTePhone(),  req.getAvatar())) {
                return Result.error("必填项不能为空");
            }
            //校验性别不能为空
            if (Objects.isNull(req.getTeSex())) {
                return Result.error("性别不能为空");
            }
            // 短信验证
            String msg = redisTemplate.opsForValue().get(PHONE_THREEUSERPARTCLIENT_CODE_KEY + req.getTePhone());
            log.info("短信验证码的值：{}", msg);
            /*if (StringUtils.isEmpty(msg)) {
                return Result.error("验证码已失效");
            }
            if (msg != null && msg.startsWith("\"") && msg.endsWith("\"")) {
                msg = msg.substring(1, msg.length() - 1);
            }
            if (!req.getPhoneMsg().equals(msg)) {
                return Result.error("短信验证码不正确");
            }*/
            if (StringUtils.isNotEmpty(req.getPhoneImgMsg())) {
                validateCaptcha(req.getTeName(), req.getPhoneImgMsg(), req.getUuid());
            }
            // 2. 调用业务层处理入驻申请
            maTechnicianService.apply(req);
            return Result.ok("提交成功，进入审核流程");
        } catch (Exception e) {
            e.printStackTrace();
            throw new RuntimeException(e);
        }
    }

    /**
     * 校验验证码
     *
     * @param username 用户名
     * @param code     验证码
     * @param uuid     唯一标识
     * @return 结果
     */
    public void validateCaptcha(String username, String code, String uuid) {
        boolean captchaEnabled = configService.selectCaptchaEnabled();
        if (captchaEnabled) {
            String verifyKey = CacheConstants.CAPTCHA_CODE_KEY + StringUtils.nvl(uuid, "");
            String captcha = redisCache.getCacheObject(verifyKey);
            redisCache.deleteObject(verifyKey);
            if (captcha == null) {
                AsyncManager.me().execute(AsyncFactory.recordLogininfor(username, Constants.LOGIN_FAIL, MessageUtils.message("user.jcaptcha.expire")));
                throw new CaptchaExpireException();
            }
            if (!code.equalsIgnoreCase(captcha)) {
                AsyncManager.me().execute(AsyncFactory.recordLogininfor(username, Constants.LOGIN_FAIL, MessageUtils.message("user.jcaptcha.error")));
                throw new CaptchaException();
            }
        }
    }

    /**
     * 申请技师文件
     *
     * @param req
     * @return Result<?>
     */
    @PostMapping("/applyFile")
    @ApiOperation("申请技师文件")
    public Result applyFile(@RequestBody MerchantApplyFileRequestDto req) {
        try {
            maTechnicianService.applyFile(req);
            return Result.ok("上传成功");
        } catch (Exception e) {
            e.printStackTrace();
            throw new RuntimeException(e);
        }
    }

    /**
     * 获取待接单列表：前端传技师实时经纬度筛选订单
     */
    @PostMapping("/wait/list")
    @ApiOperation("获取待接单列表")
    public Result<List<WaitOrderDTO>> getWaitOrder(@RequestBody WaitOrderQueryDTO query) {
        List<WaitOrderDTO> list = maTechnicianService.listWaitOrder(query);
        return Result.ok(list);
    }

    /**
     * 滑动接单逻辑不变，
     * 仅列表查询逻辑修正
     */
    @PostMapping("/accept")
    @ApiOperation("滑动接单")
    public Result<String> acceptOrder(@RequestBody AcceptOrderReqDTO req) {
        String tip = maTechnicianService.acceptOrder(req);
        return Result.ok(tip);
    }

    /**
     * 技师接单确认逻辑不变，
     * 仅列表查询逻辑修正
     */
    @GetMapping("/rest/confirm")
    @ApiOperation("确认接单")
    public Result<String> confirmRestAccept(@RequestParam Long techId, @RequestParam Long orderId) {
        String tip = maTechnicianService.confirmRestAccept(techId, orderId);
        return Result.ok(tip);
    }

    /**
     * 技师拒绝接单逻辑不变，
     * 仅列表查询逻辑修正
     */
    @PostMapping("/refuse")
    @ApiOperation("拒绝接单")
    public Result<Void> refuseOrder(@RequestBody RefuseOrderReqDTO req) {
        maTechnicianService.refuseOrder(req);
        return Result.ok("拒绝成功");
    }

    /**
     * 技师状态切换
     *
     * @param userId 商户ID
     * @param forceConfirm 是否强制切换
     * @return Result<?>
     */
    @GetMapping("/switchToOffline")
    @ApiOperation("技师状态切换")
    public Result switchToOffline(@RequestParam Long userId, @RequestParam Boolean forceConfirm) {
        try {
            return maTechnicianService.switchToOffline(userId, forceConfirm);
        } catch (Exception e) {
            e.printStackTrace();
            throw new RuntimeException(e);
        }
    }

    /**
     * 查询商户信息
     *
     * @param openid 微信openid
     * @return Result<?>
     */
    @GetMapping("/getTechnician")
    @ApiOperation("查询商户信息")
    public Result<?> getTechnician(@RequestParam String openid) {
        try {
            MerchantAuditFile technicianInfo = maTechnicianService.getTechnicianInfo(openid);
            return Result.ok(technicianInfo.getMerchant());
        } catch (Exception e) {
            log.error("查询商户信息失败", e);
            return Result.error(e.getMessage());
        }
    }

    /**
     * 查询商户信息和入驻资料
     *
     * @param openid 微信openid
     * @return Result<?>
     */
    @GetMapping("/getTechnicianInfo")
    @ApiOperation("查询商户信息和入驻资料")
    public Result<?> getTechnicianInfo(@RequestParam("openid") String openid) {
        try {
            return Result.ok(maTechnicianService.getTechnicianInfo(openid));
        } catch (Exception e) {
            log.error("查询商户信息和入驻资料失败", e);
            return Result.error(e.getMessage());
        }
    }

    /**
     * 修改商户信息
     *
     * @param req
     * @return Result<?>
     */
    @PostMapping("/updateTechnician")
    @ApiOperation("修改商户信息接口")
    public Result<?> updateTechnician(@RequestBody MerchantApplyFileRequestDto req) {
        try {
            maTechnicianService.updateTechnician(req);
            return Result.ok("修改成功");
        } catch (Exception e) {
            log.error("修改商户信息失败", e);
            return Result.error(e.getMessage());
        }
    }

    /**
     * 查询技师列表
     */
    @PreAuthorize("@ss.hasPermi('technician:technician:list')")
    @GetMapping("/list")
    public TableDataInfo list(MaTechnician maTechnician) {
        startPage();
        List<MaTechnician> list = maTechnicianService.selectMaTechnicianList(maTechnician);
        return getDataTable(list);
    }

    /**
     * 导出技师列表
     */
    @PreAuthorize("@ss.hasPermi('technician:technician:export')")
    @Log(title = "技师", businessType = BusinessType.EXPORT)
    @PostMapping("/export")
    public void export(HttpServletResponse response, MaTechnician maTechnician) {
        List<MaTechnician> list = maTechnicianService.selectMaTechnicianList(maTechnician);
        ExcelUtil<MaTechnician> util = new ExcelUtil<MaTechnician>(MaTechnician.class);
        util.exportExcel(response, list, "技师数据");
    }

    /**
     * 获取技师详细信息
     */
    @PreAuthorize("@ss.hasPermi('technician:technician:query')")
    @GetMapping(value = "/{id}")
    public AjaxResult getInfo(@PathVariable("id") Long id) {
        return success(maTechnicianService.selectMaTechnicianById(id));
    }

    /**
     * 新增技师
     */
    @ApiOperation("技师入驻")
    @PreAuthorize("@ss.hasPermi('technician:technician:add')")
    @Log(title = "技师", businessType = BusinessType.INSERT)
    @PostMapping
    public AjaxResult add(@RequestBody MaTechnicianAppAddVo maTechnicianAppAddVo) {
        return toAjax(maTechnicianService.insertMaTechnician(maTechnicianAppAddVo));
    }

    /**
     * 后台新增商户
     *
     * @param dto 商户新增DTO
     * @return AjaxResult 结果
     */
    @ApiOperation("后台新增商户")
    @PreAuthorize("@ss.hasPermi('technician:technician:add')")
    @Log(title = "商户", businessType = BusinessType.INSERT)
    @PostMapping("/merchant")
    public AjaxResult addMerchant(@RequestBody MaTechnicianMerchantAddDTO dto) {
        try {
            LoginUser loginUser = getLoginUser();
            return toAjax(maTechnicianService.insertMerchant(dto, loginUser));
        } catch (Exception e) {
            e.printStackTrace();
            throw new RuntimeException(e);
        }
    }

    /**
     * 后台编辑商户
     *
     * @param id  商户ID
     * @param dto 商户编辑DTO
     * @return AjaxResult 结果
     */
    @ApiOperation("后台编辑商户")
    @PreAuthorize("@ss.hasPermi('technician:technician:edit')")
    @Log(title = "商户", businessType = BusinessType.UPDATE)
    @PutMapping("/merchant/{id}")
    public AjaxResult editMerchant(@PathVariable("id") Integer id, @RequestBody MaTechnicianMerchantAddDTO dto) {
        try {
            LoginUser loginUser = getLoginUser();
            return toAjax(maTechnicianService.updateMerchant(id, dto, loginUser));
        } catch (Exception e) {
            e.printStackTrace();
            throw new RuntimeException(e);
        }
    }

    /**
     * 后台上传商户合同文件
     *
     * @param id  商户ID
     * @param map 合同文件
     * @return R 上传结果
     */
    @ApiOperation("后台上传商户合同文件")
    @PreAuthorize("@ss.hasPermi('technician:technician:edit')")
    @Log(title = "商户合同", businessType = BusinessType.UPDATE)
    @PostMapping("/merchant/{id}/contract")
    public R uploadMerchantContract(@PathVariable("id") Integer id, @RequestBody Map<String, Object> map) {
        try {
            LoginUser loginUser = getLoginUser();
            return R.ok(maTechnicianService.uploadMerchantContract(id, map, loginUser));
        } catch (Exception e) {
            e.printStackTrace();
            throw new RuntimeException(e);
        }
    }

    /**
     * 查询商户入驻审核列表
     *
     * @param page 分页参数
     * @param dto  查询条件
     * @return Page 商户入驻审核分页列表
     */
    @ApiOperation("后台查询商户入驻审核列表")
    @PreAuthorize("@ss.hasPermi('technician:technician:list')")
    @GetMapping("/merchant/audit/list")
    public R<Page<MaTechnicianAuditListVO>> merchantAuditList
    (Page<MaTechnicianAuditListVO> page, MaTechnicianAuditQueryDTO dto) {
        try {
            return R.ok(maTechnicianService.selectMerchantAuditList(page, dto));
        } catch (Exception e) {
            e.printStackTrace();
            throw new RuntimeException(e);
        }
    }

    /**
     * 商户入驻审核
     *
     * @param id  商户ID
     * @param dto 审核提交参数
     * @return AjaxResult 结果
     */
    @ApiOperation("商户入驻审核")
    @PreAuthorize("@ss.hasPermi('technician:technician:edit')")
    @Log(title = "商户入驻审核", businessType = BusinessType.UPDATE)
    @PutMapping("/merchant/audit/{id}/submit")
    public AjaxResult submitMerchantAudit(@PathVariable("id") Integer id, @RequestBody MaTechnicianAuditSubmitDTO
                                                                                  dto) {
        try {
            LoginUser loginUser = getLoginUser();
            return toAjax(maTechnicianService.submitMerchantAudit(id, dto, loginUser));
        } catch (Exception e) {
            e.printStackTrace();
            throw new RuntimeException(e);
        }
    }

    /**
     * 待审核页面审核通过商户
     *
     * @param id  商户ID
     * @param dto 待审核通过参数
     * @return AjaxResult 结果
     */
    @ApiOperation("待审核页面审核通过商户")
    @PreAuthorize("@ss.hasPermi('technician:technician:edit')")
    @Log(title = "商户待审核通过", businessType = BusinessType.UPDATE)
    @PutMapping("/merchant/audit/{id}/approve")
    public AjaxResult approvePendingMerchantAudit(@PathVariable("id") Integer id,
                                                  @RequestBody MaTechnicianPendingAuditSubmitDTO
                                                          dto) {
        try {
            LoginUser loginUser = getLoginUser();
            return toAjax(maTechnicianService.approvePendingMerchantAudit(id, dto, loginUser));
        } catch (Exception e) {
            e.printStackTrace();
            throw new RuntimeException(e);
        }
    }

    /**
     * 查询商户列表
     *
     * @param page 分页参数
     * @param dto  商户查询DTO
     * @return Page 商户分页列表
     */
    @ApiOperation("后台查询商户列表")
    @PreAuthorize("@ss.hasPermi('technician:technician:list')")
    @GetMapping("/merchant/list")
    public R<Page<MaTechnicianMerchantListVO>> merchantList
    (Page<MaTechnicianMerchantListVO> page, MaTechnicianMerchantQueryDTO dto) {
        try {
            return R.ok(maTechnicianService.selectMerchantList(page, dto));
        } catch (Exception e) {
            e.printStackTrace();
            throw new RuntimeException(e);
        }
    }

    /**
     * 查询商户详情
     *
     * @param id 商户ID
     * @return R<MaTechnicianMerchantDetailVO> 商户详情
     */
    @ApiOperation("后台查询商户详情")
    @PreAuthorize("@ss.hasPermi('technician:technician:query')")
    @GetMapping("/merchant/detail/{id}")
    public R<MaTechnicianMerchantDetailVO> merchantDetail(@PathVariable("id") Long id) {
        try {
            return R.ok(maTechnicianService.selectMerchantDetail(id));
        } catch (Exception e) {
            e.printStackTrace();
            throw new RuntimeException(e);
        }
    }

    /**
     * 查看商户证照
     *
     * @param id 商户ID
     * @return R<MaTechnicianCertificateVO> 商户证照
     */
    @ApiOperation("后台查看商户证照")
    @PreAuthorize("@ss.hasPermi('technician:technician:query')")
    @GetMapping("/merchant/{id}/certificate")
    public R<MaTechnicianCertificateVO> merchantCertificate(@PathVariable("id") Integer id) {
        try {
            return R.ok(maTechnicianService.selectMerchantCertificate(id));
        } catch (Exception e) {
            e.printStackTrace();
            throw new RuntimeException(e);
        }
    }

    /**
     * 修改技师
     */
    @PreAuthorize("@ss.hasPermi('technician:technician:edit')")
    @Log(title = "技师", businessType = BusinessType.UPDATE)
    @PutMapping
    public AjaxResult edit(@RequestBody MaTechnicianAppAddVo maTechnicianAppAddVo) {
        return toAjax(maTechnicianService.updateMaTechnician(maTechnicianAppAddVo));
    }

    /**
     * 删除技师
     */
    @PreAuthorize("@ss.hasPermi('technician:technician:remove')")
    @Log(title = "技师", businessType = BusinessType.DELETE)
    @DeleteMapping("/{ids}")
    public AjaxResult remove(@PathVariable Long[] ids) {
        return toAjax(maTechnicianService.deleteMaTechnicianByIds(ids));
    }

    /**
     * 1. 获取服务类目列表
     */
    @GetMapping("/getServiceCategoryList")
    @ApiOperation("获取服务类目列表")
    public AjaxResult getServiceCategoryList() {
        List<ServiceCategory> list = serviceCategoryService.listH5ServiceCategory();
        return AjaxResult.success(list);
    }

    /**
     * 1. 获取技能列表
     *
     */
    @PostMapping("/getSkillList")
    @ApiOperation("获取技能列表")
    public Result<List<MaProject>> getSkillList(@RequestBody MaProjectGetVo req) {

        List<MaProject> list = maTechnicianService.selectMaTechnicianListBy(req.getUserId(), req.getAuditStatus());
        return Result.ok(list);
    }

    /**
     * 查询未开通的服务项目列表
     *
     * @param req
     * @return
     */
    @PostMapping("/getNotApplyList")
    @ApiOperation("查询未开通的服务项目列表")
    public Result<?> getNotApplyList(@RequestBody MaProjectGetVo req) {

        return Result.ok(maTechnicianService.getNotApplyList(req.getUserId(), req.getTypeId()));

    }

    /**
     * 申请开通新服务
     */
    @PostMapping("/applyForService")
    @ApiOperation("申请开通新服务")
    public AjaxResult applyForService(@RequestBody MaProjectSaveDto dto) {

        return toAjax(maTechnicianService.applyForService(dto));
    }

    /**
     * 重新申请开通新服务
     *
     * @param req
     * @return
     */
    @PostMapping("/updateApply")
    @ApiOperation("重新申请开通新服务")
    public Result<?> updateApply(@RequestBody MaProjectUpdateDto req) {
        if (StringUtils.isNotEmpty(req.getProjectId()) && StringUtils.isNotEmpty(req.getApplyReason())) {
            LambdaUpdateWrapper<MaProject> updateWrapper = new LambdaUpdateWrapper<>();
            updateWrapper.eq(MaProject::getId, req.getProjectId());
            updateWrapper.set(MaProject::getApplyReason, req.getApplyReason());
            updateWrapper.set(MaProject::getAuditStatus, 0);
            maProjectService.update(updateWrapper);
        }
        return Result.ok("重新申请成功,提交到审核阶段");

    }

    /**
     * 申请下架,删除服务项目,编辑售价价格
     *
     * @param req
     * @return
     */
    @PostMapping("/updateMaProject")
    @ApiOperation("申请下架,删除服务项目,编辑售价价格")
    public Result<?> updateMaProject(@RequestBody MaProjectUpdateDto req) {
        String message = "";
        if (StringUtils.isNotEmpty(req.getProjectId())) {
            if (req.getIsDelete()) {
                LambdaUpdateWrapper<MaProject> updateWrapper = new LambdaUpdateWrapper<>();
                updateWrapper.eq(MaProject::getProjectId, req.getProjectId());
                updateWrapper.set(MaProject::getIsDelete, 1);
                maProjectService.update(updateWrapper);
                message = "删除成功";
            }
            if (req.getIsPass()) {
                LambdaUpdateWrapper<MaProject> updateWrapper = new LambdaUpdateWrapper<>();
                updateWrapper.eq(MaProject::getId, req.getProjectId());
                updateWrapper.set(MaProject::getProjectIsEnable, 1);
                maProjectService.update(updateWrapper);
                message = "申请下架成功";
            }
            if (req.getProjectCurrentPrice() != null) {

                LambdaUpdateWrapper<MaProject> updateWrapper = new LambdaUpdateWrapper<>();
                updateWrapper.eq(MaProject::getId, req.getProjectId());
                updateWrapper.set(MaProject::getProjectCurrentPrice, req.getProjectCurrentPrice());
                maProjectService.update(updateWrapper);
                message = "修改价格完成";

            }
        }
        return Result.ok(message);
    }

    /**
     * 商户入驻信息
     *
     * @param userId
     * @return Result<?>
     */
    @GetMapping("/getTechnicianList")
    @ApiOperation("商户入驻信息")
    public Result<?> getTechnicianList(@RequestParam(value = "userId") Integer userId) {
        return Result.ok(maTechnicianService.getTechnicianList(userId));
    }

    /**
     * 查询商户合同记录信息
     *
     * @param userId
     * @return
     */

    @GetMapping("/getContractRecords")
    @ApiOperation("查询商户合同记录信息")
    public Result<?> getContractRecords(@RequestParam(value = "userId") Long userId) {
        return Result.ok(maTechnicianService.getContractRecords(userId));
    }

}