package com.ruoyi.device.service.impl;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.ruoyi.common.exception.ServiceException;
import com.ruoyi.device.mapper.MaintenanceItemMapper;
import com.ruoyi.device.pojo.MaintenanceItem;
import com.ruoyi.device.service.MaintenanceItemService;
import lombok.RequiredArgsConstructor;
import org.apache.commons.lang3.StringUtils;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.util.List;

@Service
@RequiredArgsConstructor
public class MaintenanceItemServiceImpl
        extends ServiceImpl<MaintenanceItemMapper, MaintenanceItem>
        implements MaintenanceItemService {

    private static final List<String> VALID_FREQUENCIES = List.of(
            "DAILY",
            "WEEKLY",
            "MONTHLY",
            "QUARTERLY",
            "ALL"
    );

    private final MaintenanceItemMapper maintenanceItemMapper;

    @Override
    public List<MaintenanceItem> listActive() {
        return list(new LambdaQueryWrapper<MaintenanceItem>()
                .eq(MaintenanceItem::getDeleted, 0)
                .eq(MaintenanceItem::getIsActive, 1)
                .orderByAsc(MaintenanceItem::getSortNum)
                .orderByAsc(MaintenanceItem::getId));
    }

    @Override
    public List<MaintenanceItem> list(MaintenanceItem query) {
        LambdaQueryWrapper<MaintenanceItem> wrapper = buildQueryWrapper(query, false)
                .orderByDesc(MaintenanceItem::getId);
        return maintenanceItemMapper.selectList(wrapper);
    }

    @Override
    public Page<MaintenanceItem> page(
            long pageNum,
            long pageSize,
            boolean includeCommon,
            MaintenanceItem query
    ) {
        long safePageNum = Math.max(pageNum, 1);
        long safePageSize = Math.min(Math.max(pageSize, 1), 100);

        LambdaQueryWrapper<MaintenanceItem> wrapper = buildQueryWrapper(query, includeCommon)
                .orderByAsc(MaintenanceItem::getSortNum)
                .orderByAsc(MaintenanceItem::getId);
        return maintenanceItemMapper.selectPage(new Page<>(safePageNum, safePageSize), wrapper);
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public void createItem(MaintenanceItem item) {
        if (!isValid(item)) {
            throw new ServiceException("保养项目、保养内容和频率不能为空或无效");
        }

        normalize(item);
        item.setDeleted(0);
        if (existsName(item, null)) {
            throw new ServiceException("该设备和频率下已存在同名保养内容");
        }

        if (maintenanceItemMapper.insert(item) <= 0) {
            throw new ServiceException("新增保养项目失败");
        }
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public void updateItem(MaintenanceItem item) {
        if (item == null || item.getId() == null || !isValid(item)) {
            throw new ServiceException("保养项目、保养内容和频率不能为空或无效");
        }

        MaintenanceItem existingItem = maintenanceItemMapper.selectById(item.getId());
        if (existingItem == null || Integer.valueOf(1).equals(existingItem.getDeleted())) {
            throw new ServiceException("保养项目不存在");
        }

        normalize(item);
        if (existsName(item, item.getId())) {
            throw new ServiceException("该设备和频率下已存在同名保养内容");
        }

        existingItem.setItemProject(item.getItemProject());
        existingItem.setItemName(item.getItemName());
        existingItem.setDeviceLedgerId(item.getDeviceLedgerId());
        existingItem.setFrequencyType(item.getFrequencyType());
        existingItem.setSortNum(item.getSortNum() == null ? 0 : item.getSortNum());
        existingItem.setIsActive(item.getIsActive() == null ? existingItem.getIsActive() : item.getIsActive());
        existingItem.setRemarks(item.getRemarks());

        if (maintenanceItemMapper.updateById(existingItem) <= 0) {
            throw new ServiceException("修改保养项目失败");
        }
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public void deleteItem(Long id) {
        if (id == null) {
            throw new ServiceException("保养项目编号不能为空");
        }

        MaintenanceItem item = maintenanceItemMapper.selectById(id);
        if (item == null || Integer.valueOf(1).equals(item.getDeleted())) {
            throw new ServiceException("保养项目不存在");
        }

        item.setDeleted(1);
        item.setIsActive(0);
        if (maintenanceItemMapper.updateById(item) <= 0) {
            throw new ServiceException("删除保养项目失败");
        }
    }

    private LambdaQueryWrapper<MaintenanceItem> buildQueryWrapper(
            MaintenanceItem query,
            boolean includeCommon
    ) {
        MaintenanceItem filter = query == null ? new MaintenanceItem() : query;
        LambdaQueryWrapper<MaintenanceItem> wrapper = new LambdaQueryWrapper<MaintenanceItem>()
                .eq(MaintenanceItem::getDeleted, 0);

        if (StringUtils.isNotBlank(filter.getItemName())) {
            wrapper.like(MaintenanceItem::getItemName, filter.getItemName().trim());
        }
        if (StringUtils.isNotBlank(filter.getItemProject())) {
            wrapper.like(MaintenanceItem::getItemProject, filter.getItemProject().trim());
        }
        if (filter.getIsActive() != null) {
            wrapper.eq(MaintenanceItem::getIsActive, filter.getIsActive());
        }
        if (filter.getDeviceLedgerId() != null) {
            if (includeCommon) {
                wrapper.and(condition -> condition
                        .eq(MaintenanceItem::getDeviceLedgerId, filter.getDeviceLedgerId())
                        .or()
                        .isNull(MaintenanceItem::getDeviceLedgerId));
            } else {
                wrapper.eq(MaintenanceItem::getDeviceLedgerId, filter.getDeviceLedgerId());
            }
        }
        if (StringUtils.isNotBlank(filter.getFrequencyType())) {
            if (includeCommon) {
                wrapper.and(condition -> condition
                        .eq(MaintenanceItem::getFrequencyType, filter.getFrequencyType())
                        .or()
                        .eq(MaintenanceItem::getFrequencyType, "ALL"));
            } else {
                wrapper.eq(MaintenanceItem::getFrequencyType, filter.getFrequencyType());
            }
        }

        return wrapper;
    }

    private boolean isValid(MaintenanceItem item) {
        return item != null
                && StringUtils.isNotBlank(item.getItemProject())
                && StringUtils.isNotBlank(item.getItemName())
                && StringUtils.isNotBlank(item.getFrequencyType())
                && VALID_FREQUENCIES.contains(item.getFrequencyType());
    }

    private void normalize(MaintenanceItem item) {
        item.setItemProject(item.getItemProject().trim());
        item.setItemName(item.getItemName().trim());
        item.setSortNum(item.getSortNum() == null ? 0 : item.getSortNum());
        item.setIsActive(item.getIsActive() == null ? 1 : item.getIsActive());
    }

    private boolean existsName(MaintenanceItem item, Long excludedId) {
        LambdaQueryWrapper<MaintenanceItem> wrapper = new LambdaQueryWrapper<MaintenanceItem>()
                .eq(MaintenanceItem::getDeleted, 0)
                .eq(MaintenanceItem::getItemName, item.getItemName())
                .eq(MaintenanceItem::getFrequencyType, item.getFrequencyType());

        if (item.getDeviceLedgerId() == null) {
            wrapper.isNull(MaintenanceItem::getDeviceLedgerId);
        } else {
            wrapper.eq(MaintenanceItem::getDeviceLedgerId, item.getDeviceLedgerId());
        }
        if (excludedId != null) {
            wrapper.ne(MaintenanceItem::getId, excludedId);
        }

        return maintenanceItemMapper.selectCount(wrapper) > 0;
    }
}