package com.sckw.system.service;

import com.alibaba.fastjson2.JSON;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.sckw.core.exception.SystemException;
import com.sckw.core.model.page.PageResult;
import com.sckw.core.web.constant.HttpStatus;
import com.sckw.core.web.context.LoginUserHolder;
import com.sckw.system.model.KwsEnterprise;
import com.sckw.system.model.KwsPrinter;
import com.sckw.system.model.vo.req.PrinterPageReqVo;
import com.sckw.system.model.vo.req.PrinterSaveReqVo;
import com.sckw.system.model.vo.req.PrinterStatusReqVo;
import com.sckw.system.model.vo.res.PlatformEnterpriseResVo;
import com.sckw.system.model.vo.res.PrinterDetailResVo;
import com.sckw.system.model.vo.res.PrinterOptionResVo;
import com.sckw.system.model.vo.res.PrinterPageResVo;
import com.sckw.system.repository.KwsEnterpriseRepository;
import com.sckw.system.repository.KwsPrinterRepository;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.Date;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Map;
import java.util.Objects;
import java.util.Set;
import java.util.stream.Collectors;

/**
 * 打印机管理服务类
 * 负责打印机的增删改查、状态管理以及与企业信息的关联处理
 */
@Service
@RequiredArgsConstructor
@Slf4j
public class KwsPrinterManageService {

    private final KwsPrinterRepository kwsPrinterRepository;
    private final KwsEnterpriseRepository kwsEnterpriseRepository;

    /**
     * 分页查询打印机列表
     *
     * @param reqVo 分页查询请求参数，包含页码、页大小、打印机名称模糊匹配、企业名称模糊匹配
     * @return 分页结果集
     */
    public PageResult page(PrinterPageReqVo reqVo) {
        log.info("分页查询打印机列表，参数：{}", JSON.toJSONString(reqVo));
        // 根据企业名称解析出有权限查看的企业ID集合
        Set<Long> entIds = resolveQueryEntIds(reqVo.getEnterpriseName());
        if (entIds.isEmpty()) {
            // 如果没有可查询的企业ID，直接返回空结果
            return PageResult.build(reqVo.getPage(), reqVo.getPageSize(), 0L, Collections.emptyList());
        }
        // 执行数据库分页查询
        IPage<KwsPrinter> page = kwsPrinterRepository.pageQuery(reqVo.getPage(), reqVo.getPageSize(),
                reqVo.getPrinterName(), entIds);
        // 构建返回结果，填充企业名称等额外信息
        return PageResult.of(page, buildPageRes(page.getRecords()));
    }

    /**
     * 获取打印机详情
     *
     * @param id 打印机ID
     * @return 打印机详情响应对象
     */
    public PrinterDetailResVo detail(Long id) {
        log.info("获取打印机详情，id：{}", id);
        // 获取并校验打印机实体，同时检查权限
        KwsPrinter printer = getAndCheck(id);
        PrinterDetailResVo resVo = new PrinterDetailResVo();
        // 填充基本信息及企业名称
        fillBaseRes(printer, enterpriseNameMap(Collections.singleton(printer.getEntId())), resVo);
        return resVo;
    }

    /**
     * 新增打印机
     *
     * @param reqVo 新增请求参数
     */
    @Transactional(rollbackFor = Exception.class)
    public void add(PrinterSaveReqVo reqVo) {
        log.info("新增打印机，参数：{}", JSON.toJSONString(reqVo));
        // 校验请求参数合法性（非空、重复性、企业有效性等）
        validateSaveReq(reqVo, null);
        Date now = new Date();
        // 构建打印机实体对象
        KwsPrinter printer = new KwsPrinter()
                .setEntId(reqVo.getEntId())
                .setPrinterName(reqVo.getPrinterName())
                .setPrinterType(reqVo.getPrinterType())
                .setUsefulLife(reqVo.getUsefulLife())
                .setOnlineStatus(defaultOnlineStatus(reqVo.getOnlineStatus()))
                .setStatus(0) // 默认启用
                .setDelFlag(0) // 未删除
                .setCreateBy(LoginUserHolder.getUserId())
                .setCreateTime(now)
                .setUpdateBy(LoginUserHolder.getUserId())
                .setUpdateTime(now);
        // 保存至数据库，失败则抛出异常
        if (!kwsPrinterRepository.save(printer)) {
            throw new SystemException(HttpStatus.CRUD_FAIL_CODE, HttpStatus.INSERT_FAIL);
        }
    }

    /**
     * 更新打印机信息
     *
     * @param reqVo 更新请求参数
     */
    @Transactional(rollbackFor = Exception.class)
    public void update(PrinterSaveReqVo reqVo) {
        log.info("更新打印机信息，参数：{}", JSON.toJSONString(reqVo));
        if (reqVo.getId() == null) {
            throw new SystemException("打印机ID不能为空");
        }
        // 获取并校验原打印机数据及权限
        KwsPrinter printer = getAndCheck(reqVo.getId());
        // 校验更新参数的合法性
        validateSaveReq(reqVo, printer.getId());
        // 更新字段
        printer.setEntId(reqVo.getEntId());
        printer.setPrinterName(reqVo.getPrinterName());
        printer.setPrinterType(reqVo.getPrinterType());
        printer.setUsefulLife(reqVo.getUsefulLife());
        printer.setOnlineStatus(defaultOnlineStatus(reqVo.getOnlineStatus()));
        printer.setUpdateBy(LoginUserHolder.getUserId());
        printer.setUpdateTime(new Date());
        // 执行更新操作
        if (!kwsPrinterRepository.updateById(printer)) {
            throw new SystemException(HttpStatus.CRUD_FAIL_CODE, HttpStatus.UPDATE_FAIL);
        }
    }

    /**
     * 更新打印机状态（启用/停用）
     *
     * @param reqVo 状态更新请求参数
     */
    @Transactional(rollbackFor = Exception.class)
    public void updateStatus(PrinterStatusReqVo reqVo) {
        log.info("更新打印机状态，参数：{}", JSON.toJSONString(reqVo));
        if (reqVo.getId() == null) {
            throw new SystemException("打印机ID不能为空");
        }
        // 校验状态值是否合法（0:启用, 1:停用）
        if (!Objects.equals(reqVo.getStatus(), 0) && !Objects.equals(reqVo.getStatus(), 1)) {
            throw new SystemException("打印机状态值非法");
        }
        // 获取并校验打印机及权限
        KwsPrinter printer = getAndCheck(reqVo.getId());
        printer.setStatus(reqVo.getStatus());
        printer.setUpdateBy(LoginUserHolder.getUserId());
        printer.setUpdateTime(new Date());
        // 执行更新操作
        if (!kwsPrinterRepository.updateById(printer)) {
            throw new SystemException(HttpStatus.CRUD_FAIL_CODE, HttpStatus.UPDATE_FAIL);
        }
    }

    /**
     * 获取企业下拉选项列表
     * 根据用户权限返回可见的企业列表，支持名称模糊搜索
     *
     * @param keyword 企业名称关键字
     * @return 企业选项列表
     */
    public List<PlatformEnterpriseResVo> enterpriseOptions(String keyword) {
        log.info("获取企业下拉选项列表，参数：{}", keyword);
        // 获取当前用户有权限访问的企业ID集合
        Set<Long> authEntIds = resolveAuthorizedEntIds();
        List<KwsEnterprise> enterpriseList;
        if (LoginUserHolder.isManager()) {
            // 管理员可查看所有企业
            enterpriseList = kwsEnterpriseRepository.queryByEntIdAndName(null, keyword);
        } else if (authEntIds.isEmpty()) {
            // 普通用户若无授权企业，返回空列表
            return Collections.emptyList();
        } else {
            // 普通用户仅查看授权范围内的企业
            enterpriseList = kwsEnterpriseRepository.queryByEntIds(authEntIds, keyword);
        }
        // 转换为响应VO
        return enterpriseList.stream().map(item -> {
            PlatformEnterpriseResVo resVo = new PlatformEnterpriseResVo();
            resVo.setId(item.getId());
            resVo.setFirmName(item.getFirmName());
            return resVo;
        }).toList();
    }

    /**
     * 根据企业ID获取打印机下拉选项列表
     *
     * @param entId 企业ID
     * @return 打印机选项列表
     */
    public List<PrinterOptionResVo> optionByEntId(Long entId) {
        log.info("根据企业ID获取打印机下拉选项列表，参数：{}", entId);
        // 校验企业是否存在及当前用户是否有该企业权限
        checkEnterprise(entId);
        // 查询该企业下的所有打印机并转换为VO
        return kwsPrinterRepository.listByEntId(entId).stream().map(item -> {
            PrinterOptionResVo resVo = new PrinterOptionResVo();
            resVo.setId(item.getId());
            resVo.setPrinterName(item.getPrinterName());
            return resVo;
        }).toList();
    }

    /**
     * 构建分页响应数据列表
     *
     * @param records 数据库查询出的打印机实体列表
     * @return 分页响应VO列表
     */
    private List<PrinterPageResVo> buildPageRes(List<KwsPrinter> records) {
        if (records == null || records.isEmpty()) {
            return Collections.emptyList();
        }
        // 批量获取企业名称映射，避免N+1查询问题
        Map<Long, String> entNameMap = enterpriseNameMap(records.stream().map(KwsPrinter::getEntId).collect(Collectors.toSet()));
        List<PrinterPageResVo> result = new ArrayList<>(records.size());
        for (KwsPrinter record : records) {
            PrinterPageResVo resVo = new PrinterPageResVo();
            fillBaseRes(record, entNameMap, resVo);
            result.add(resVo);
        }
        return result;
    }

    /**
     * 填充打印机基础响应信息
     *
     * @param record     打印机实体
     * @param entNameMap 企业ID到企业名称的映射
     * @param resVo      待填充的响应VO
     */
    private void fillBaseRes(KwsPrinter record, Map<Long, String> entNameMap, PrinterPageResVo resVo) {
        resVo.setId(record.getId());
        resVo.setEntId(record.getEntId());
        resVo.setEnterpriseName(entNameMap.getOrDefault(record.getEntId(), ""));
        resVo.setPrinterName(record.getPrinterName());
        resVo.setPrinterType(record.getPrinterType());
        resVo.setUsefulLife(record.getUsefulLife());
        resVo.setOnlineStatus(record.getOnlineStatus());
        // 转换在线状态显示文本
        resVo.setOnlineStatusName(Objects.equals(record.getOnlineStatus(), 1) ? "在线" : "离线");
        resVo.setStatus(record.getStatus());
        // 转换启用状态显示文本
        resVo.setStatusName(Objects.equals(record.getStatus(), 0) ? "启用" : "停用");
        resVo.setCreateTime(record.getCreateTime());
        resVo.setUpdateTime(record.getUpdateTime());
    }

    /**
     * 校验保存请求参数
     *
     * @param reqVo     请求参数
     * @param excludeId 排除的ID（用于更新时排除自身）
     */
    private void validateSaveReq(PrinterSaveReqVo reqVo, Long excludeId) {
        if (reqVo.getEntId() == null) {
            throw new SystemException("所属企业不能为空");
        }
        if (StringUtils.isBlank(reqVo.getPrinterName())) {
            throw new SystemException("打印机名称不能为空");
        }
        // 校验企业有效性及权限
        checkEnterprise(reqVo.getEntId());
        // 检查同一企业下打印机名称是否重复
        KwsPrinter exists = kwsPrinterRepository.findByEntIdAndName(reqVo.getEntId(), reqVo.getPrinterName().trim());
        if (exists != null && !Objects.equals(exists.getId(), excludeId)) {
            throw new SystemException("同一企业下打印机名称不能重复");
        }
    }

    /**
     * 校验企业有效性及当前用户操作权限
     *
     * @param entId 企业ID
     */
    private void checkEnterprise(Long entId) {
        // 判断是否有操作该企业的权限：管理员或授权企业列表中包含该企业
        boolean allowed = LoginUserHolder.isManager() || resolveAuthorizedEntIds().contains(entId);
        if (!allowed) {
            throw new SystemException("没有当前企业的操作权限");
        }
        // 校验企业是否存在、未删除且状态正常
        KwsEnterprise enterprise = kwsEnterpriseRepository.getById(entId);
        if (enterprise == null || Objects.equals(enterprise.getDelFlag(), 1) || Objects.equals(enterprise.getStatus(), 1)) {
            throw new SystemException(HttpStatus.ENT_NOT_EXISTS);
        }
    }

    /**
     * 获取打印机实体并校验权限
     *
     * @param id 打印机ID
     * @return 打印机实体
     */
    private KwsPrinter getAndCheck(Long id) {
        // 查询可用的打印机记录
        KwsPrinter printer = kwsPrinterRepository.findAvailableById(id);
        if (printer == null) {
            throw new SystemException("打印机不存在");
        }
        // 非管理员需校验是否拥有该打印机所属企业的权限
        if (!LoginUserHolder.isManager() && !resolveAuthorizedEntIds().contains(printer.getEntId())) {
            throw new SystemException("没有当前打印机的操作权限");
        }
        return printer;
    }

    /**
     * 获取企业ID到企业名称的映射
     *
     * @param entIds 企业ID集合
     * @return 映射Map
     */
    private Map<Long, String> enterpriseNameMap(Collection<Long> entIds) {
        if (entIds == null || entIds.isEmpty()) {
            return Collections.emptyMap();
        }
        return kwsEnterpriseRepository.listByIds(entIds).stream()
                .collect(Collectors.toMap(KwsEnterprise::getId, KwsEnterprise::getFirmName, (a, b) -> a));
    }

    /**
     * 解析查询条件中的企业ID集合
     * 根据用户权限和输入的企业名称关键字，筛选出符合条件的企业ID
     *
     * @param enterpriseName 企业名称关键字
     * @return 企业ID集合
     */
    private Set<Long> resolveQueryEntIds(String enterpriseName) {
        Set<Long> authEntIds = resolveAuthorizedEntIds();
        List<KwsEnterprise> enterpriseList;
        if (LoginUserHolder.isManager()) {
            // 管理员可根据名称全局搜索
            enterpriseList = kwsEnterpriseRepository.queryByEntIdAndName(null, enterpriseName);
        } else if (authEntIds.isEmpty()) {
            // 无授权企业则返回空集合
            return Collections.emptySet();
        } else {
            // 普通用户在授权范围内根据名称搜索
            enterpriseList = kwsEnterpriseRepository.queryByEntIds(authEntIds, enterpriseName);
        }
        // 提取ID并保持顺序
        return enterpriseList.stream().map(KwsEnterprise::getId).collect(Collectors.toCollection(LinkedHashSet::new));
    }

    /**
     * 解析当前用户有权限访问的企业ID集合
     * 包括：用户所属企业、授权企业列表、子企业列表
     * 如果是管理员，返回空集合表示无限制（具体逻辑视业务而定，此处空集合通常代表全选或特殊标记）
     *
     * @return 企业ID集合
     */
    private Set<Long> resolveAuthorizedEntIds() {
        if (LoginUserHolder.isManager()) {
            return Collections.emptySet();
        }
        Set<Long> result = new LinkedHashSet<>();
        if (LoginUserHolder.getEntId() != null) {
            result.add(LoginUserHolder.getEntId());
        }
        result.addAll(LoginUserHolder.getAuthEntIdList());
        result.addAll(LoginUserHolder.getChildEntList());
        return result;
    }

    /**
     * 获取默认的在线状态
     * 如果传入为1则在线，否则默认离线(0)
     *
     * @param onlineStatus 传入的在线状态
     * @return 标准化后的在线状态
     */
    private Integer defaultOnlineStatus(Integer onlineStatus) {
        return Objects.equals(onlineStatus, 1) ? 1 : 0;
    }
}
