潘钊 / bsth_control · Files

package com.bsth.service.impl.videoimpl;

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONArray;
import com.bsth.data.BasicData;
import com.bsth.entity.Business;
import com.bsth.entity.Line;
import com.bsth.entity.video.VideoChannel;
import com.bsth.entity.video.VideoTree;
import com.bsth.service.BusinessService;
import com.bsth.service.LineService;
import com.bsth.service.video.VideoService;
import com.bsth.util.HttpClientUtils;
import com.bsth.util.MailUtils;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.collections.CollectionUtils;
import org.apache.commons.collections.MapUtils;
import org.apache.commons.lang3.StringUtils;
import org.apache.http.HttpEntity;
import org.apache.http.client.config.RequestConfig;
import org.apache.http.client.methods.CloseableHttpResponse;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.client.methods.HttpPost;
import org.apache.http.entity.StringEntity;
import org.apache.http.impl.client.CloseableHttpClient;
import org.geolatte.geom.M;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.*;
import java.util.stream.Collectors;

/**
 * @author liujun
 * @date 2024年07月01日 12:57
 */
@Service
@Slf4j
public class VideoServiceImpl implements VideoService {
    @Autowired
    private BusinessService businessService;
    @Autowired
    private LineService lineService;
    @Autowired
    private WvpConfig wvpConfig;
    @Autowired
    private BasicData basicData;


    @Override
    public List<VideoTree> combinationTree() {
        List<VideoTree> returnList = new ArrayList<>();

        List<VideoTree> bussessTree = queryBusiness();
        if (CollectionUtils.isNotEmpty(bussessTree)) {
            returnList.addAll(bussessTree);
        }

//        List<VideoTree> lineTree = queryLine();
//        if (CollectionUtils.isNotEmpty(lineTree)) {
//            returnList.addAll(lineTree);
//        }
        return returnList;

    }

    @Override
    public List<VideoTree> combinationTreeOfCar(String code,boolean spread,boolean asyn) {
        if (Objects.nonNull(code)) {
            List<VideoTree> trees = new ArrayList<>();
            Set<String> carNos = groupCarNosByComputeCode(code);

            Set<Line> lineSet = groupLingByCompany(code);
            if (CollectionUtils.isNotEmpty(lineSet)) {
                for (Line line : lineSet) {
                    VideoTree videoTree = combinationOfLine(code, line,spread,asyn);
                    trees.add(videoTree);

                    Set<String> carNoSets = groupCarNoByLine(line.getId());
                    if (CollectionUtils.isNotEmpty(carNoSets)) {
                        List<VideoTree> children = new ArrayList<>();
                        for (String carNo : carNoSets) {
                            VideoTree carTree = combnationOfCar(carNo, line.getId().toString(),spread,asyn);
                            children.add(carTree);

                            if (CollectionUtils.isNotEmpty(carNos)) {
                                carNos.remove(carNo);
                            }
                        }
                        videoTree.setChildren(children);
                    }
                }

            }


            if (CollectionUtils.isNotEmpty(carNos)) {
                for (String carNo : carNos) {
                    VideoTree carTree = combnationOfCar(carNo, code,spread,asyn);
                    trees.add(carTree);
                }
            }
            return trees;
        }
        return null;
    }

    private VideoTree combnationOfCar(String carNo, String line,boolean spread,boolean asyn) {
        String name = Objects.isNull(basicData) || MapUtils.isEmpty(basicData.nbbmCompanyPlateMap) ? null : basicData.nbbmCompanyPlateMap.get(carNo);
        VideoTree tree = combinationVideoTree(carNo, carNo, line, carNo, 301, "bus1", carNo,spread,asyn);
        tree.setWvpLiveBroadcast(wvpConfig.getWvpLiveBroadcast());
        return tree;
    }

    private VideoTree combinationOfLine(String code, Line line,boolean spread,boolean asyn) {
        return combinationVideoTree(line.getId(), line.getName(), code, line.getId(), 201, "line", line.getLineCode(),spread,asyn);
    }

    @Override
    public List<VideoTree> searchTreeDataByCarNo(String carNo,boolean spread,boolean asyn) throws Exception {
        Line line = findLineByCode(carNo);

        Iterable<Business> businessIterable = businessService.list(new HashMap<>());
        if (Objects.isNull(businessIterable)) {
            return Collections.emptyList();
        }

        if (Objects.nonNull(line)) {
            Set<Business> businesses = new LinkedHashSet<>();
            findBussinessByUpCode(line.getCompany(), businessIterable, businesses);
            if (CollectionUtils.isNotEmpty(businesses)) {
                List<VideoTree> group = combitionBussiness(businesses,spread,asyn);

                VideoTree sourceTree = findVideoTreeByBusinessCode(line.getCompany(), group);
                if (Objects.isNull(sourceTree.getChildren())) {
                    sourceTree.setChildren(new ArrayList<>());
                }
                VideoTree lineOfTreeNode = combinationOfLine(sourceTree.getId().toString(), line,spread,asyn);
                lineOfTreeNode.setSpread(Boolean.TRUE.toString());
                lineOfTreeNode.setChildren(new ArrayList<>());
                sourceTree.getChildren().add(lineOfTreeNode);

                VideoTree carOfTreeNode = combnationOfCar(carNo, line.getLineCode(),spread,asyn);
                lineOfTreeNode.getChildren().add(carOfTreeNode);
                carOfTreeNode.setSpread(Boolean.TRUE.toString());

                List<VideoTree> children = queryChannelsTree(carNo,spread,asyn);
                carOfTreeNode.setChildren(children);


                return group;
            }
        } else {
            Set<Business> businesses = new LinkedHashSet<>();
            String company = basicData.nbbm2CompanyCodeMap.get(carNo);
            if (StringUtils.isNotEmpty(company)) {
                findBussinessByUpCode(company, businessIterable, businesses);
                if (CollectionUtils.isNotEmpty(businesses)) {
                    List<VideoTree> group = combitionBussiness(businesses,spread,asyn);
                    VideoTree sourceTree = findVideoTreeByBusinessCode(company, group);
                    if (Objects.nonNull(sourceTree) && Objects.isNull(sourceTree.getChildren())) {
                        sourceTree.setChildren(new ArrayList<>());
                    }
                    VideoTree carOfTreeNode = combnationOfCar(carNo, company,spread,asyn);
                    carOfTreeNode.setSpread(Boolean.TRUE.toString());
                    sourceTree.getChildren().add(carOfTreeNode);

                    sourceTree.setSpread("true");
                    List<VideoTree> children = queryChannelsTree(carNo,spread,asyn);
                    carOfTreeNode.setChildren(children);

                    return group;
                }
            }
        }


        return Collections.emptyList();
    }

    @Override
    public List<VideoTree> queryChannelsTree(String carNo, boolean spread,boolean asyn) throws Exception {
        List<Map<String, Object>> videoChannels = getVideoChannel(carNo);
        List<VideoTree> trees = new ArrayList<>();

        if (CollectionUtils.isNotEmpty(videoChannels)) {
            for (Map<String, Object> map : videoChannels) {
                VideoTree tree = new VideoTree();
                tree.setId(map.get("channelId"));
                tree.setCode(map.get("channelId"));
                tree.setSourceId(map.get("deviceId"));
                tree.setType(401);
                tree.setIcon("layui-icon-video");
                String name = Objects.isNull(map.get("name")) ? map.get("channelId") + "_" + map.get("deviceId") : map.get("name").toString();
                tree.setText("<span><img src='/metronic_v4.5.4/layui/icon/video1.ico' class ='imageIcon' /></span><span>"+name+"</span>");
                tree.setNodePValue(carNo);
                tree.setWvpLiveBroadcast(wvpConfig.getWvpLiveBroadcast());

                trees.add(tree);
            }
        }
        return trees;
    }

    @Override
    public List<Map<String, Object>> getVideoChannel(String carNo) throws Exception {
        return getWvpVideoChannelByCarNo(carNo);
    }

    @Override
    public List<Map<String, Object>> getVideoChannelHistoryList(String device, String channel, String dateStr, String token) throws Exception {
        return getVideoChannelHistoryListReq(device, channel, dateStr, token);
    }

    @Override
    public String getToken() throws Exception {
        return getWvpLoginToken();
    }


    /***
     *查询公交公司的数据。
     * @author liujun
     * @date 2024/6/27 11:29
     * @return java.util.List<com.bsth.entity.video.VideoTree>
     */
    private List<VideoTree> queryBusiness() {
        Iterable<Business> businessIterable = businessService.list(new HashMap<>());
        if (Objects.isNull(businessIterable)) {
            return Collections.emptyList();
        }

        return combitionBussiness(businessIterable,false,Boolean.FALSE);

    }

    private List<VideoTree> combitionBussiness(Iterable<Business> businessIterable,boolean spread,boolean asyn) {
        List<VideoTree> trees = new ArrayList<>();
        Iterator<Business> iterator = businessIterable.iterator();
        while (iterator.hasNext()) {
            Business business = iterator.next();
            VideoTree videoTree = combinationVideoTree(business.getBusinessCode(), business.getBusinessName(), business.getUpCode(), business.getId(), null, "company1", business.getBusinessCode(),spread,asyn);
            trees.add(videoTree);
        }
        List<VideoTree> groupTree = new ArrayList<>();
        for (VideoTree tree : trees) {
            if (Objects.equals(tree.getNodePValue(), "0")) {
                VideoTree target = new VideoTree();
                BeanUtils.copyProperties(tree, target);
                target.setSpread(String.valueOf(tree.getSpread()));
//                target.setParent("#");
                target.setType(0);
                groupTree.add(target);
            }
        }

        if (CollectionUtils.isNotEmpty(groupTree)) {
            for (VideoTree tree : groupTree) {
                groupTree(trees, tree);
            }
        }
        return groupTree;
    }

    /***
     * 组合树
     * @author liujun
     * @date 2024/6/27 13:12
     * @param id id
     * @param text 显示的文本
     * @param sourceId 数据的ID
     * @param parent 数据的父节点
     * @param type 类型
     * @param icon 图标
     * @return com.bsth.entity.video.VideoTree
     */
    private VideoTree combinationVideoTree(Object id, String text, String parent, Object sourceId, Integer type, String icon, Object code,boolean spread,boolean asyn) {
        VideoTree videoTree = new VideoTree();
        videoTree.setId(id);
        videoTree.setText("<span><img src='/metronic_v4.5.4/layui/icon/"+icon+".png' class ='imageIcon' /></span><span>"+text+"</span>");
        videoTree.setSourceId(sourceId);
        videoTree.setNodePValue(parent);
        videoTree.setType(type);
        videoTree.setIcon(icon);
        videoTree.setCode(code);
        videoTree.setInitChild(asyn);
        videoTree.setSpread(String.valueOf(spread));
        return videoTree;
    }

    private void groupTree(List<VideoTree> trees, VideoTree tree) {
        if (Objects.isNull(trees) || CollectionUtils.isEmpty(trees)) {
            return;
        }
        for (VideoTree videoTree : trees) {
            if (Objects.equals(videoTree.getNodePValue(), tree.getId())) {
                if (Objects.isNull(tree.getChildren())) {
                    tree.setChildren(new ArrayList<>());
                }
                VideoTree target = new VideoTree();
                BeanUtils.copyProperties(videoTree, target);
                target.setType(tree.getType() + 1);
                target.setSpread(String.valueOf(tree.getSpread()));


                tree.getChildren().add(target);
                groupTree(trees, target);
            }
        }
    }

    /***
     * 获取wvp 系统的登陆token
     * @author liujun
     * @date 2024/7/2 16:16
     * @return java.lang.String
     */
    private String getWvpLoginToken() throws Exception {
        StringBuilder url = new StringBuilder();
        url.append(wvpConfig.getLoginURL());
        if (StringUtils.indexOf(wvpConfig.getLoginURL(), "?") == -1) {
            url.append("?");
        }
        url.append("username=");
        url.append(wvpConfig.getUserName());
        url.append("&password=");
        url.append(wvpConfig.getPwd());
        try {
            StringBuilder result = HttpClientUtils.get(url.toString());
            Map<String, Object> resultMap = (Map<String, Object>) switchWVPResult(result, url);
            if (MapUtils.isEmpty(resultMap)) {
                return null;
            }
            return Objects.isNull(resultMap.get("accessToken")) ? null : resultMap.get("accessToken").toString();

        } catch (Exception e) {
            log.error("[{}]请求异常:", url, e);
            throw e;
        }
    }

    private List<Map<String, Object>> getWvpVideoChannelByCarNo(String carNo) throws Exception {
        String token = getWvpLoginToken();
        if (StringUtils.isEmpty(token)) {
            log.error("wvp login token is null");
            return Collections.emptyList();
        }
        Map<String, Object> headers = new HashMap<>();
        headers.put("Access-Token", token);
        String url = StringUtils.replace(wvpConfig.getChannelListOfCarNoURL(), "{carNo}", carNo);
        try {
            StringBuilder result = get(url, headers);
            return (List<Map<String, Object>>) switchWVPResult(result, url);

        } catch (Exception e) {
            log.error("get wvp of channel list error[{}];", url, e);
            throw e;
        }
    }

    private List<Map<String, Object>> getVideoChannelHistoryListReq(String device, String channel, String dateStr, String token) throws Exception {
        if (StringUtils.isEmpty(token)) {
            log.error("wvp login token is null");
            return Collections.emptyList();
        }
        Map<String, Object> headers = new HashMap<>();
        headers.put("Access-Token", token);


        String url = StringUtils.replace(wvpConfig.getWvpChannelHistoryUrl(), "{device}", device);
        url = StringUtils.replace(url, "{channel}", channel);
        url = StringUtils.replace(url, "{startTimeStr}", dateStr + "%2000:00:00");
        url = StringUtils.replace(url, "{endTimeStr}", dateStr + "%2023:59:59");

        try {
            StringBuilder result = get(url, headers);
            Map<String, Object> resulMap = (Map<String, Object>) switchWVPResult(result, url);
            if (MapUtils.isEmpty(resulMap)) {
                return Collections.emptyList();
            }

            List<Map<String, Object>> recordList = (List<Map<String, Object>>) resulMap.get("recordList");

            return CollectionUtils.isEmpty(recordList) ? Collections.emptyList() : recordList;
        } catch (Exception e) {
            log.error("get wvp of channel history list error[{}];", url, e);
            throw e;
        }
    }

    public static StringBuilder get(String url, Map<String, Object> headers) throws Exception {
        CloseableHttpClient httpClient = null;
        CloseableHttpResponse response = null;
        StringBuilder stringBuffer = null;
        try {
            httpClient = HttpClientUtils.defaultHttpClient(url);
            HttpGet get = new HttpGet(url);

            if (MapUtils.isNotEmpty(headers)) {
                for (Map.Entry<String, Object> header : headers.entrySet()) {
                    get.setHeader(header.getKey(), String.valueOf(header.getValue()));
                }
            }
            //超时时间
            RequestConfig requestConfig = RequestConfig.custom()
                    .setConnectTimeout(12500).setConnectionRequestTimeout(12000)
                    .setSocketTimeout(13500).build();
            get.setConfig(requestConfig);

            response = httpClient.execute(get);
            stringBuffer = getResult(response.getEntity());
        } catch (Exception e) {
            log.error("", e);
            throw e;
        } finally {
            if (null != httpClient)
                httpClient.close();
            if (null != response)
                response.close();
        }
        return stringBuffer;
    }

    private static StringBuilder getResult(HttpEntity entity) throws IOException {
        StringBuilder stringBuffer = null;
        if (null != entity) {
            BufferedReader br = new BufferedReader(new InputStreamReader(entity.getContent()));
            stringBuffer = new StringBuilder();
            String str = "";
            while ((str = br.readLine()) != null)
                stringBuffer.append(str);
        }
        return stringBuffer;
    }

    /***
     * 解析wvp系统返回的数据
     * @author liujun
     * @date 2024/7/2 14:43
     * @param result
     * @param url
     * @return java.lang.Object
     */
    private Object switchWVPResult(Object result, Object url) {
        log.info("[{}]请求返回的数据：[{}]", url, result);
        if (Objects.nonNull(result)) {
            String resultStr = result.toString();
            if (StringUtils.isNotEmpty(resultStr)) {
                Map<String, Object> resultMap = (Map<String, Object>) JSON.parse(resultStr);
                Integer code = (Integer) resultMap.get("code");
                if (Objects.equals(0, code)) {
                    return resultMap.get("data");
                }
            }

        }
        return null;
    }


    private Set<String> groupCarNosByComputeCode(String code) {
        if (Objects.isNull(basicData) || MapUtils.isEmpty(basicData.nbbm2CompanyCodeMap)) {
            return Collections.emptySet();
        }
        Set<String> carNos = new LinkedHashSet<>();
        for (Map.Entry<String, String> entry : basicData.nbbm2CompanyCodeMap.entrySet()) {
            if (Objects.equals(code, entry.getValue())) {
                carNos.add(entry.getKey());
            }
        }

        return carNos;
    }

    private Set<String> groupCarNoByLine(Integer id) {
        if (Objects.isNull(basicData) || MapUtils.isEmpty(basicData.nbbm2LineMap)) {
            return Collections.emptySet();
        }

        Set<String> carNos = new LinkedHashSet<>();
        for (Map.Entry<String, Line> entry : basicData.nbbm2LineMap.entrySet()) {
            if (Objects.nonNull(entry.getValue()) && Objects.equals(entry.getValue().getId(), id)) {
                carNos.add(entry.getKey());
            }

        }

        return carNos;

    }


    private Set<Line> groupLine(Collection<String> carNos) {
        if (Objects.isNull(basicData) || MapUtils.isEmpty(basicData.nbbm2LineMap)) {
            return Collections.emptySet();
        }

        Set<Line> lineSet = new LinkedHashSet<>();
        for (String carNo : carNos) {
            Line line = basicData.nbbm2LineMap.get(carNo);
            if (Objects.nonNull(line)) {
                lineSet.add(line);
            }
        }

        return lineSet;
    }

    private Set<Line> groupLingByCompany(String companyCode) {
        if (Objects.isNull(basicData) || MapUtils.isEmpty(basicData.nbbm2LineMap)) {
            return Collections.emptySet();
        }

        Set<Line> lineSet = new LinkedHashSet<>();
        for (Map.Entry<String, Line> entry : basicData.nbbm2LineMap.entrySet()) {
            if (Objects.nonNull(entry.getValue()) && Objects.equals(entry.getValue().getCompany(), companyCode)) {
                lineSet.add(entry.getValue());
            }

        }
        return lineSet;
    }

    private void findBussinessByUpCode(String upCode, Iterable<Business> businessIterable, Collection<Business> results) {
        for (Business business : businessIterable) {
            if (Objects.equals(business.getBusinessCode(), upCode)) {
                results.add(business);
                findBussinessByUpCode(business.getUpCode(), businessIterable, results);
            }
        }
    }

    private VideoTree findVideoTreeByBusinessCode(String bussinessCode, List<VideoTree> videoTrees) {
        if (CollectionUtils.isEmpty(videoTrees)) {
            return null;
        }

        for (VideoTree videoTree : videoTrees) {
            if (Objects.nonNull(videoTree.getId()) && Objects.equals(videoTree.getId().toString(), bussinessCode)) {
                return videoTree;
            } else if (CollectionUtils.isNotEmpty(videoTree.getChildren())) {
                VideoTree source = findVideoTreeByBusinessCode(bussinessCode, videoTree.getChildren());
                if (Objects.nonNull(source)) {
                    return source;
                }
            }
        }

        return null;
    }

    private Line findLineByCode(String carNo) {
        Line line = basicData.nbbm2LineMap.get(carNo);
        if (Objects.nonNull(line)) {
            return line;
        }
        for (Map.Entry<String, Line> entry : basicData.nbbm2LineMap.entrySet()) {
            if (StringUtils.equalsIgnoreCase(carNo, entry.getKey())) {
                return entry.getValue();
            }
        }
        String lineId = null;
        for (Map.Entry<String, List<String>> entry : basicData.lineCodeHistoryNbbmMap.entrySet()) {
            if (CollectionUtils.isNotEmpty(entry.getValue())) {
                for (String sourceCarNo : entry.getValue()) {
                    if (StringUtils.equalsIgnoreCase(carNo, sourceCarNo)) {
                        lineId = entry.getKey();
                        break;
                    }
                }
            }

            if (StringUtils.isNotEmpty(lineId)) {
                break;
            }
        }

        if (StringUtils.isEmpty(lineId)) {
            return null;
        }

        for (Map.Entry<String, Line> entry : basicData.nbbm2LineMap.entrySet()) {
            if (StringUtils.equalsIgnoreCase(lineId, String.valueOf(entry.getValue().getId()))) {
                return entry.getValue();
            }
        }

        return null;

    }


}