package com.ylx.web.controller.massage;


import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.ylx.common.annotation.Log;
import com.ylx.common.core.domain.R;
import com.ylx.common.enums.BusinessType;
import com.ylx.common.exception.ServiceException;
import com.ylx.common.utils.SecurityUtils;
import com.ylx.common.utils.StringUtils;
import com.ylx.massage.domain.Alarm;
import com.ylx.massage.service.AlarmService;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.*;

import javax.annotation.Resource;
import java.util.Date;

/**
 * 告警工单表控制层
 *
 * @author makejava
 * @since 2024-04-28 09:19:04
 */
@RestController
@RequestMapping("alarm")
@Api(tags = {"告警工单"})
public class AlarmController {
    /**
     * 服务对象
     */
    @Resource
    private AlarmService alarmService;

    /**
     * 分页查询告警记录
     *
     * @param page 分页对象
     * @param alarm 筛选条件
     * @return R 查询结果
     */
    @GetMapping("getAlarmList")
    @ApiOperation("分页查询告警记录")
    public R queryByPage(Page<Alarm> page, Alarm alarm) {
        try {
            LambdaQueryWrapper<Alarm> alarmLambdaQueryWrapper = buildAlarmQueryWrapper(alarm);
            Page<Alarm> pageSelect = alarmService.page(page, alarmLambdaQueryWrapper);
            return R.ok(pageSelect);
        } catch (Exception e) {
            e.printStackTrace();
            throw new RuntimeException(e);
        }
    }

    /**
     * 构建告警记录查询条件
     * @param alarm
     * @return LambdaQueryWrapper<Alarm>
     */
    private LambdaQueryWrapper<Alarm> buildAlarmQueryWrapper(Alarm alarm) {
        LambdaQueryWrapper<Alarm> wrapper = new LambdaQueryWrapper<>();
        wrapper.eq(null != alarm.getAlarmStatus(), Alarm::getAlarmStatus, alarm.getAlarmStatus())
                .like(StringUtils.isNotBlank(alarm.getMerchantName()), Alarm::getMerchantName, alarm.getMerchantName())
                .like(StringUtils.isNotBlank(alarm.getMerchantNickName()), Alarm::getMerchantNickName, alarm.getMerchantNickName())
                .eq(null != alarm.getMerchantSex(), Alarm::getMerchantSex, alarm.getMerchantSex())
                .like(StringUtils.isNotBlank(alarm.getMerchantPhone()), Alarm::getMerchantPhone, alarm.getMerchantPhone())
                .ge(StringUtils.isNotBlank(alarm.getBeginTime()), Alarm::getCreateTime, normalizeBeginTime(alarm.getBeginTime()))
                .le(StringUtils.isNotBlank(alarm.getEndTime()), Alarm::getCreateTime, normalizeEndTime(alarm.getEndTime()))
                .orderByDesc(Alarm::getCreateTime);
        return wrapper;
    }

    /**
     * 格式化开始时间
     * @param beginTime
     * @return String 格式化后的开始时间
     */
    private String normalizeBeginTime(String beginTime) {
        if (StringUtils.isBlank(beginTime)) {
            return null;
        }
        String value = beginTime.trim();
        return value.length() == 10 ? value + " 00:00:00" : value;
    }

    /**
     * 格式化结束时间
     * @param endTime
     * @return String 格式化后的结束时间
     */
    private String normalizeEndTime(String endTime) {
        if (StringUtils.isBlank(endTime)) {
            return null;
        }
        String value = endTime.trim();
        return value.length() == 10 ? value + " 23:59:59" : value;
    }

    /**
     * 通过主键查询单条数据
     *
     * @param id 主键
     * @return 单条数据
     */
    @GetMapping("{id}")
    public ResponseEntity<Alarm> queryById(@PathVariable("id") String id) {
        return ResponseEntity.ok(this.alarmService.queryById(id));
    }


    /**
     * 处理告警工单
     * @param alarm
     * @return R
     */
    @PostMapping("/handleAlarm")
    @ApiOperation("已处理")
    @Log(title = "处理告警工单", businessType = BusinessType.UPDATE)
    public R handleAlarm(@RequestBody Alarm alarm) {
        try {
            if (StringUtils.isBlank(alarm.getId())) {
                throw new ServiceException("id不能为空");
            }
            if (StringUtils.isBlank(alarm.getNote())) {
                throw new ServiceException("处理过程及结果不能为空");
            }

            String handleResult = alarm.getNote().trim();
            if (handleResult.length() > 128) {
                throw new ServiceException("处理过程及结果不能超过128个字符");
            }

            Alarm existAlarm = alarmService.getById(alarm.getId());
            if (existAlarm == null) {
                throw new ServiceException("告警工单不存在");
            }
            if (Integer.valueOf(1).equals(existAlarm.getAlarmStatus())) {
                throw new ServiceException("告警工单已处理，请勿重复处理");
            }

            Alarm updateAlarm = new Alarm()
                    .setId(alarm.getId())
                    .setAlarmStatus(1)
                    .setNote(handleResult)
                    .setUpdateBy(SecurityUtils.getUsername())
                    .setUpdateTime(new Date());
            boolean updateResult = alarmService.updateById(updateAlarm);
            if (!updateResult) {
                throw new ServiceException("处理告警工单失败");
            }
            return R.ok();
        } catch (ServiceException e) {
            e.printStackTrace();
            throw new RuntimeException(e);
        }
    }
}