package com.myproject.webapp.controller;

import com.csvreader.CsvReader;
import com.myproject.Constants;
import com.myproject.bean.excel.BarcodeExcel;
import com.myproject.bean.excel.BomExcel;
import com.myproject.bean.excel.ComponentExcel;
import com.myproject.bean.excel.StoragePosExcel;
import com.myproject.bean.update.*;
import com.myproject.exception.ExcelParseException;
import com.myproject.exception.ValidateException;
import com.myproject.manager.*;
import com.myproject.poi.BarcodeXlsParser;
import com.myproject.poi.BomXlsParser;
import com.myproject.poi.ComponentXlsParser;
import com.myproject.util.PointUtil;
import com.myproject.util.StorageConstants;
import com.myproject.webapp.controller.webService.DataCache;
import org.apache.commons.beanutils.BeanUtils;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.geo.Point;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.ModelAttribute;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.multipart.MultipartHttpServletRequest;
import org.springframework.web.multipart.commons.CommonsMultipartFile;

import javax.servlet.http.HttpServletRequest;
import java.io.*;
import java.lang.reflect.InvocationTargetException;
import java.util.ArrayList;
import java.util.List;

/**
 * Controller class to upload Files.
 * <p/>
 * <p>
 * <a href="FileUploadFormController.java.html"><i>View Source</i></a>
 * </p>
 *
 * @author <a href="mailto:matt@raibledesigns.com">Matt Raible</a>
 */
@Controller
@RequestMapping("/storage/fileupload*")
public class FileUploadController extends BaseFormController {

    @Autowired
    private IComponentManager componentManager;
    @Autowired
    private IBarcodeManager barcodeManager;
    @Autowired
    private IStorageManager storageManager;
    @Autowired
    private IStoragePosManager storagePosManager;
    @Autowired
    private DataCache dataCache;

    public FileUploadController() {
        setCancelView("redirect:/home");
        setSuccessView("uploadDisplay");
    }

    @ModelAttribute
    @RequestMapping(method = RequestMethod.GET)
    public FileUpload showForm() {
        return new FileUpload();
    }

    @RequestMapping(method = RequestMethod.POST)
    public String onSubmit(
                          /** FileUpload fileUpload, BindingResult errors,*/ HttpServletRequest request) throws Exception {

        String type = request.getParameter("type");
        String param = request.getParameter("param");
        if (request.getParameter("cancel") != null) {
            return getCancelView();
        }

//        if (validator != null) { // validator is null during testing
//            validator.validate(fileUpload, errors);
//
//            if (errors.hasErrors()) {
//                return "fileupload";
//            }
//        }

        // validate a file was entered
//        /*if (fileUpload.getFile().length == 0) {
//            Object[] args = new Object[]{getText("uploadForm.file", request.getLocale())};
//            errors.rejectValue("file", "errors.required", args, "File");
//
//            return "fileupload";
//        }*/

        MultipartHttpServletRequest multipartRequest = (MultipartHttpServletRequest) request;
        CommonsMultipartFile file = (CommonsMultipartFile) multipartRequest.getFile("file");

        // the directory to upload to
        String uploadDir = getServletContext().getRealPath("/resources");

        // The following seems to happen when running jetty:run
        if (uploadDir == null) {
            uploadDir = new File("src/main/webapp/resources").getAbsolutePath();
        }
        uploadDir += "/" + request.getRemoteUser() + "/";

        // Create the directory if it doesn't exist
        File dirPath = new File(uploadDir);

        if (!dirPath.exists()) {
            dirPath.mkdirs();
        }

        //retrieve the file data
        InputStream stream = file.getInputStream();

        //write the file to the file specified
        OutputStream bos = new FileOutputStream(uploadDir + file.getOriginalFilename());
        int bytesRead;
        byte[] buffer = new byte[8192];

        while ((bytesRead = stream.read(buffer, 0, 8192)) != -1) {
            bos.write(buffer, 0, bytesRead);
        }

        bos.close();

        //close the stream
        stream.close();

        // place the data into the request for retrieval on next page
        request.setAttribute("friendlyName", request.getAttribute("name"));
        request.setAttribute("fileName", file.getOriginalFilename());
        request.setAttribute("contentType", file.getContentType());
        request.setAttribute("size", file.getSize() + " bytes");
        String fileURL = dirPath.getAbsolutePath() + Constants.FILE_SEP + file.getOriginalFilename();
        request.setAttribute("location", fileURL);

        String link = request.getContextPath() + "/resources" + "/" + request.getRemoteUser() + "/";
        request.setAttribute("link", link + file.getOriginalFilename());
        log.debug("Upload file is saved as: " + fileURL);
        if (!StringUtils.isEmpty(type)) {
            log.debug("Upload file type is: " + type);
            try {
                if (StorageConstants.COMPONENT.equals(type)) {
                    return handleComponent(fileURL);
                } else if (StorageConstants.BARCODE_TYPE.equals(type)) {
                    return handleBarcode(fileURL);
                } else if (StorageConstants.STORAGE_TYPE.equals(type)) {
                    String message = handleStoragePos(fileURL, param);
                    saveMessage(request,message);
                }
            } catch (ExcelParseException e) {
                log.error(e);
                log.error(e.getMessage());
                saveError(request, e.getMessage());
            } catch (IOException ioe) {
                log.error(ioe);
                log.error(ioe.getMessage());
                saveError(request, getText("errors.upload.fileNotExist", request.getLocale()));
            } catch (ValidateException ve) {
                String errorMsg = getText(ve.getMessage(), ve.getParams(), request.getLocale());
                log.error(ve);
                log.error(errorMsg);
                saveError(request, errorMsg);
            } finally {
                if (StorageConstants.COMPONENT.equals(type)) {
                    return StorageConstants.COMPONENT_SEARCH_VIEW;
                }  else if (StorageConstants.BARCODE_TYPE.equals(type)) {
                    return StorageConstants.BARCODE_SEARCH_VIEW;
                } else if (StorageConstants.STORAGE_TYPE.equals(type)) {
                    return StorageConstants.STORAGE_UPDATE_VIEW + "?id=" + param;
                }
            }
        }

        return getSuccessView();
    }



    protected String handleComponent(String fileURL) throws ExcelParseException, IOException, ValidateException, IllegalAccessException, InvocationTargetException {
        ComponentXlsParser componentXlsParser = new ComponentXlsParser();
        List<ComponentExcel> list = componentXlsParser.readXls(fileURL);
        log.debug("Parse component to list with size: " + list.size());
        if (list != null && list.size() > 0) {
            for (ComponentExcel componentExcel : list) {
                Component component = componentManager.findOneByPn(componentExcel.getPartNumber());
                if (component == null) {
                    component = new Component();
                }
                BeanUtils.copyProperties(component, componentExcel);
                componentManager.save(component);
            }
        }
        return StorageConstants.COMPONENT_SEARCH_VIEW;
    }

    protected String handleBarcode(String fileURL) throws ExcelParseException, IOException, ValidateException, IllegalAccessException, InvocationTargetException {
//        BarcodeXlsParser barcodeXlsParser = new BarcodeXlsParser();
//        List<BarcodeExcel> list = barcodeXlsParser.readXls(fileURL);
//        log.debug("Parse barcode to list with size: " + list.size());
//        if (list != null && list.size() > 0) {
//            for (BarcodeExcel barcodeExcel : list) {
//                Barcode barcode = barcodeManager.findByBarcode(barcodeExcel.getBarcode());
//                if (barcode == null) {
//                    barcode = new Barcode();
//                } else if (barcode.isUsed()) {
//                    log.error("Barcode: " + barcode.getBarcode() + " is already used, can't import again.");
//                    throw new ValidateException("barcode.error.used", new String[]{barcode.getBarcode()});
//                }
//                BeanUtils.copyProperties(barcode, barcodeExcel);
//                barcode.setUsed(false);
//                barcodeManager.save(barcode);
//            }
//        }
//        return StorageConstants.BARCODE_SEARCH_VIEW;
        log.info("开始更新条码信息");

//        CsvReader csvRead = new CsvReader(fileURL);
//        csvRead.setSkipEmptyRecords(true);//忽略空行
//        csvRead.setTrimWhitespace(true);//去除空格
//        csvRead.readHeaders();

        CsvReader csvRead = CsvReader.newReader(fileURL,"PN");

        int reelIdIndex = csvRead.getIndex("RI");
        int partNumberIndex = csvRead.getIndex("PN");
        if (partNumberIndex == -1){
            log.info("未包含PN列");
            return "必须包含PN列";
        }
        int qtyIndex = csvRead.getIndex("QTY");
        if (qtyIndex == -1){
            log.info("未包含【QTY】列");
            return "必须包含【QTY】列";
        }
        int barcodeCount = 0;
        while(csvRead.readRecord()){
            String[] lineValues = csvRead.getValues();
            String reelId = System.currentTimeMillis() + "";
            if(reelIdIndex != -1){
                String reelIdStr = lineValues[reelIdIndex];
                if(reelIdStr != null && !reelIdStr.isEmpty()){
                    reelId = reelIdStr;
                }
            }
            int qty = 1;
            if(qtyIndex != -1){
                try{
                    qty = Integer.valueOf(lineValues[qtyIndex]);
                }catch (Exception e){

                }
            }
            String partNumber = lineValues[partNumberIndex];

            if(partNumber.isEmpty()){
                log.warn("行[partNumber="+partNumber + ","+"reelId="+reelId+",qty="+qty+"]中PN 为空,此行忽略");
            }else{
                Component component = componentManager.findOneByPn(partNumber);
                if(component == null){
                    log.info("未找到["+ partNumber+"]的档案,创建新的数量为["+qty+"]档案");
                    component = new Component();
                    component.setPartNumber(partNumber);
                    component.setAmount(qty);
                    component = componentManager.save(component);
                }
                Barcode barcode = barcodeManager.findByBarcode(reelId);
                if(barcode == null){
                    barcode = new Barcode();
                }
                barcode.setBarcode(reelId);
                barcode.setPartNumber(partNumber);
                barcode.setInitialAmount(component.getAmount());
                barcode.setAmount(qty);
                barcodeManager.save(barcode);
                barcodeCount++;
            }
        }

        String msg = "操作完成,共保存["+barcodeCount+"]个条码信息";
        log.info(msg);

        return msg;
    }

    /**
     *
     * @param fileURL
     * @param params
     * @return
     */
    protected String handleStoragePos(String fileURL, String params) throws ExcelParseException, IOException, ValidateException, IllegalAccessException, InvocationTargetException
    {
        log.info("开始更新料仓【"+params+"】的位置信息");
        if (StringUtils.isEmpty(params)) {
            log.error("Storage id is null");
            throw new ValidateException("storage.error.notExist");
        }
        Storage storage = storageManager.get(params);
        if (storage == null) {
            log.error("Storage id is not exist");
            throw new ValidateException("storage.error.notExist");
        }
//        CsvReader csvRead = new CsvReader(fileURL);
//        csvRead.setSkipEmptyRecords(true);//忽略空行
//        csvRead.setTrimWhitespace(true);//去除空格
//        csvRead.readHeaders();

        CsvReader csvRead = CsvReader.newReader(fileURL,"位置","pos");

        int posIndex = csvRead.getIndex("位置");
        if(posIndex == -1){
            posIndex = csvRead.getIndex("pos");
            if(posIndex == -1){
                log.info("未包含【位置】或【pos】列");
                return "必须包含[位置]列";
            }
        }
        int priIndex = csvRead.getIndex("优先级");
        if (priIndex == -1){
            priIndex = csvRead.getIndex("pri");
            if(priIndex == -1){
                log.info("未包含【优先级】或【pri】列");
                return "必须包含[优先级]列";
            }
        }
        int hIndex = csvRead.getIndex("高度");
        if (hIndex == -1){
            hIndex = csvRead.getIndex("h");
            if(hIndex == -1){
                log.info("未包含【高度】或【h】列");
                return "必须包含【高度】列";
            }
        }
        int wIndex = csvRead.getIndex("宽度");
        if (wIndex == -1){
            wIndex = csvRead.getIndex("w");
            if(wIndex == -1){
                log.info("未包含【宽度】或【w】列");
                return "必须包含【宽度】列";
            }
        }
        List<StoragePosExcel> list = new ArrayList<StoragePosExcel>();
        while(csvRead.readRecord()){
            String[] lineValues = csvRead.getValues();
            String posName = lineValues[posIndex];
            String priorityStr = lineValues[priIndex];
            String hStr = lineValues[hIndex];
            String wStr = lineValues[wIndex];
            if(posName.isEmpty() || priorityStr.isEmpty() || hStr.isEmpty() || wStr.isEmpty()){
                log.warn("行[posName="+posName + ","+"priority="+priorityStr+",h="+hStr+",w="+wStr+"]中有空白内容,此行忽略");
            }else{
                StoragePosExcel posInfo = new StoragePosExcel();
                posInfo.setPosName(posName);
                posInfo.setPriority(Double.valueOf(priorityStr));
                posInfo.setH(Integer.valueOf(hStr));
                posInfo.setW(Integer.valueOf(wStr));
                list.add(posInfo);
            }
        }
        int newRowCount = 0;
        int existRowCount=0;
        int updateRowCount = 0;
        List<StoragePos> storagePosList=storagePosManager.findByStorage(storage.getId());
        List<StoragePos> newList=new ArrayList<>();
        if (list != null && list.size() > 0) {
            for (StoragePosExcel storagePosExcel : list) {
//                StoragePos storagePos = storagePosManager.findByStorage(storage.getId(), storagePosExcel.getPosName());
                StoragePos storagePos =findFormList(storagePosList,storage.getId(),storagePosExcel.getPosName());
                if (storagePos == null) {
                    storagePos = new StoragePos();
                    newRowCount ++;
                    storagePos.setPosName(storagePosExcel.getPosName());
                    storagePos.setPriority(storagePosExcel.getPriority());
                    storagePos.setW(storagePosExcel.getW());
                    storagePos.setH(storagePosExcel.getH());
                    storagePos.setStorageId(storage.getId());
                    Point point= PointUtil.getPosPoint(storagePos.getPosName());
                    storagePos.setCoordinate(new double[]{point.getX(),point.getY()});
                    newList.add(storagePos);
                }else{
                    boolean needUpdate=false;
                    if(!storagePos.getPosName().equals(storagePosExcel.getPosName())){
                        needUpdate=true;
                        storagePos.setPosName(storagePosExcel.getPosName());
                    }
//                    if(storagePos.getPriority()!=storagePosExcel.getPriority()) {
//                        needUpdate=true;
//                        storagePos.setPriority(storagePosExcel.getPriority());
//                    }
                    if(storagePos.getW()!=storagePosExcel.getW()) {
                        needUpdate=true;
                        storagePos.setW(storagePosExcel.getW());
                    }
                    if(storagePos.getH()!=storagePosExcel.getH()) {
                        needUpdate=true;
                        storagePos.setH(storagePosExcel.getH());
                    }
                    if(!storagePos.getStorageId().equals(storage.getId())){
                        needUpdate=true;
                        storagePos.setStorageId(storage.getId());
                    }
                    Point point= PointUtil.getPosPoint(storagePos.getPosName());
                    if(storagePos.getCoordinate()==null||storagePos.getCoordinate().length!=2||
                            (storagePos.getCoordinate()[0]!=point.getX()) ||(storagePos.getCoordinate()[1]!=point.getY())){
                        needUpdate=true;
                        storagePos.setCoordinate(new double[]{point.getX(),point.getY()});
                    }
                    if(needUpdate){
                        updateRowCount ++;
                        storagePosManager.save(storagePos);
                    }else{
                        existRowCount++;
                    }
                }
            }
            if(newList.size()>0){
                storagePosManager.insertAll(newList);
            }
        }
        dataCache.reloadStorage(storage);
        String msg = "读取到["+list.size()+"]个位置信息:新增【"+newRowCount+"】，已存在【"+existRowCount+"】，更新【" +updateRowCount +"】";
        log.info(msg);

        return msg;
    }

    private StoragePos findFormList(List<StoragePos> list,String storageId,String posName)
    {
        for (StoragePos pos :
                list) {
            if(pos.getStorageId().equals(storageId)&&pos.getPosName().equals(posName)){
                return pos;
            }
        }
        return null;
    }

    /*protected String handleStoragePos(String fileURL, String params) throws ExcelParseException, IOException, ValidateException, IllegalAccessException, InvocationTargetException {
        if (StringUtils.isEmpty(params)) {
            log.error("Storage id is null");
            throw new ValidateException("storage.error.notExist");
        }
        Storage storage = storageManager.get(params);
        if (storage == null) {
            log.error("Storage id is not exist");
            throw new ValidateException("storage.error.notExist");
        }

        StoragePosXlsParser storagePosXlsParser = new StoragePosXlsParser();
        List<StoragePosExcel> list = storagePosXlsParser.readXls(fileURL);
        log.debug("Parse storagePos to list with size: " + list.size());
        if (list != null && list.size() > 0) {
            for (StoragePosExcel storagePosExcel : list) {
                StoragePos storagePos = storagePosManager.findByStorage(storage.getId(), storagePosExcel.getPosName());
                if (storagePos == null) {
                    storagePos = new StoragePos();
                }
                BeanUtils.copyProperties(storagePos, storagePosExcel);
                storagePos.setStorageId(storage.getId());
                storagePosManager.save(storagePos);
            }
        }
        return StorageConstants.STORAGE_UPDATE_VIEW + "?id=" + params;
    }*/

    public void setComponentManager(IComponentManager componentManager) {
        this.componentManager = componentManager;
    }


    public void setBarcodeManager(IBarcodeManager barcodeManager) {
        this.barcodeManager = barcodeManager;
    }

    public void setStorageManager(IStorageManager storageManager) {
        this.storageManager = storageManager;
    }

    public void setStoragePosManager(IStoragePosManager storagePosManager) {
        this.storagePosManager = storagePosManager;
    }
}