package com.fzzy.common.manager;

import com.fzzy.igds.constant.Constant;
import com.fzzy.igds.constant.DepotType;
import com.fzzy.igds.data.IgdsBaseParam;
import com.fzzy.igds.data.InoutParam;
import com.fzzy.igds.data.MainData;
import com.fzzy.igds.domain.*;
import com.fzzy.igds.service.*;
import com.fzzy.igds.utils.ContextUtil;
import com.fzzy.igds.utils.DateUtil;
import com.fzzy.work.data.OrderStatus;
import com.fzzy.work.service.WorkOrderService;
import com.ruoyi.common.core.domain.entity.SysDept;
import com.ruoyi.common.core.domain.entity.SysDictData;
import com.ruoyi.common.core.domain.entity.SysUser;
import com.ruoyi.common.utils.StringUtils;
import com.ruoyi.system.service.ISysDeptService;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.time.DateFormatUtils;
import org.springframework.stereotype.Component;

import javax.annotation.Resource;
import java.util.Date;
import java.util.LinkedHashMap;
import java.util.List;

/**
 * @Description
 * @Author CZT
 * @Date 2025/11/29 15:19
 */
@Slf4j
@Component
public class CommonManager {

    @Resource
    private DepotService depotService;
    @Resource
    private DicService dicService;
    @Resource
    private CoreDeptService coreDeptService;
    @Resource
    private SecCameraService secCameraService;
    @Resource
    private ISysDeptService iSysDeptService;
    @Resource
    private FileService fileService;
    @Resource
    private CoreCompanyService coreCompanyService;
    @Resource
    private SloganService sloganService;
    @Resource
    private WorkOrderService workOrderService;
    @Resource
    private InoutRecordService inoutRecordService;
    @Resource
    private EventInfoService eventInfoService;
    @Resource
    private SnapRecordService snapRecordService;

    /**
     * 根据库区编码获取库区下所有仓库列表
     *
     * @param id
     * @return
     */
    public SysDept getDeptById(String id) {

        return iSysDeptService.selectDeptById(Long.valueOf(id));
    }

    /**
     * 获取库区鸟瞰图
     *
     * @param deptId
     * @return
     */
    public String isDeptImgExit(String deptId) {

        Dept dept = coreDeptService.getDeptById(deptId);

        String imgPath = (dept == null ? null : dept.getImgPath());
        return isImgExit(imgPath, "dept");
    }

    /**
     * 判断路径下文件是否存在，不存在则给默认
     *
     * @param imgPath
     * @param tag
     * @return
     */
    public String isImgExit(String imgPath, String tag) {
        return fileService.isImgExit(imgPath, tag);
    }

    /**
     * 根据字典类型获取字典列表
     *
     * @param parentCode
     * @param companyId
     * @return
     */
    public List<SysDictData> getDicTrigger(String parentCode, String companyId) {
        return dicService.getDictDataByType(parentCode, companyId);
    }

    /**
     * 根据库区编码获取库区下所有仓库列表
     *
     * @param deptId
     * @return
     */
    public List<Depot> listDepotByDeptId(String deptId) {
        try {
            if (StringUtils.isEmpty(deptId)) {
                deptId = ContextUtil.subDeptId(null);
            }

            return depotService.getCacheDepotList(ContextUtil.getCompanyId(), deptId);

        } catch (Exception e) {
            return null;
        }
    }

    /**
     * @return
     */
    public List<SysDictData> getInoutType() {
        return dicService.getInoutType();
    }


    /**
     * 获取分库列表
     *
     * @author sgj
     * @date 2025/12/12
     */
    public List<Dept> listDeptData() {
        return coreDeptService.getDeptData();
    }

    /**
     * 根据仓库编码获取仓库类型
     *
     * @param depotId
     * @return
     */
    public String getDepotTypeById(String depotId) {
        String depotType = DepotType.TYPE_01.getCode();

        Depot depot = depotService.getCacheDepot(ContextUtil.getCompanyId(), depotId);
        if (null != depot && StringUtils.isNotEmpty(depot.getDepotType())) {
            depotType = depot.getDepotType();
        }

        return depotType;
    }

    /**
     * 获取设备列表
     *
     * @author sgj
     * @date 2025/12/12
     */
    public List<Camera> listCameraData() {
        return secCameraService.listCamera(ContextUtil.getCompanyId(), ContextUtil.subDeptId(null));
    }

    /**
     * 获取收储公司列表
     *
     * @author sgj
     * @date 2025/12/17
     */
    public List<Company> listCompanyData() {
        SysUser user = ContextUtil.getLoginUser();
        return coreCompanyService.listCompany(null, null, user.getDeptId() + "");
    }


    /**
     * 获取启用的大屏标语
     *
     * @return
     */
    public Slogan getDicSlogan() {
        List<Slogan> slogans = sloganService.listData(Constant.YN_Y);
        if (null == slogans || slogans.isEmpty()) {
            return null;
        }
        return slogans.get(0);
    }


    /**
     * 获取启用的大屏标语
     *
     * @return
     */
    public MainData getIndexData(SysUser user) {

        MainData mainData = new MainData();

        //待办工单数
        Integer orderNum = workOrderService.getNumByUser(OrderStatus.STATUS_30.getCode(), user.getLoginName());
        mainData.setOrderNum(orderNum);

        //统计出入库信息
        Double inSum = 0.0;
        Double outSum = 0.0;
        LinkedHashMap<String, Integer> mapWeekInNum = new LinkedHashMap<>();
        LinkedHashMap<String, Integer> mapWeekOutNum = new LinkedHashMap<>();
        LinkedHashMap<String, Integer> mapMonthInNum = new LinkedHashMap<>();
        LinkedHashMap<String, Integer> mapMonthOutNum = new LinkedHashMap<>();
        LinkedHashMap<String, Integer> mapWeekAiNum = new LinkedHashMap<>();
        LinkedHashMap<String, Integer> mapWeekSnapNum = new LinkedHashMap<>();
        String key;
        for (int i = -29; i <= 0; i++) {
            mapMonthInNum.put(DateFormatUtils.format(DateUtil.getNewByDay(new Date(), i), "MM-dd"), 0);
            mapMonthOutNum.put(DateFormatUtils.format(DateUtil.getNewByDay(new Date(), i), "MM-dd"), 0);
            if (i >= -6) {
                mapWeekInNum.put(DateFormatUtils.format(DateUtil.getNewByDay(new Date(), i), "MM-dd"), 0);
                mapWeekOutNum.put(DateFormatUtils.format(DateUtil.getNewByDay(new Date(), i), "MM-dd"), 0);
                mapWeekAiNum.put(DateFormatUtils.format(DateUtil.getNewByDay(new Date(), i), "MM-dd"), 0);
                mapWeekSnapNum.put(DateFormatUtils.format(DateUtil.getNewByDay(new Date(), i), "MM-dd"), 0);
            }
        }

        //近7天AI事件数
        IgdsBaseParam param = new IgdsBaseParam();
        param.setDeptId(user.getDeptId() + "");
        param.setStart(DateUtil.getNewByDay(new Date(), -6));
        param.setEnd(new Date());
        List<EventInfo> listEvent = eventInfoService.getListByParam(param);
        if (null != listEvent && !listEvent.isEmpty()) {
            mainData.setAiNum(listEvent.size());
            for (EventInfo event : listEvent) {
                key = DateFormatUtils.format(event.getTime(), "MM-dd");
                if (null != mapWeekAiNum.get(key)) {
                    mapWeekAiNum.put(key, mapWeekAiNum.get(key) + 1);
                }
            }
        }
        for (String mapKey : mapWeekAiNum.keySet()) {
            mainData.getWeekAiDateList().add(mapKey);
            mainData.getWeekAiNumList().add(mapWeekAiNum.get(mapKey));
        }

        //近7天抓拍信息统计
        List<SnapRecord> listSnap = snapRecordService.getListByParam(param);
        if (null != listSnap && !listSnap.isEmpty()) {
            for (SnapRecord snap : listSnap) {
                key = DateFormatUtils.format(snap.getSnapTime(), "MM-dd");
                if (null != mapWeekSnapNum.get(key)) {
                    mapWeekSnapNum.put(key, mapWeekSnapNum.get(key) + 1);
                }
            }
        }
        for (String mapKey : mapWeekSnapNum.keySet()) {
            mainData.getWeekSnapDateList().add(mapKey);
            mainData.getWeekSnapNumList().add(mapWeekSnapNum.get(mapKey));
        }

        //查询近30天所有出入库信息
        InoutParam inoutParam = new InoutParam();
        param.setDeptId(user.getDeptId() + "");
        param.setStart(DateUtil.getNewByDay(new Date(), -29));
        param.setEnd(new Date());
        List<InoutRecord> inoutRecords = inoutRecordService.listInout(inoutParam);
        if (null != inoutRecords && !inoutRecords.isEmpty()) {
            for (InoutRecord record : inoutRecords) {
                key = DateFormatUtils.format(record.getRegisterTime(), "MM-dd");
                if (Constant.TYPE_IN.equals(record.getType())) {
                    if (null != mapWeekInNum.get(key)) {
                        mapWeekInNum.put(key, mapWeekInNum.get(key) + 1);
                    }
                    if (null != mapMonthInNum.get(key)) {
                        mapMonthInNum.put(key, mapMonthInNum.get(key) + 1);
                    }
                    if (key.equals(DateFormatUtils.format(new Date(), "MM-dd"))) {
                        mainData.setInNumDay(mainData.getInNumDay() + 1);
                        inSum += record.getRecordWeight();
                    }
                }
                if (Constant.TYPE_OUT.equals(record.getType())) {
                    if (null != mapWeekOutNum.get(key)) {
                        mapWeekOutNum.put(key, mapWeekOutNum.get(key) + 1);
                    }
                    if (null != mapMonthOutNum.get(key)) {
                        mapMonthOutNum.put(key, mapMonthOutNum.get(key) + 1);
                    }
                    if (key.equals(DateFormatUtils.format(new Date(), "MM-dd"))) {
                        mainData.setOutNumDay(mainData.getOutNumDay() + 1);
                        outSum += record.getRecordWeight();
                    }
                }
            }
        }

        for (String mapKey : mapWeekInNum.keySet()) {
            mainData.getWeekDateList().add(mapKey);
            mainData.getWeekInNumList().add(mapWeekInNum.get(mapKey));
        }

        for (String mapKey : mapWeekOutNum.keySet()) {
            mainData.getWeekOutNumList().add(mapWeekOutNum.get(mapKey));
        }

        for (String mapKey : mapMonthInNum.keySet()) {
            mainData.getMonthDateList().add(mapKey);
            mainData.getMonthInNumList().add(mapMonthInNum.get(mapKey));
        }

        for (String mapKey : mapMonthOutNum.keySet()) {
            mainData.getMonthOutNumList().add(mapMonthOutNum.get(mapKey));
        }
        mainData.setInSum(inSum / 1000);
        mainData.setOutSum(outSum / 1000);
        return mainData;
    }

}