package com.objecteye.handle;

import com.alibaba.fastjson.JSON;
import com.objecteye.config.RabbitmqConfig;
import com.objecteye.entity.ResponseParam;
import com.objecteye.entity.SyEquipment;
import com.objecteye.entity.UploadVehicleResult;
import com.objecteye.entity.VpAnalysisParam;
import com.objecteye.service.EquipmentService;
import com.objecteye.utils.FtpUtil;
import com.objecteye.utils.GlobalUtil;
import com.objecteye.utils.TimeUtil;
import org.apache.commons.net.ftp.FTPClient;
import org.apache.commons.net.ftp.FTPFile;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Component;

import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStream;
import java.util.Map;

@Component
public class Ftp2Mongo {
    private Logger logger = LoggerFactory.getLogger(getClass());

    @Autowired
    private RedisTemplate redisTemplate;
    @Autowired
    private FtpUtil ftpUtil;
    @Autowired
    private RabbitTemplate rabbitTemplate;
    @Autowired
    private EquipmentService equipmentService;

    @Value("${picture.storePath}")
    private String path2;
    @Value("${picture.http}")
    private String http;
    @Value("${requestFile}")
    private String url;


    public void downloadFile() {
        while (true) {
            Map<String, Integer> equipmentIpAndId = redisTemplate.opsForHash().entries("equipmentIpAndId");
            OutputStream os = null;
            FTPClient ftp = ftpUtil.connect();
            if (ftp != null) {
                String localpath = path2;
                try {
                    Thread.sleep(500);
                    FTPFile[] ftpFiles = ftp.listDirectories();
                    if (null == ftpFiles || ftpFiles.length == 0) {
                        Thread.sleep(1000);
                    } else {
                        for (FTPFile ftpFile : ftpFiles) {
                            String name = ftpFile.getName();
                            if (equipmentIpAndId.containsKey(name)) {
                                FTPFile[] fs = ftp.listFiles(name);
                                for (FTPFile f : fs) {
                                    String fileName = f.getName();
                                    File localFile = new File(localpath + "/" + fileName);

                                    if (localFile.exists()) {
                                        ftp.deleteFile(name + "/" + fileName);
                                    }
                                    String picName = localpath + fileName;
                                    os = new FileOutputStream(picName);
                                    boolean b = ftp.retrieveFile(name + "/" + fileName, os);
                                    int i = 0;
                                    while (i <= 1000) {
                                        if (b) {
                                            long timeStamp = TimeUtil.getTimeStamp(fileName);
                                            System.out.println(timeStamp);
                                            String picFile = TimeUtil.getPicFile(fileName);
                                            String picUrl = http + fileName;
                                            Integer deviceId = equipmentIpAndId.get(picFile);
                                            SyEquipment equipment = equipmentService.findOne(deviceId);
                                            String latitude = equipment.getLatitude();
                                            String longitude = equipment.getLongitude();
                                            String equipmentName = equipment.getEquipmentName();

                                            File file = new File(picName);
                                            String body = GlobalUtil.httpExecute(url, file);

                                            ResponseParam responseParam = JSON.parseObject(body, ResponseParam.class);
                                            String code = responseParam.getCode();
                                            if ("0".equals(code)) {
                                                String s1 = JSON.toJSONString(responseParam.getResult());
                                                VpAnalysisParam vpAnalysisParam = JSON.parseObject(s1, VpAnalysisParam.class);
                                                UploadVehicleResult uploadVehicleResult = new UploadVehicleResult();
                                                uploadVehicleResult.setCount(vpAnalysisParam.getCount());
                                                uploadVehicleResult.setInfo(vpAnalysisParam.getInfo());
                                                uploadVehicleResult.setPicName(fileName);
                                                uploadVehicleResult.setDeviceId(deviceId);
                                                uploadVehicleResult.setImageUrl(picUrl);
                                                uploadVehicleResult.setEquipmentName(equipmentName);
                                                uploadVehicleResult.setLatitude(latitude);
                                                uploadVehicleResult.setLongitude(longitude);

                                                uploadVehicleResult.setCaptureTime(timeStamp);
                                                String s = JSON.toJSONString(uploadVehicleResult);
                                                rabbitTemplate.convertAndSend(RabbitmqConfig.EXCHANGE_TOPICS_INFORM, "inform.store", s);
                                            }
                                            ftp.deleteFile(name + "/" + fileName);
                                            break;
                                        } else {
                                            Thread.sleep(100);
                                            i += 100;
                                        }
                                    }
                                    os.close();
                                }
                            }
                        }
                    }
                    ftp.logout();
                } catch (Exception e) {
                    e.printStackTrace();
                } finally {
                    if (ftp.isConnected())
                        try {
                            ftp.disconnect();
                        } catch (IOException ioe) {
                            ioe.printStackTrace();
                        }
                }
            }
        }
    }
}