package com.kxs.product.biz.controller.kxsapp;

import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.kxs.common.core.constant.enums.MachineTypeEnum;
import com.kxs.common.core.util.R;
import com.kxs.common.security.annotation.Inner;
import com.kxs.product.api.dto.kxsapp.machine.*;
import com.kxs.product.api.model.KxsMachine;
import com.kxs.product.api.model.KxsTicket;
import com.kxs.product.api.vo.kxsapp.machine.*;
import com.kxs.product.biz.service.KxsBrandService;
import com.kxs.product.biz.service.KxsMachineService;
import com.kxs.product.biz.service.KxsMachineTransferService;
import jakarta.validation.Valid;
import lombok.RequiredArgsConstructor;
import org.springdoc.core.annotations.ParameterObject;
import org.springframework.web.bind.annotation.*;

/**
 * 仓库模块(Machine)控制层
 *
 * @author 系统
 * @since 2024-01-04 16:20:14
 */
@RestController
@RequiredArgsConstructor
@RequestMapping("machine")
public class MachineController {

    /**
     * 服务对象
     */
    private final KxsMachineService kxsMachineService;
    private final KxsBrandService kxsBrandService;
    private final KxsMachineTransferService kxsMachineTransferService;



    /**
     * 可循环机列表
     *
     * @param page 分页对象
     * @return 可循环机列表
     */
    @GetMapping("/recycleMachines")
    public R recycleMachines(@ParameterObject Page<RecycleMachinesVO> page, @RequestParam("brandId") Integer brandId ) {

        return R.ok(kxsMachineService.recycleMachinesPage(page, brandId));
    }


    /**
     * 申请机具说明
     *
     * @return 申请机具说明
     */
    @GetMapping("/applyRemark")
    public R applyRemark() {

        return R.ok(kxsMachineService.applyRemark());
    }


    /**
     * 未绑定机具列表
     *
     * @param page 分页对象
     * @param param 查询实体
     * @return 未绑定机具列表
     */
    @GetMapping("/machineUnBindList")
    public R machineUnBindList(@ParameterObject Page<MachineUnBindListVO> page, @Valid @ParameterObject MachineUserListDTO param) {

        return R.ok(kxsMachineService.machineUnBindListPage(page, param));
    }


    /**
     * 已绑定列表
     *
     * @param page 分页对象
     * @param param 查询实体
     * @return 已绑定列表
     */
    @GetMapping("/machineBindList")
    public R machineBindList(@ParameterObject Page<MachineBindListVO> page, @Valid @ParameterObject MachineUserListDTO param) {

        return R.ok(kxsMachineService.machineBindList(page, param));
    }


    /**
     * 全部机具
     *
     * @param page 分页对象
     * @param param 查询实体
     * @return 全部机具
     */
    @GetMapping("/machineUserList")
    public R machineUserList(@ParameterObject Page<MachineUserListVO> page, @Valid @ParameterObject MachineUserListDTO param) {

        return R.ok(kxsMachineService.getByPage(page, param));
    }


    /**
     * 机具修改活动
     *
     * @param param 实体对象
     * @return 机具修改活动
     */
    @PostMapping("/updatePledge")
    public R updatePledge(@RequestBody MachineUpdatePledgeDTO param) {
        return R.ok();
    }


    /**
     * 机具未绑定划拨
     *
     * @param param 实体对象
     * @return 机具未绑定划拨
     */
    @PostMapping("/machineTransfer")
    public R machineTransfer(@Valid @RequestBody MachineTransferDTO param) {

        return kxsMachineService.machineTransferUser(param);
    }


    /**
     * 未绑定划拨记录
     *
     * @param page 分页对象
     * @param param 查询实体
     * @return 未绑定划拨记录
     */
    @GetMapping("/machineTransferList")
    public R machineTransferList(@ParameterObject Page<MachineTransferListVO> page, @Valid @ParameterObject MachineTransferListDTO param) {

        return R.ok(kxsMachineTransferService.machineTransferList(page, param));
    }


    /**
     * 用户机具和箱具码搜索
     *
     * @param page 分页对象
     * @param param 查询实体
     * @return 用户机具和箱具码搜索
     */
    @GetMapping("/searchUserMachine")
    public R searchUserMachine(@ParameterObject Page<SearchUserMachineVO> page, @ParameterObject SearchUserMachineDTO param) {

        return R.ok(kxsMachineService.searchUserMachine(page, param));
    }


    /**
     * 循环过期弹框
     *
     * @return 循环过期弹框列表
     */
    @GetMapping("/expiredModal")
    public R expiredModal() {

        return R.ok(kxsMachineService.expiredModal());
    }

    /**
     * 机具可回收列表
     *
     * @param page 分页对象
     * @return 机具可回收列表
     */
    @GetMapping("/recycleList")
    public R recycleList(@ParameterObject Page<MachineRecycleListVO> page, @ParameterObject RecycleMachineQuery param) {

        return R.ok(kxsMachineService.recycleList(page, param));
    }

    /**
     * 可回收数量 内部调用
     *
     * @param userId 分页对象
     * @return 可回收数量
     */
    @Inner
    @GetMapping("/loadRecoverableData")
    public R loadRecoverableData(@RequestParam("userId") Long userId) {

        return R.ok(kxsMachineService.count(Wrappers.<KxsMachine>lambdaQuery()
                .eq(KxsMachine::getStatus, MachineTypeEnum.RECYCLE_STATUS.getType())
                .eq(KxsMachine::getUserId, userId)));
    }


    /**
     * 仓库库存机具列表
     *
     * @param page 分页对象
     * @param param 查询实体
     * @return 仓库库存机具列表
     */
    @GetMapping("/machineStoreList")
    public R machineStoreList(@ParameterObject Page<MachineStoreListVO> page, @Valid @ParameterObject MachineStoreListDTO param) {

        return R.ok(kxsMachineService.machineStoreList(page, param));
    }


    /**
     * 仓库机具搜索
     *
     * @param page 分页对象
     * @param param 查询实体
     * @return 机具搜索
     */
    @GetMapping("/searchStoreMachine")
    public R searchStoreMachine(@ParameterObject Page<MachineStoreListVO> page, @Valid @ParameterObject MachineStoreListDTO param) {

        return R.ok(kxsMachineService.searchStoreMachine(page, param));
    }

    /**
     * 通过id查询信息
     *
     * @param id sn
     * @return machine
     */
    @Inner
    @GetMapping("/loadMachineById")
    public R loadMachineById(@RequestParam("id") Integer id) {

        return R.ok(kxsMachineService.getById(id));
    }


    /**
     * 更新机具
     *
     * @param machine 机具
     * @return {@link R}<{@link KxsTicket}>
     */
    @Inner
    @PostMapping("/updateByMachine")
    public R updateByMachine(@RequestBody KxsMachine machine) {

        return R.ok(kxsMachineService.updateById(machine));
    }

    /**
     * 订单管理-激活统计
     *
     * @param page 分页对象
     * @param param 查询实体
     * @return 订单管理-激活统计
     */
    @GetMapping("/activateMachineMonthTotal")
    public R activateMachineMonthTotal(@ParameterObject Page<StoreActMachineMonthTotalVO> page, @Valid @ParameterObject StoreActMachineMonthTotalDTO param) {

        return R.ok(kxsMachineService.activateMachineMonthTotal(page, param));
    }


    /**
     * 订单管理-激活统计明细
     *
     * @param page 分页对象
     * @param param 查询实体
     * @return 订单管理-激活统计明细
     */
    @GetMapping("/activateMachineMonthTotalDetail")
    public R activateMachineMonthTotalDetail(@ParameterObject Page<StoreActMachineDayDetailVO> page, @Valid @ParameterObject StoreActMachineDayDetailDTO param) {

        return R.ok(kxsMachineService.activateMachineMonthTotalDetail(page, param));
    }

    @Inner
    @GetMapping("/loadMachineBySn")
    public R loadMachineBySn(@RequestParam("sn") String sn){

        return R.ok(kxsMachineService.getOne(Wrappers.lambdaQuery(KxsMachine.class)
                .eq(KxsMachine::getPosSn, sn)));
    }
}

