package cn.besteam.modules.medical.controller;

import cn.besteam.common.api.vo.Result;
import cn.besteam.common.aspect.annotation.AutoLog;
import cn.besteam.common.util.oConvertUtils;
import cn.besteam.common.util.UserContextUtil;
import cn.besteam.modules.medical.dto.MwMaterialDTO;
import cn.besteam.modules.medical.dto.MwMaterialQueryDTO;
import cn.besteam.modules.medical.entity.MwMaterial;
import cn.besteam.modules.medical.entity.MwMaterialCategory;
import cn.besteam.modules.medical.service.IMwMaterialCategoryService;
import cn.besteam.modules.medical.service.IMwMaterialService;
import cn.besteam.modules.shiro.authc.util.EnvUtils;
import cn.besteam.modules.system.entity.SysDepartment;
import cn.besteam.modules.system.service.ISysDepartmentService;
import cn.besteam.modules.system.util.MybatisParameterUtils;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import io.swagger.annotations.ApiParam;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

import javax.servlet.http.HttpServletRequest;
import javax.validation.Valid;
import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;

/**
 * @Description: 资料管理控制器
 * @author: besteam
 * @date: 2025-08-17
 */
@RestController
@RequestMapping("/medical/mwMaterial")
@Slf4j
@Api(tags = "【0729迭代】资料管理")
public class MwMaterialController {

    @Autowired
    private IMwMaterialService mwMaterialService;

    @Autowired
    private IMwMaterialCategoryService mwMaterialCategoryService;

    @Autowired
    private ISysDepartmentService sysDepartmentService;

    @Autowired
    private UserContextUtil userContextUtil;

    /**
     * 分页列表查询
     * @param queryDTO 查询条件
     * @return 分页结果
     */
    @GetMapping(value = "/list")
    @ApiOperation(value = "获取资料列表", notes = "获取资料列表")
    public Result<IPage<MwMaterial>> queryPageList(MwMaterialQueryDTO queryDTO) {
        
        Page<MwMaterial> page = new Page<>(queryDTO.getPageNo(), queryDTO.getPageSize());
        IPage<MwMaterial> pageList = mwMaterialService.selectPageList(page, queryDTO);
        
        return Result.ok(pageList);
    }

    /**
     * 添加资料
     * @param materialDTO 资料信息
     * @return 操作结果
     */
    @PostMapping(value = "/add")
    @AutoLog(value = "添加资料")
    @ApiOperation(value = "添加资料", notes = "添加资料", produces = "application/json")
    public Result<String> add(@RequestBody MwMaterialDTO materialDTO) {
        // 验证资料名称是否重复
        if (checkMaterialNameExists(materialDTO.getMaterialName(), materialDTO.getHospitalId(), null)) {
            return Result.error("资料名称已存在！");
        }
        
        MwMaterial material = new MwMaterial();
        BeanUtils.copyProperties(materialDTO, material);
        
        boolean success = mwMaterialService.saveMaterial(material);
        if (success) {
            return Result.ok("添加成功！");
        } else {
            return Result.error("添加失败！");
        }
    }

    /**
     * 编辑资料
     * @param materialDTO 资料信息
     * @return 操作结果
     */
    @PostMapping(value = "/edit")
    @AutoLog(value = "编辑资料")
    @ApiOperation(value = "编辑资料", notes = "编辑资料", produces = "application/json")
    public Result<String> edit(@RequestBody MwMaterialDTO materialDTO) {
        if (materialDTO.getId() == null) {
            return Result.error("ID不能为空！");
        }
        
        // 验证资料名称是否重复
        if (checkMaterialNameExists(materialDTO.getMaterialName(), materialDTO.getHospitalId(), materialDTO.getId())) {
            return Result.error("资料名称已存在！");
        }
        
        MwMaterial material = new MwMaterial();
        BeanUtils.copyProperties(materialDTO, material);
        
        boolean success = mwMaterialService.updateMaterial(material);
        if (success) {
            return Result.ok("修改成功！");
        } else {
            return Result.error("修改失败！");
        }
    }

    /**
     * 通过id删除
     * @param id 资料ID
     * @return 操作结果
     */
    @DeleteMapping(value = "/delete")
    @AutoLog(value = "删除资料")
    @ApiOperation(value = "删除资料", notes = "删除资料", produces = "application/json")
    public Result<String> delete(@RequestParam(name = "id", required = true) String id) {
        // 验证资料是否存在
        MwMaterial material = mwMaterialService.getById(Integer.parseInt(id));
        if (material == null) {
            return Result.error("资料不存在");
        }
        
        boolean success = mwMaterialService.deleteMaterial(Integer.parseInt(id));
        if (success) {
            return Result.ok("删除成功！");
        } else {
            return Result.error("删除失败！");
        }
    }

    /**
     * 批量删除
     * @param ids 资料ID数组
     * @return 操作结果
     */
    @DeleteMapping(value = "/deleteBatch")
    @AutoLog(value = "批量删除资料")
    @ApiOperation(value = "批量删除资料", notes = "批量删除资料", produces = "application/json")
    public Result<String> deleteBatch(@RequestParam(name = "ids", required = true) String ids) {
        if (oConvertUtils.isEmpty(ids)) {
            return Result.error("参数不识别！");
        }
        
        String[] idArray = ids.split(",");
        
        for (String id : idArray) {
            mwMaterialService.deleteMaterial(Integer.parseInt(id));
        }
        
        return Result.ok("批量删除成功！");
    }

    /**
     * 通过id查询
     * @param id 资料ID
     * @return 资料详情
     */
    @GetMapping(value = "/queryById")
    @ApiOperation(value = "通过ID查询资料", notes = "通过ID查询资料", produces = "application/json")
    public Result<MwMaterial> queryById(@RequestParam(name = "id", required = true) String id) {
        MwMaterial material = mwMaterialService.selectById(Integer.parseInt(id));
        if (material != null) {
            return Result.ok(material);
        } else {
            return Result.error("未找到对应实体");
        }
    }

    /**
     * 更新资料状态
     * @param id 资料ID
     * @param status 状态
     * @return 操作结果
     */
    @PostMapping(value = "/updateStatus")
    @AutoLog(value = "更新资料状态")
    @ApiOperation(value = "更新资料状态", notes = "更新资料状态", produces = "application/json")
    public Result<String> updateStatus(
            @RequestParam(name = "id", required = true) Integer id,
            @RequestParam(name = "status", required = true) Integer status) {
        
        MwMaterial material = mwMaterialService.getById(id);
        if (material == null) {
            return Result.error("未找到对应实体");
        }
        
        material.setStatus(status);
        material.setUpdateBy(EnvUtils.getUser().getName());
        boolean success = mwMaterialService.updateById(material);
        if (success) {
            return Result.ok("状态更新成功！");
        } else {
            return Result.error("状态更新失败！");
        }
    }

    /**
     * 获取医院列表
     * @return 医院列表
     */
    @GetMapping(value = "/getHospitals")
    @ApiOperation(value = "获取医院列表", notes = "获取医院列表", produces = "application/json")
    public Result<List<SysDepartment>> getHospitals() {
        QueryWrapper<SysDepartment> queryWrapper = new QueryWrapper<>();
        queryWrapper.eq("org_type", 2); // 2表示单位（医院）
        queryWrapper.eq("del_flag", 0);
        queryWrapper.orderByAsc("depart_order");
        
        List<SysDepartment> hospitals = sysDepartmentService.list(queryWrapper);
        return Result.ok(hospitals);
    }

    /**
     * 获取资料分类列表
     * @return 资料分类列表
     */
    @GetMapping(value = "/getMaterialCategories")
    @ApiOperation(value = "获取资料分类列表", notes = "获取资料分类列表", produces = "application/json")
    public Result<List<MwMaterialCategory>> getMaterialCategories() {
        LambdaQueryWrapper<MwMaterialCategory> queryWrapper = new LambdaQueryWrapper<>();

        SysDepartment currentUserDepartment = userContextUtil.getCurrentUserDepartment();
        if (currentUserDepartment.getOrgType().equals(1)) {
            List<SysDepartment> sysDepartments = sysDepartmentService.listMyHospital(userContextUtil.getCurrentUser().getId());
            List<Integer> hospitalIds = sysDepartments.stream().map(SysDepartment::getId).collect(Collectors.toList());
            try {
                MybatisParameterUtils.cutInParameter(queryWrapper, MwMaterialCategory::getHospitalId, hospitalIds);
            } catch (Exception e) {
                throw new RuntimeException(e);
            }
        } else {
            Integer currentUserHospitalId = userContextUtil.getCurrentUserHospitalId();
            queryWrapper.eq(MwMaterialCategory::getHospitalId, currentUserHospitalId);
        }
        queryWrapper.eq(MwMaterialCategory::getDelFlag, 0);
        queryWrapper.orderByAsc(MwMaterialCategory::getCreateTime);
        
        List<MwMaterialCategory> categories = mwMaterialCategoryService.list(queryWrapper);
        return Result.ok(categories);
    }

    /**
     * 检查资料名称是否重复
     * @param materialName 资料名称
     * @param hospitalId 医院ID
     * @param id 资料ID（编辑时传入）
     * @return 是否重复
     */
    @GetMapping(value = "/checkMaterialName")
    @ApiOperation(value = "检查资料名称是否重复", notes = "检查资料名称是否重复", produces = "application/json")
    public Result<Boolean> checkMaterialName(
            @RequestParam(name = "materialName", required = true) String materialName,
            @RequestParam(name = "hospitalId", required = true) Integer hospitalId,
            @RequestParam(name = "id", required = false) Integer id) {
        
        boolean exists = checkMaterialNameExists(materialName, hospitalId, id);
        return Result.ok(!exists);
    }

    /**
     * 检查资料名称是否存在
     * @param materialName 资料名称
     * @param hospitalId 医院ID
     * @param id 资料ID（编辑时传入）
     * @return 是否存在
     */
    private boolean checkMaterialNameExists(String materialName, Integer hospitalId, Integer id) {
        QueryWrapper<MwMaterial> queryWrapper = new QueryWrapper<>();
        queryWrapper.eq("material_name", materialName);
        queryWrapper.eq("hospital_id", hospitalId);
        queryWrapper.eq("del_flag", 0);
        
        if (id != null) {
            queryWrapper.ne("id", id);
        }
        
        int count = mwMaterialService.count(queryWrapper);
        return count > 0;
    }
}