package com.yeqifu.bus.controller;


import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.yeqifu.bus.entity.Goods;
import com.yeqifu.bus.entity.Provider;
import com.yeqifu.bus.service.IGoodsService;
import com.yeqifu.bus.service.IProviderService;
import com.yeqifu.bus.vo.GoodsVo;
import com.yeqifu.sys.common.AppFileUtils;
import com.yeqifu.sys.common.Constast;
import com.yeqifu.sys.common.DataGridView;
import com.yeqifu.sys.common.ResultObj;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import java.util.List;

/**
 * <p>
 * InnoDB free: 9216 kB; (`providerid`) REFER `warehouse/bus_provider`(`id`) 前端商品控制器
 * </p>
 *
 * @author luoyi-
 * @since 2019-12-06
 */
@RestController
@RequestMapping("/goods")
public class GoodsController {

    @Autowired
    private IGoodsService goodsService;

    @Autowired
    private IProviderService providerService;

    /**
     * 查询商品
     * @param goodsVo 包含查询条件和分页信息的商品值对象
     * @return DataGridView 包含分页数据和总记录数的数据视图对象
     */
    @RequestMapping("loadAllGoods")
    public DataGridView loadAllGoods(GoodsVo goodsVo){
        // 创建分页对象，根据传入的页码和每页记录数初始化
        IPage<Goods> page = new Page<Goods>(goodsVo.getPage(),goodsVo.getLimit());
        // 创建查询包装器，用于构建查询条件
        QueryWrapper<Goods> queryWrapper = new QueryWrapper<Goods>();
        // 根据 providerid 进行精确查询，当 providerid 不为空且不为 0 时添加条件
        queryWrapper.eq(goodsVo.getProviderid()!=null&&goodsVo.getProviderid()!=0,"providerid",goodsVo.getProviderid());
        // 根据商品名称进行模糊查询，当商品名称不为空时添加条件
        queryWrapper.like(StringUtils.isNotBlank(goodsVo.getGoodsname()),"goodsname",goodsVo.getGoodsname());
        // 根据产品代码进行模糊查询，当产品代码不为空时添加条件
        queryWrapper.like(StringUtils.isNotBlank(goodsVo.getProductcode()),"productcode",goodsVo.getProductcode());
        // 根据许可代码进行模糊查询，当许可代码不为空时添加条件
        queryWrapper.like(StringUtils.isNotBlank(goodsVo.getPromitcode()),"promitcode",goodsVo.getPromitcode());
        // 根据商品描述进行模糊查询，当商品描述不为空时添加条件
        queryWrapper.like(StringUtils.isNotBlank(goodsVo.getDescription()),"description",goodsVo.getDescription());
        // 根据商品尺寸进行模糊查询，当商品尺寸不为空时添加条件
        queryWrapper.like(StringUtils.isNotBlank(goodsVo.getSize()),"size",goodsVo.getSize());
        // 按照 id 降序排序
        queryWrapper.orderByDesc("id");
        // 调用服务层进行分页查询
        goodsService.page(page,queryWrapper);
        List<Goods> records = page.getRecords();
        // 遍历查询结果，为每个商品设置供应商名称
        for (Goods goods : records) {
            Provider provider = providerService.getById(goods.getProviderid());
            if (null!=provider){
                goods.setProvidername(provider.getProvidername());
            }
        }
        // 将查询结果封装到 DataGridView 中并返回
        return new DataGridView(page.getTotal(),page.getRecords());
    }

    /**
     * 添加商品
     * @param goodsVo 包含要添加的商品信息的值对象
     * @return ResultObj 操作结果对象，指示添加操作是否成功
     */
    @RequestMapping("addGoods")
    public ResultObj addGoods(GoodsVo goodsVo){
        try {
            System.out.println("====================================");
            System.out.println(goodsVo.getGoodsimg());
            // 当商品图片不为空且以 "_temp" 结尾时，重命名文件
            if (goodsVo.getGoodsimg()!=null&&goodsVo.getGoodsimg().endsWith("_temp")){
                String newName = AppFileUtils.renameFile(goodsVo.getGoodsimg());
                goodsVo.setGoodsimg(newName);
            }
            // 调用服务层保存商品信息
            goodsService.save(goodsVo);
            // 保存成功，返回添加成功结果对象
            return ResultObj.ADD_SUCCESS;
        } catch (Exception e) {
            // 打印异常信息
            e.printStackTrace();
            // 保存失败，返回添加失败结果对象
            return ResultObj.ADD_ERROR;
        }
    }

    /**
     * 修改商品
     * @param goodsVo 包含要修改的商品信息的值对象
     * @return ResultObj 操作结果对象，指示修改操作是否成功
     */
    @RequestMapping("updateGoods")
    public ResultObj updateGoods(GoodsVo goodsVo){
        try {
            //商品图片不是默认图片
            if (!(goodsVo.getGoodsimg()!=null&&goodsVo.getGoodsimg().equals(Constast.DEFAULT_IMG_GOODS))){
                // 当商品图片以 "_temp" 结尾时，重命名文件
                if (goodsVo.getGoodsimg().endsWith("_temp")){
                    String newName = AppFileUtils.renameFile(goodsVo.getGoodsimg());
                    goodsVo.setGoodsimg(newName);
                    //删除原先的图片
                    String oldPath = goodsService.getById(goodsVo.getId()).getGoodsimg();
                    AppFileUtils.removeFileByPath(oldPath);
                }
            }
            // 调用服务层更新商品信息
            goodsService.updateById(goodsVo);
            // 更新成功，返回更新成功结果对象
            return ResultObj.UPDATE_SUCCESS;
        } catch (Exception e) {
            // 打印异常信息
            e.printStackTrace();
            // 更新失败，返回更新失败结果对象
            return ResultObj.UPDATE_ERROR;
        }
    }

    /**
     * 删除商品
     * @param id       商品 id
     * @param goodsimg 商品图片路径
     * @return ResultObj 操作结果对象，指示删除操作是否成功
     */
    @RequestMapping("deleteGoods")
    public ResultObj deleteGoods(Integer id,String goodsimg){
        try {
            //删除商品的图片
            AppFileUtils.removeFileByPath(goodsimg);
            //goodsService.removeById(id);
            // 调用服务层删除商品信息
            goodsService.deleteGoodsById(id);
            // 删除成功，返回删除成功结果对象
            return ResultObj.DELETE_SUCCESS;
        } catch (Exception e) {
            // 打印异常信息
            e.printStackTrace();
            // 删除失败，返回删除失败结果对象
            return ResultObj.DELETE_ERROR;
        }
    }

    /**
     * 加载所有可用的商品
     * @return DataGridView 包含可用商品列表的数据视图对象
     */
    @RequestMapping("loadAllGoodsForSelect")
    public DataGridView loadAllGoodsForSelect(){
        // 创建查询包装器，用于构建查询条件
        QueryWrapper<Goods> queryWrapper = new QueryWrapper<Goods>();
        // 查询条件为 available 字段等于可用状态常量
        queryWrapper.eq("available",Constast.AVAILABLE_TRUE);
        List<Goods> list = goodsService.list(queryWrapper);
        // 遍历商品列表，为每个商品设置供应商名称
        for (Goods goods : list) {
            Provider provider = providerService.getById(goods.getProviderid());
            if (null!=provider){
                goods.setProvidername(provider.getProvidername());
            }
        }
        // 将查询结果封装到 DataGridView 中并返回
        return new DataGridView(list);
    }

    /**
     * 根据供应商ID查询商品信息
     * @param providerid 供应商 ID
     * @return DataGridView 包含符合条件的商品列表的数据视图对象
     */
    @RequestMapping("loadGoodsByProviderId")
    public DataGridView loadGoodsByProviderId(Integer providerid){
        // 创建查询包装器，用于构建查询条件
        QueryWrapper<Goods> queryWrapper = new QueryWrapper<Goods>();
        // 查询条件为 available 字段等于可用状态常量，且 providerid 等于传入的供应商 ID
        queryWrapper.eq("available",Constast.AVAILABLE_TRUE);
        queryWrapper.eq(providerid!=null,"providerid",providerid);
        List<Goods> list = goodsService.list(queryWrapper);
        // 遍历商品列表，为每个商品设置供应商名称
        for (Goods goods : list) {
            Provider provider = providerService.getById(goods.getProviderid());
            if (null!=provider){
                goods.setProvidername(provider.getProvidername());
            }
        }
        // 将查询结果封装到 DataGridView 中并返回
        return new DataGridView(list);
    }

    /**
     * 加载所有预警商品
     *
     * @return DataGridView 包含预警商品列表的数据视图对象
     */
    @RequestMapping("loadAllWarningGoods")
    public DataGridView loadAllWarningGoods(){
        // 调用服务层加载所有预警商品
        List<Goods> goods = goodsService.loadAllWarning();
        // 将结果封装到 DataGridView 中并返回，包含商品列表的大小和商品列表
        return new DataGridView((long) goods.size(),goods);
    }



}

