package com.wms.bussiness;

import com.wms.constants.enums.LocationStatus;
import com.wms.constants.enums.StockStatus;
import com.wms.constants.enums.TaskType;
import com.wms.constants.enums.WmsTaskStatus;
import com.wms.entity.table.Location;
import com.wms.entity.table.Stock;
import com.wms.entity.table.Task;
import com.wms.mapper.LocationMapper;
import com.wms.mapper.StockMapper;
import com.wms.mapper.TaskMapper;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import javax.swing.plaf.synth.Region;
import java.util.Date;
import java.util.List;


/**
 * 对任务的操作
 */
@Slf4j
@Component
@RequiredArgsConstructor(onConstructor = @__(@Autowired))
public class TaskOperation {

    /**
     * 库存 Mapper
     */
    private final StockMapper stockMapper;

    /**
     * 任务表操作类
     */
    private final TaskMapper taskMapper;

    /**
     * 库位表操作类
     */
    private final LocationMapper locationMapper;




    //region 完成任务
    /**
     * 完成任务
     * @param task 要完成的任务
     * @return 操作结果
     */
    public boolean completeTask(Task task) {
        if(task == null) {
            return false;
        }
        TaskType taskType = TaskType.getTaskType(task.getTaskType());
        if(taskType == null) {
            return false;
        }
        /* 根据任务类型判断 */
        return switch (taskType) {
            case IN -> completeInTask(task);
            case OUT -> completeOutTask(task);
            case INVENTORY -> completeInventoryTask(task);
            case MOVE -> completeMoveTask(task);
        };
    }

    /**
     * 完成入库任务
     * @param task 要完成的入库任务
     * @return 结果
     */
    private boolean completeInTask(Task task) {
        /* 将任务更新为完成，将库存更新为正常库存，将库位更新为占用 */
        // 更新任务状态
        Task updateTask = new Task();
        updateTask.setTaskId(task.getTaskId());
        updateTask.setTaskStatus(WmsTaskStatus.FINISH.getCode());
        updateTask.setFinishTime(new Date());
        int updateRow = taskMapper.executeTask(updateTask);
        if(updateRow != 1) {
            log.warn(String.format("完成入库任务更新任务状态失败，任务号：%s", task.getTaskId()));
            return false;
        }
        // 更新库存状态
        Stock stockQuery = new Stock();
        stockQuery.setLocationId(task.getDestination());
        List<Stock> stocks = stockMapper.selStocks(stockQuery);
        if(stocks == null) {
            log.warn(String.format("完成入库任务查询库存 查询数据库失败，任务号：%s", task.getTaskId()));
            return false;
        }
        if(stocks.isEmpty()) {
            log.warn(String.format("完成入库任务查询库存没有库存数据，任务号：%s", task.getTaskId()));
            return false;
        }
        for(Stock stock : stocks) {
            Stock updateStock = new Stock();
            updateStock.setStockId(stock.getStockId());
            updateStock.setStockStatus(StockStatus.OK.getCode());
            updateStock.setLastUpdateTime(new Date());
            updateStock.setCreateTime(new Date());
            int updateStockResult = stockMapper.modifyStock(updateStock);
            if(updateStockResult != 1) {
                log.warn(String.format("完成入库任务更新库存状态失败，任务号：%s , 库存号：%s", task.getTaskId(), stock.getStockId()));
            }
        }
        return true;
    }

    /**
     * 完成出库任务
     * @param task 要完成的出库任务
     * @return 执行结果
     */
    private boolean completeOutTask(Task task) {
        /* 将任务更新为完成，删除库存，将库位释放 */
        // 更新任务状态
        Task updateTask = new Task();
        updateTask.setTaskId(task.getTaskId());
        updateTask.setTaskStatus(WmsTaskStatus.FINISH.getCode());
        updateTask.setFinishTime(new Date());
        int updateRow = taskMapper.executeTask(updateTask);
        if(updateRow != 1) {
            log.warn(String.format("完成出库任务更新任务状态失败，任务号：%s", task.getTaskId()));
            return false;
        }
        // 删除库存
        Stock stockQuery = new Stock();
        stockQuery.setLocationId(task.getDestination());
        List<Stock> stocks = stockMapper.selStocks(stockQuery);
        if(stocks == null) {
            log.warn(String.format("完成出库任务查询库存 查询数据库失败，任务号：%s", task.getTaskId()));
            return false;
        }
        if(stocks.isEmpty()) {
            log.warn(String.format("完成出库任务查询库存没有库存数据，任务号：%s", task.getTaskId()));
            return false;
        }
        for(Stock stock : stocks) {
            int deleteStockResult = stockMapper.deleteStock(stock.getStockId());
            if(deleteStockResult != 1) {
                log.warn(String.format("完成出库任务删除库存状态失败，任务号：%s , 库存号：%s", task.getTaskId(), stock.getStockId()));
            }
        }
        // 释放库位
        Location location = new Location();
        location.setLocationId(task.getDestination());
        location.setLocationStatus(LocationStatus.EMPTY.getCode());
        locationMapper.modifyLocation(location);
        return true;
    }

    private boolean completeInventoryTask(Task task) {
        return true;
    }

    private boolean completeMoveTask(Task task) {
        /* 将任务更新为完成；更新库存状态；更新库位状态 */
        Task updateTask = new Task();
        updateTask.setTaskId(task.getTaskId());
        updateTask.setTaskStatus(WmsTaskStatus.FINISH.getCode());
        updateTask.setFinishTime(new Date());
        int updateRow = taskMapper.executeTask(updateTask);
        if(updateRow != 1) {
            log.warn(String.format("完成移库任务更新任务状态失败，任务号：%s", task.getTaskId()));
            return false;
        }
        // 更新库存
        int updateLocationResult = stockMapper.updateLocationAndStatus(task.getOrigin(), task.getDestination(), StockStatus.OK.getCode());
        if(updateLocationResult < 1) {
            log.warn(String.format("完成移库任务更新库存状态失败，任务号：%s ，原库位：%s，新库位：%s", task.getTaskId(), task.getOrigin(), task.getDestination()));
            return false;
        }
        // 释放原库位
        Location location = new Location();
        location.setLocationId(task.getOrigin());
        location.setLocationStatus(LocationStatus.EMPTY.getCode());
        locationMapper.modifyLocation(location);
        return true;
    }
    //endregion



    //region 取消任务

    /**
     * 取消任务
     * @param task 要完成的任务
     * @return 操作结果
     */
    public boolean cancelTask(Task task) {
        if(task == null) {
            return false;
        }
        TaskType taskType = TaskType.getTaskType(task.getTaskType());
        if(taskType == null) {
            return false;
        }
        /* 根据任务类型判断 */
        return switch (taskType) {
            case IN -> cancelInTask(task);
            case OUT -> cancelOutTask(task);
            case INVENTORY -> cancelInventoryTask(task);
            case MOVE -> cancelMoveTask(task);
        };
    }

    /**
     * 取消入库任务
     * @param task 要取消的入库任务
     * @return 结果
     */
    private boolean cancelInTask(Task task) {
        /* 将任务更新为取消，将库存删除，将库位更新为空闲 */
        // 更新任务状态
        Task updateTask = new Task();
        updateTask.setTaskId(task.getTaskId());
        updateTask.setTaskStatus(WmsTaskStatus.CANCEL.getCode());
        updateTask.setFinishTime(new Date());
        int updateRow = taskMapper.executeTask(updateTask);
        if(updateRow != 1) {
            log.warn(String.format("取消入库任务更新任务状态失败，任务号：%s", task.getTaskId()));
            return false;
        }
        // 删除库存
        int deleteResult = stockMapper.deleteStockWithLocationId(task.getDestination());
        if(deleteResult < 1) {
            log.warn(String.format("取消入库删除库存失败，任务号：%s，入库点位：%s -> %s", task.getTaskId(), task.getOrigin(), task.getDestination()));
        }
        // 释放库位
        Location location = new Location();
        location.setLocationId(task.getDestination());
        location.setLocationStatus(LocationStatus.EMPTY.getCode());
        locationMapper.modifyLocation(location);
        return true;
    }

    /**
     * 取消出库任务
     * @param task 要取消的出库任务
     * @return 执行结果
     */
    private boolean cancelOutTask(Task task) {
        /* 将任务更新为取消，将库存更新为库存中 */
        // 更新任务状态
        Task updateTask = new Task();
        updateTask.setTaskId(task.getTaskId());
        updateTask.setTaskStatus(WmsTaskStatus.CANCEL.getCode());
        updateTask.setFinishTime(new Date());
        int updateRow = taskMapper.executeTask(updateTask);
        if(updateRow != 1) {
            log.warn(String.format("取消出库任务更新任务状态失败，任务号：%s", task.getTaskId()));
            return false;
        }
        // 更新库存信息为库存中
        int updateResult = stockMapper.updateStockStatusWithLocationId(task.getOrigin(), StockStatus.OK.getCode());
        if(updateResult < 1) {
            log.warn(String.format("取消出库任务更新库存状态失败，任务号：%s，出库点位：%s -> %s", task.getTaskId(), task.getOrigin(), task.getDestination()));
        }
        return true;
    }

    private boolean cancelInventoryTask(Task task) {
        return true;
    }

    private boolean cancelMoveTask(Task task) {
        /* 将任务更新为取消；更新库存状态为正常；释放终点库位 */
        Task updateTask = new Task();
        updateTask.setTaskId(task.getTaskId());
        updateTask.setTaskStatus(WmsTaskStatus.CANCEL.getCode());
        updateTask.setFinishTime(new Date());
        int updateRow = taskMapper.executeTask(updateTask);
        if(updateRow != 1) {
            log.warn(String.format("完成移库任务更新任务状态失败，任务号：%s", task.getTaskId()));
            return false;
        }
        // 更新库存信息为库存中
        int updateResult = stockMapper.updateStockStatusWithLocationId(task.getOrigin(), StockStatus.OK.getCode());
        if(updateResult < 1) {
            log.warn(String.format("取消出库任务更新库存状态失败，任务号：%s，出库点位：%s -> %s", task.getTaskId(), task.getOrigin(), task.getDestination()));
        }
        // 释放新库位
        Location location = new Location();
        location.setLocationId(task.getDestination());
        location.setLocationStatus(LocationStatus.EMPTY.getCode());
        locationMapper.modifyLocation(location);
        return true;
    }


    //endregion




}