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.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.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 org.springframework.web.servlet.ModelAndView;
import org.springframework.web.servlet.view.RedirectView;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
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("fileUpload");
    }

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

    @RequestMapping(method = RequestMethod.POST)
    public String onSubmit(
            /** FileUpload fileUpload, BindingResult errors,*/ HttpServletRequest request, HttpServletResponse response) 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.info("收到上传["+type+"]文件: " + fileURL);
        if (!StringUtils.isEmpty(type)) {
            log.info("Upload file type is: " + type);
            try {
                if (StorageConstants.COMPONENT.equals(type)) {
                    String message =  handleComponent(fileURL,request);
                    saveMessage(request,message);

                } else if (StorageConstants.BARCODE_TYPE.equals(type)) {
                    handleBarcode(fileURL);
                } else if (StorageConstants.STORAGE_TYPE.equals(type)) {
                    handleStoragePos(fileURL, param);
                    //saveMessage(request,message);
                }
            } catch (ExcelParseException e) {
                log.error("ExcelParseException文件解析失败",e);
                saveError(request, e.getMessage());
            } catch (IOException ioe) {
                log.error("IOException文件解析失败",ioe);
                saveError(request, getText("errors.upload.fileNotExist", request.getLocale()));
            } catch (Exception ve) {
                log.error("文件解析失败",ve);
                saveError(request, ve.getMessage());
            } finally {
                if (StorageConstants.COMPONENT.equals(type)) {
                    //response.sendRedirect(request.getContextPath() + StorageConstants.COMPONENT_SEARCH_VIEW);
                    return StorageConstants.COMPONENT_SEARCH_VIEW;
                   // return null;
                } 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, HttpServletRequest request) throws ExcelParseException, IOException, ValidateException, IllegalAccessException, InvocationTargetException {

        log.info("开始读取文件:" + fileURL);
        CsvReader csvRead = new CsvReader(fileURL);
        csvRead.setSkipEmptyRecords(true);//忽略空行
        csvRead.setTrimWhitespace(true);//去除空格
        csvRead.readHeaders();

        int pnIndex = csvRead.getIndex("物编","PN");
        if(pnIndex == -1){
            String errorMsg = getText("error.file.culumn.required",new String[]{"PN"},request.getLocale(),"未包含【物编】或【PN】列");
            throw new ValidateException(errorMsg);
        }
        int qtyIndex = csvRead.getIndex("数量","count","QTY");
//        if (qtyIndex == -1){
//            log.info("未包含【数量】或【count】列");
//            throw new ValidateException("必须包含【数量】或【count】列");
//        }
//
        int wIndex = csvRead.getIndex("宽度","W");

        if (wIndex == -1){
            String errorMsg = getText("error.file.culumn.required",new String[]{"W"},request.getLocale(),"必须包含【宽度】或[W]列");
            throw new ValidateException(errorMsg);
        }

        int hIndex = csvRead.getIndex("高度","H");
        if (hIndex == -1){
            String errorMsg = getText("error.file.culumn.required",new String[]{"H"},request.getLocale(),"必须包含【高度】或[H]列");
            throw new ValidateException(errorMsg);
        }

        int supplierIndex = csvRead.getIndex("供应商","supplier","SP");
//        if (supplierIndex == -1){
//            log.info("未包含【供应商】或【supplier】列");
//            throw new ValidateException("必须包含【供应商】或【supplier】列");
//        }

//        int spnIndex = csvRead.getIndex("供应商PN","SPN");

//        int typeIndex = csvRead.getIndex("类型","type");
//        if (typeIndex == -1){
//            log.info("未包含【类型】或【type】列");
//            return "必须包含【类型】或【type】列";
//        }

        List<Component> list = new ArrayList<Component>();
        while(csvRead.readRecord()){
            String[] lineValues = csvRead.getValues();
            String pn = lineValues[pnIndex];

            String qtyStr = "1";
            if(qtyIndex != -1){
                qtyStr = lineValues[qtyIndex];
            }

//            String spn = "";
//            if(spnIndex != -1){
//                spn = lineValues[spnIndex];
//            }

            String wStr = lineValues[wIndex];
            String hStr = lineValues[hIndex];
            String supplier = "";
            if(supplierIndex != -1){
                supplier = lineValues[supplierIndex];
            }

            //String typeStr = lineValues[typeIndex];
            if(pn.isEmpty() || wStr.isEmpty() || hStr.isEmpty()){
                log.warn("行[PN="+pn+"w="+wStr+" h="+hStr+"]中有空白内容,此行忽略");
            }else{
                Component component = new Component();
                component.setName(pn);
                component.setPartNumber(pn);
                component.setAmount(Integer.valueOf(qtyStr));

                component.setPlateSize(Integer.valueOf(wStr));
                component.setHeight(Integer.valueOf(hStr));

                component.setProvider(supplier);

//                component.setSupplierPn(spn);

                //component.setType(Integer.valueOf(typeStr));
                list.add(component);
            }
        }
        log.info("共读取["+list.size()+"]行数据");
        int newRowCount = 0;
        int updateRowCount = 0;
        if (list != null && list.size() > 0) {
            for (Component c : list) {
                Component component = componentManager.findByPartNumberAndProvider(c.getPartNumber(),c.getProvider());
                if (component == null) {
                    component = c;
                    newRowCount ++;
                }else{
                    component.setPartNumber(c.getPartNumber());
                    component.setName(c.getPartNumber());
                    component.setAmount(c.getAmount());
                    component.setPlateSize(c.getPlateSize());
                    component.setHeight(c.getHeight());
                    component.setProvider(c.getProvider());
                    component.setType(c.getType());
                    updateRowCount ++;
                }

                componentManager.save(component);
            }
        }
        String totalNumStr = String.valueOf(list.size());
        String addNumStr = String.valueOf(newRowCount);
        String updateNumStr = String.valueOf(updateRowCount);
        String msg = getText("file.upload.result",new String[]{totalNumStr,addNumStr,updateNumStr},request.getLocale(),"读取到["+totalNumStr+"]个物料信息:新增【"+addNumStr+"】更新【" +updateNumStr +"】个");
        log.info(msg);
        return msg;
    }

    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;
    }

    /**
     *
     * @param fileURL
     * @param params
     * @return
     */
    protected void 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();
        int posIndex = csvRead.getIndex("位置","pos");
        if(posIndex == -1){
            log.info("未包含【位置】或【pos】列");
            throw new ValidateException("必须包含[位置]列");
        }
        int priIndex = csvRead.getIndex("优先级","pri");
        if (priIndex == -1){
            log.info("未包含【优先级】或【pri】列");
            throw new ValidateException("必须包含[优先级]列");
        }
        int hIndex = csvRead.getIndex("高度","h");
        if (hIndex == -1){
            log.info("未包含【高度】或【h】列");
            throw new ValidateException("必须包含【高度】列");
        }
        int wIndex = csvRead.getIndex("宽度","w");
        if (wIndex == -1){
            log.info("未包含【宽度】或【w】列");
            throw new ValidateException("必须包含【宽度】列");
        }
        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 updateRowCount = 0;
        if (list != null && list.size() > 0) {
            for (StoragePosExcel storagePosExcel : list) {
                StoragePos storagePos = storagePosManager.findByStorage(storage.getId(), storagePosExcel.getPosName());
                if (storagePos == null) {
                    storagePos = new StoragePos();
                    newRowCount ++;
                }else{
                    updateRowCount ++;
                }
                storagePos.setPosName(storagePosExcel.getPosName());
                storagePos.setPriority(storagePosExcel.getPriority());
                storagePos.setW(storagePosExcel.getW());
                storagePos.setH(storagePosExcel.getH());
                storagePos.setStorageId(storage.getId());
                storagePosManager.save(storagePos);
            }
        }
        dataCache.reloadStorage(storage);
        String msg = "读取到["+list.size()+"]个位置信息:新增【"+newRowCount+"】更新【" +updateRowCount +"】";
        log.info(msg);
    }

    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;
    }
}