package cn.com.goldenwater.dcproj.utils.impexcel;

import cn.com.goldenwater.dcproj.dao.AttAdXBaseDao;
import cn.com.goldenwater.dcproj.dao.AttRsBaseDao;
import cn.com.goldenwater.dcproj.dao.AttRsBaseFjDao;
import cn.com.goldenwater.dcproj.model.AttAdXBase;
import cn.com.goldenwater.dcproj.model.AttRsBase;
import cn.com.goldenwater.dcproj.model.AttRsBaseFj;
import cn.com.goldenwater.dcproj.param.AttAdXBaseParam;
import cn.com.goldenwater.dcproj.param.AttRsBaseParam;
import cn.com.goldenwater.dcproj.service.AttRsBaseService;
import cn.com.goldenwater.dcproj.socket.WebSocketServer;
import org.apache.commons.collections.MapUtils;
import org.apache.commons.lang.StringUtils;
import org.apache.poi.hssf.usermodel.HSSFWorkbook;
import org.apache.poi.ss.usermodel.Cell;
import org.apache.poi.ss.usermodel.Row;
import org.apache.poi.ss.usermodel.Sheet;
import org.apache.poi.ss.usermodel.Workbook;
import org.apache.poi.xssf.usermodel.XSSFWorkbook;
import org.springframework.beans.factory.annotation.Autowired;

import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.*;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

import static cn.com.goldenwater.dcproj.utils.export.FieldFormatDispatch.getFormatValue;
import static cn.com.goldenwater.dcproj.utils.impexcel.ImpUtil.XLS;
import static cn.com.goldenwater.dcproj.utils.impexcel.ImpUtil.checkIsDate;

/**
 * <p>
 * 导入工具类
 *
 * </p>
 *
 * @author liyz
 * @date 2019/4/10 19:43
 */
public class ImpRsExcel {

    private static final SimpleDateFormat SIMPLE_DATE_FORMAT = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss:SSS");
    private static final String EMPTY = "";
    @Autowired
    private AttRsBaseDao attRsBaseDao;
    @Autowired
    private AttAdXBaseDao attAdXBaseDao;
    @Autowired
    private AttRsBaseService attRsBaseService;
    @Autowired
    private AttRsBaseFjDao attRsBaseFjDao;

    public static void main(String[] args) {
        String filePath = "D:\\最新福建省水库名录20200227.xls";
        int startRow = 0;
        int endRow = 0;

        try {
            //List<HashMap> bookList = (List<HashMap>) ImpRsExcel.importExcel(filePath, startRow, endRow, HashMap.class, "", "sk");
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    /**
     * 正则表达式 用于匹配属性的第一个字母
     */
    private static final String REGEX = "[a-zA-Z]";

    /**
     * 功能: Excel数据导入到数据库
     * 参数: originUrl[Excel表的所在路径]
     * 参数: startRow[从第几行开始]
     * 参数: endRow[到第几行结束
     * (0表示所有行;
     * 正数表示到第几行结束;
     * 负数表示到倒数第几行结束)]
     * 参数: clazz[要返回的对象集合的类型]
     */
    public void importExcel(String originUrl, int startRow, int endRow, Class<?> clazz, String sid, String type) throws Exception {
        //是否打印提示信息
        boolean showInfo = true;
        //doImportExcel(originUrl, startRow, endRow, showInfo, clazz, sid, type);
    }


    /**
     * 功能：判断文件是否存在
     */
    public static File isExist(String originUrl) throws IOException {
        // 判断文件是否存在
        File file = new File(originUrl);
        if (!file.exists()) {
            throw new IOException("文件名为" + file.getName() + "Excel文件不存在！");
        }
        return file;
    }


    /**
     * 功能:真正实现导入
     */
    public void doImportExcel(String originUrl, int startRow, int endRow, boolean showInfo, Class<?> clazz,
                              String sid, String type,AttAdXBaseDao attAdXBaseDao1,AttRsBaseFjDao attRsBaseFjDao1
    ,AttRsBaseService attRsBaseService1,AttRsBaseDao attRsBaseDao1) throws IOException, ParseException {
        attAdXBaseDao = attAdXBaseDao1;
        attRsBaseFjDao = attRsBaseFjDao1;
        attRsBaseService = attRsBaseService1;
        attRsBaseDao = attRsBaseDao1;
        // 判断文件是否存在
        File file = isExist(originUrl);

        HSSFWorkbook wb = null;
        FileInputStream fis = null;
        List<Row> rowList = new ArrayList<Row>();
        try {
            fis = new FileInputStream(file);
            // 去读Excel
            wb = new HSSFWorkbook(fis);
            Sheet sheet = wb.getSheetAt(0);
            // 获取最后行号
            int lastRowNum = sheet.getLastRowNum();
            // 如果>0，表示有数据
            if (lastRowNum > 0) {
                out("\n开始读取并校验名为【" + sheet.getSheetName() + "】的内容：", showInfo, sid);
                WebSocketServer.sendInfo(SIMPLE_DATE_FORMAT.format(new Date()) + "-②开始读取并校验名为【" + sheet.getSheetName() + "】的内容", sid);
            }
            List<String> keys = new ArrayList<>();
            Row keyRow = sheet.getRow(0);
            for (int i = 0; i < keyRow.getPhysicalNumberOfCells(); i++) {
                keys.add(keyRow.getCell(i).toString());
            }
            Row row = null;
            // 循环读取
            for (int i = startRow; i <= lastRowNum + endRow; i++) {
                row = sheet.getRow(i);
                HashMap<String, String> map = new LinkedHashMap<>();
                if (row != null) {
                    rowList.add(row);

                    // 获取每一单元格的值
                    for (int j = 0; j < row.getLastCellNum(); j++) {
                        String value = getCellValue(row.getCell(j));
                        if(j<keys.size()){
                            map.put(keys.get(j), value);
                        }
                    }
                    String adCd="";
                    Map<String, String> ads = getAdCds("福建省",map.get("所在市"),map.get("归属地"));
                    String provinceCode = "350000000000";
                    String cityCode = ads.get("shi");
                    String countryCode = ads.get("xian");
                    if(org.apache.commons.lang3.StringUtils.isNotBlank(countryCode)){
                        adCd = countryCode;
                    }else if(org.apache.commons.lang3.StringUtils.isNotBlank(cityCode)){
                        adCd = cityCode;
                    }else if(org.apache.commons.lang3.StringUtils.isNotBlank(provinceCode)){
                        adCd = provinceCode;
                    }
                    if(StringUtils.isEmpty(countryCode)){
                        System.out.println("行政区划未找到："+map.get("所在市")+"--"+map.get("归属地")+"--"+map.get("水库名称"));
                    }
                    Map<String, String> mapRs = checkRsBase(map.get("水库名称"), countryCode);
                    String rsCode = mapRs.get("rsCode");
                    AttRsBaseFj attRsBase = new AttRsBaseFj();
                    if(StringUtils.isNotBlank(rsCode)){
                        attRsBase = attRsBaseFjDao.get(rsCode);
                    }
                    attRsBase.setRsName(map.get("水库名称"));
                    attRsBase.setEngScal(encagl(map.get("工程规模")));
                    attRsBase.setAdmDiv(adCd);
                    attRsBase.setAdmDivName(map.get("归属地"));
                    attRsBase.setLocation("福建省-"+map.get("所在市")+"-"+map.get("归属地"));
                    attRsBase.setRsAdmName(map.get("管理单位名称"));
                    attRsBase.setRegCode(map.get("注册登记号"));
                    attRsBase.setRsClass(map.get("功能类别"));
                    SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd");//注意月份是MM
                    if(StringUtils.isNotEmpty(map.get("下闸蓄水时间"))){
                        Date date = simpleDateFormat.parse(map.get("下闸蓄水时间"));
                        attRsBase.setImpdDt(date);
                    }
                    if(StringUtils.isNotEmpty(map.get("最近一次加固改造_蓄水运行时间"))){
                        Date date = simpleDateFormat.parse(map.get("最近一次加固改造_蓄水运行时间"));
                        attRsBase.setRnfcImpdDt(date);
                    }
                    if(StringUtils.isNotEmpty(map.get("总库容"))){
                        attRsBase.setTotCap(Double.parseDouble(map.get("总库容")));
                    }

                    attRsBase.setDamType(map.get("主坝坝型"));
                    attRsBase.setDamTypeMat(typeMat(map.get("主坝坝型")));
                    attRsBase.setDamTypeStr(typeStr(map.get("主坝坝型")));
                    if(StringUtils.isNotEmpty(map.get("主坝最大坝高"))){
                        attRsBase.setDamSizeHig(Double.parseDouble(map.get("主坝最大坝高")));
                    }
                    if(StringUtils.isNotEmpty(map.get("设计洪水位"))){
                        attRsBase.setDesFlStag(Double.parseDouble(map.get("设计洪水位")));
                    }
                    if(StringUtils.isNotEmpty(map.get("防洪高水位"))){
                        attRsBase.setFlConTopStag(Double.parseDouble(map.get("防洪高水位")));
                    }
                    attRsBase.setEdtrPesr("福建");
                    attRsBase.setWiunWaoLegPers(map.get("行政责任人"));
                    attRsBase.setWiunWaoLegPersUnit(map.get("行政责任人工作单位"));
                    attRsBase.setWiunWaoLegPersDuty(map.get("行政责任人职务"));
                    attRsBase.setWiunWaoLegPersTel(map.get("行政责任人联系方式"));
                    attRsBase.setTechPers(map.get("技术责任人"));
                    attRsBase.setTechPersUnit(map.get("技术责任人工作单位"));
                    attRsBase.setTechPersDuty(map.get("技术责任人职务"));
                    attRsBase.setTechPersTel(map.get("技术责任人联系方式"));
                    attRsBase.setPatrolPers(map.get("巡查责任人"));
                    attRsBase.setPatrolPersUnit(map.get("巡查责任人工作单位"));
                    attRsBase.setPatrolPersDuty(map.get("巡查责任人职务"));
                    attRsBase.setPatrolPersTel(map.get("巡查责任人联系方式"));
                    attRsBase.setUptm(new Date());
                    attRsBase.setRegNo(i+1+"");
                    if(StringUtils.isEmpty(rsCode)){
                        String str = attRsBaseFjDao.findMax(countryCode.substring(0,6));
                        if(StringUtils.isEmpty(str)){
                            str = countryCode;
                        }
                        long a = Long.parseLong(str)+1;
                        rsCode = a+"";
                        attRsBase.setRsCode(rsCode);
                        out("第" + (i + 1) + "行：", showInfo, false, sid);
                        System.out.println(attRsBase.toString());
                        attRsBaseFjDao.insert(attRsBase);
                    }else {
                        attRsBase.setRsCode(rsCode);
                        attRsBaseFjDao.insert(attRsBase);
                    }
                }
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            wb.close();
        }
        //return returnObjectList(rowList, type, sid);
    }


    /**
     * 功能:获取单元格的值
     */
    private static String getCellValue(Cell cell) {
        Object result = "";
        if (cell != null) {
            switch (cell.getCellType()) {
                case STRING:
                    result = cell.getStringCellValue();
                    break;
                case NUMERIC:
                    result = cell.getNumericCellValue();
                    break;
                case BOOLEAN:
                    result = cell.getBooleanCellValue();
                    break;
                case FORMULA:
                    result = cell.getCellFormula();
                    break;
                case ERROR:
                    result = cell.getErrorCellValue();
                    break;
                case BLANK:
                    break;
                default:
                    break;
            }
        }
        return result.toString();
    }

    /**
     * 功能:返回指定的对象集合
     */
    private static List<Object> returnObjectList(List<Row> rowList, String type, String sid) {
        List<Object> objectList = null;
        List<String> keys = new ArrayList<>();
        Row keyRow = rowList.get(0);

        for (int i = 0; i < keyRow.getPhysicalNumberOfCells(); i++) {
            keys.add(keyRow.getCell(i).toString());
        }
        try {
            objectList = new ArrayList<>();
            for (int i = 1; i < rowList.size(); i++) {
                Row row = rowList.get(i);
                HashMap<String, String> map = new LinkedHashMap<>();
                int check = 0;
                for (int j = 0; j < keys.size(); j++) {
                    // 此单元格的值
                    String cellValue = getCellValue(row.getCell(j));
                    // 格式化后的值
                    String formatValue = getFormatValue(type, keys.get(j), cellValue, true).toString();
                    map.put(keys.get(j), formatValue);
                    // 先不格式化
//                    map.put(keys.get(j), getCellValue(row.getCell(j)));
                    // 错误的话输出一下
                    if (formatValue.contains("$E$")) {
                        check++;
                        WebSocketServer.sendInfo(SIMPLE_DATE_FORMAT.format(new Date()) + "-第" + (i + 5) + "行[" + cellValue + "]填写有误,请查看弹出信息,并重新上传模板！", sid);
                    }
                }
                if (check == 0 && row.getCell(2) != null && !"".equals(row.getCell(2).toString())) {
                    WebSocketServer.sendInfo(SIMPLE_DATE_FORMAT.format(new Date()) + "-第" + (i + 5) + "行验证完毕，数据无误。", sid);
                }
                objectList.add(map);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        return objectList;
    }

    /**
     * 功能:返回指定的对象集合,（有单表实体类时可用）
     */
    private static List<Object> returnObjectList(List<Row> rowList, Class<?> clazz) {
        List<Object> objectList = null;
        Object obj = null;
        String attribute = null;
        String value = null;
        int j = 0;
        try {
            objectList = new ArrayList<Object>();
            Field[] declaredFields = clazz.getDeclaredFields();
            for (Row row : rowList) {
                j = 0;
                obj = clazz.newInstance();
                for (Field field : declaredFields) {
                    attribute = field.getName().toString();
                    value = getCellValue(row.getCell(j));
                    setAttrributeValue(obj, attribute, value);
                    j++;
                }
                objectList.add(obj);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        return objectList;
    }

    /**
     * 功能:给指定对象的指定属性赋值
     */
    public static void setAttrributeValue(Object obj, String attribute, String value) {
        //得到该属性的set方法名
        String methodName = convertToMethodName(attribute, obj.getClass(), true);
        Method[] methods = obj.getClass().getMethods();
        for (Method method : methods) {
            /*
             因为这里只是调用bean中属性的set方法，属性名称不能重复
             所以set方法也不会重复，所以就直接用方法名称去锁定一个方法
             (注：在java中，锁定一个方法的条件是方法名及参数）
             */
            if (method.getName().equals(methodName)) {
                Class<?>[] parameterC = method.getParameterTypes();
                try {
                    /*
                     如果是(整型,浮点型,布尔型,字节型,时间类型,Long类型),
                     按照各自的规则把value值转换成各自的类型
                     否则一律按类型强制转换(比如:String类型)
                     */
                    if (parameterC[0] == int.class || parameterC[0] == Integer.class) {
                        value = value.substring(0, value.lastIndexOf("."));
                        method.invoke(obj, Integer.valueOf(value));
                        break;
                    } else if (parameterC[0] == float.class || parameterC[0] == Float.class) {
                        method.invoke(obj, Float.valueOf(value));
                        break;
                    } else if (parameterC[0] == double.class || parameterC[0] == Double.class) {
                        if (value != null && !"".equals(value)) {
                            method.invoke(obj, Double.valueOf(value));
                        }
                        break;
                    } else if (parameterC[0] == long.class || parameterC[0] == Long.class) {
                        if (value != null && !"".equals(value)) {
                            method.invoke(obj, Long.valueOf(value));
                        }
                        break;
                    } else if (parameterC[0] == byte.class || parameterC[0] == Byte.class) {
                        method.invoke(obj, Byte.valueOf(value));
                        break;
                    } else if (parameterC[0] == boolean.class || parameterC[0] == Boolean.class) {
                        method.invoke(obj, Boolean.valueOf(value));
                        break;
                    } else if (parameterC[0] == Date.class) {
                        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
                        Date date = null;
                        try {
                            if (StringUtils.isNotBlank(value)) {
                                // 可能是年月日格式的，处理一下
                                value = value.replace("年","-").replace("月","-").replace("日","");
                                if(checkIsDate(value)){
                                    date = sdf.parse(value.replace("/","-"));
                                }
                            }
                        } catch (Exception e) {
                            e.printStackTrace();
                        }
                        method.invoke(obj, date);
                        break;
                    } else {
                        method.invoke(obj, parameterC[0].cast(value));
                        break;
                    }
                } catch (IllegalArgumentException e) {
                    e.printStackTrace();
                } catch (IllegalAccessException e) {
                    e.printStackTrace();
                } catch (InvocationTargetException e) {
                    e.printStackTrace();
                } catch (SecurityException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    /**
     * 功能:根据属性生成对应的set/get方法
     */
    private static String convertToMethodName(String attribute, Class<?> objClass, boolean isSet) {
        // 通过正则表达式来匹配第一个字符
        Pattern p = Pattern.compile(REGEX);
        Matcher m = p.matcher(attribute);
        StringBuilder sb = new StringBuilder();
        // 如果是set方法名称
        if (isSet) {
            sb.append("set");
        } else {
            // get方法名称
            try {
                Field attributeField = objClass.getDeclaredField(attribute);
                // 如果类型为boolean
                if (attributeField.getType() == boolean.class || attributeField.getType() == Boolean.class) {
                    sb.append("is");
                } else {
                    sb.append("get");
                }
            } catch (SecurityException e) {
                e.printStackTrace();
            } catch (NoSuchFieldException e) {
                e.printStackTrace();
            }
        }
        // 针对以下划线开头的属性
        if (attribute.charAt(0) != '_' && m.find()) {
            sb.append(m.replaceFirst(m.group().toUpperCase()));
        } else {
            sb.append(attribute);
        }
        return sb.toString();
    }

    /**
     * 功能:输出提示信息(普通信息打印)
     */
    private static void out(String info, boolean showInfo, String sid) {
        if (showInfo) {
//            System.out.print(info + (showInfo ? "\n" : ""));
        }
    }

    /**
     * 功能:输出提示信息(同一行的不同单元格信息打印)
     */
    private static void out(String info, boolean showInfo, boolean nextLine, String sid) {
        if (showInfo) {
            if (nextLine) {
//                System.out.print(info + (showInfo ? "\n" : ""));
                WebSocketServer.sendInfo(info + (showInfo ? "\n" : ""), sid);
            } else {
//                System.out.print(info);
            }
        }
    }


    // 新方法


    /**
     * 功能:获取Excel数据行集合(可单独使用)
     *
     * @param originUrl Excel文件路径
     * @param startRow  起始读取行
     * @param endRow    结束读取行
     */
    public static List<Row> getRowList(String originUrl, int startRow, int endRow) throws IOException {
        // 判断文件是否存在
        File file = isExist(originUrl);
        // 开始读取Excel的内容
        Workbook wb = null;
        FileInputStream fis = null;
        List<Row> rowList = new ArrayList<Row>();
        try {
            fis = new FileInputStream(file);
            if (originUrl.substring(originUrl.lastIndexOf(".") + 1).equals(XLS)) {
                wb = new HSSFWorkbook(fis);
            } else {
                wb = new XSSFWorkbook(fis);
            }

            Sheet sheet = wb.getSheetAt(0);
//            int lastRowNum = sheet.getLastRowNum();
            int lastRowNum = sheet.getPhysicalNumberOfRows();
            Row row;
            for (int i = startRow; i <= lastRowNum + endRow; i++) {
                row = sheet.getRow(i);
                if (row != null) {
                    rowList.add(row);
                }
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (wb != null) {
                wb.close();
            }
            if (fis != null) {
                fis.close();
            }
        }
        return rowList;
    }

    /**
     * 功能:把List<Row>转为List<Map>并格式化字段(可单独使用)
     */
    public static List<LinkedHashMap<String, Object>> getDataList(List<Row> rowList, Class<?> clazz) {
        List<LinkedHashMap<String, Object>> objectList = null;
        List<String> nameKeys = new ArrayList<>();
        Row keyRow = rowList.get(0);

        for (int i = 0; i < keyRow.getPhysicalNumberOfCells(); i++) {
            nameKeys.add(keyRow.getCell(i).toString().trim());
        }
        try {
            objectList = new ArrayList<>();
            for (int i = 1; i < rowList.size(); i++) {
                Row row = rowList.get(i);
                LinkedHashMap<String, Object> map = new LinkedHashMap<>();
                int check = 0;
                for (int j = 0; j < nameKeys.size(); j++) {
                    // 此单元格的值
                    String cellValue = getCellValue(row.getCell(j));
                    // 格式化后的值
                    String name = nameKeys.get(j);
                    map.put(name, formatValue(name, cellValue, clazz));
                }
                objectList.add(map);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        return objectList;
    }

    /**
     * 功能:格式化字段(可单独使用,具体格式化方式由claszz决定，通常也检查字段是否合法，并注上错误标识)
     */
    public static Object formatValue(String name, Object value, Class<?> formatClazz) {
        Method[] methods = formatClazz.getMethods();
        for (Method method : methods) {
            if (("format" + name).toLowerCase().equals(method.getName().toLowerCase())) {
                try {
                    Class<?>[] parameterC = method.getParameterTypes();
                    if (parameterC[0] == Date.class) {
                        if (value instanceof Date) {
                            return method.invoke(formatClazz, (Date) value);
                        } else {
                            return value;
                        }
                    } else {
                        // 找到对应的方法，并把原始值传进去，返回格式化后的值
                        return method.invoke(formatClazz, value);
                    }
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        }
        return value;
    }

    /**
     * 功能:直接调用此方法获取解析后的数据
     */
    public static List<LinkedHashMap<String, Object>> getParseData(String originUrl, int startRow, int endRow
            , Class<?> clazz) throws IOException {
        return getDataList(getRowList(originUrl, startRow, endRow), clazz);
    }

    /**
     * 功能：把解析数据转为展示数据，例如：字典项 1 转为 是
     */
    public static List<LinkedHashMap<String, Object>> getShowData(List<LinkedHashMap<String, Object>> parseData, Class<?> clazz) {
        List<LinkedHashMap<String, Object>> listShow = new ArrayList<>();
        for (LinkedHashMap lhm : parseData) {
            LinkedHashMap<String, Object> map = new LinkedHashMap<>();
            for (Object o : lhm.keySet()) {
                String key = o.toString();
                String value = lhm.get(key).toString();
                Object formatValue = ImpRsExcel.formatValue(key, value, clazz);
                map.put(key, formatValue);
            }
            listShow.add(map);
        }
        return listShow;
    }

    /**
     * 功能：把Map转成Bean (主要用于把从Excel解析出来的Map对象还原成实体类对象，方便入库)
     */
    public static Object convertMapToBean(Class<?> clazz, Map lhp) throws IllegalAccessException, InstantiationException {
        Field[] fields = clazz.getDeclaredFields();
        Object obj = clazz.newInstance();
        for (Field field : fields) {
            setAttrributeValue(obj, field.getName(), MapUtils.getString(lhp, field.getName()));
        }
        return obj;
    }
    public Map<String, String> getAdCds(String sheng, String shi, String xian){
        Map<String, String> map = new HashMap<>();
        AttAdXBaseParam attAdXBaseParam = new AttAdXBaseParam();
        attAdXBaseParam.setAdName(sheng);
        attAdXBaseParam.setAdGrad("2");
        AttAdXBase attAdXBase = attAdXBaseDao.getBy(attAdXBaseParam);
        if(attAdXBase!=null){
            String shengCode = attAdXBase.getAdCode();
            attAdXBaseParam.setAdFcode(shengCode);
            map.put("sheng",shengCode);
        }else {
            attAdXBaseParam.setAdName("");
            attAdXBaseParam.setAdFullName(sheng);
            attAdXBase = attAdXBaseDao.getBy(attAdXBaseParam);
            if(attAdXBase!=null){
                String shengCode = attAdXBase.getAdCode();
                attAdXBaseParam.setAdFcode(shengCode);
                map.put("sheng",shengCode);
            }
        }
        if(org.apache.commons.lang3.StringUtils.isNotBlank(shi)){
            attAdXBaseParam.setAdName(shi);
            attAdXBaseParam.setAdGrad("3");
            attAdXBase = attAdXBaseDao.getBy(attAdXBaseParam);
            if(attAdXBase!=null){
                String shiCode = attAdXBase.getAdCode();
                attAdXBaseParam.setAdFcode(shiCode);
                map.put("shi",shiCode);
            }else {
                shi = shi.replaceAll("州","");
                shi = shi.replaceAll("市","");
                attAdXBase = attAdXBaseDao.getBy(attAdXBaseParam);
                if(attAdXBase!=null){
                    String shiCode = attAdXBase.getAdCode();
                    attAdXBaseParam.setAdFcode(shiCode);
                    map.put("shi",shiCode);
                }else {
                    attAdXBaseParam.setAdName("");
                    attAdXBaseParam.setAdFullName(shi);
                    attAdXBase = attAdXBaseDao.getBy(attAdXBaseParam);
                    if(attAdXBase!=null){
                        String shiCode = attAdXBase.getAdCode();
                        attAdXBaseParam.setAdFcode(shiCode);
                        map.put("shi",shiCode);
                    }else {
                        attAdXBaseParam.setAdFcode("");
                        attAdXBaseParam.setAdCode(map.get("sheng").substring(0,2));
                    }
                }
            }
        }else{
            attAdXBaseParam.setAdFcode("");
            attAdXBaseParam.setAdCode(map.get("sheng").substring(0,2));
        }
        if(org.apache.commons.lang3.StringUtils.isNotBlank(xian)){
            attAdXBaseParam.setAdName(xian);
            attAdXBaseParam.setAdGrad("4");
            List<AttAdXBase> adXBases = attAdXBaseDao.findList(attAdXBaseParam);
            if(adXBases!=null&&adXBases.size()>0){
                if (adXBases.size()==1){
                    attAdXBase = adXBases.get(0);
                }else {
                    for (AttAdXBase adXBase:adXBases) {
                        if(xian.equals(adXBase.getAdName())){
                            attAdXBase = adXBase;
                            break;
                        }
                    }
                }
            }else {
                xian = xian.replaceAll("风景名胜区","");
                xian = xian.replaceAll("管理区","");
                xian = xian.replaceAll("开发区、","");
                xian = xian.replaceAll("经济区","");
                xian = xian.replaceAll("新区","");
                xian = xian.replaceAll("区","");
                xian = xian.replaceAll("自治县","");
                xian = xian.replaceAll("县","");
                xian = xian.replaceAll("市","");
                xian = xian.replaceAll("管委会","");
                attAdXBaseParam.setAdName(xian);
                adXBases = attAdXBaseDao.findList(attAdXBaseParam);
                if(adXBases!=null&&adXBases.size()>0){
                    if (adXBases.size()==1){
                        attAdXBase = adXBases.get(0);
                    }else {
                        for (AttAdXBase adXBase:adXBases) {
                            if(xian.equals(adXBase.getAdName())){
                                attAdXBase = adXBase;
                                break;
                            }
                        }
                    }
                }else {
                    attAdXBase = new AttAdXBase();
                }
            }
            //attAdXBase = attAdXBaseService.getBy(attAdXBaseParam);
            if(attAdXBase!=null){
                String xianCode = attAdXBase.getAdCode();
                map.put("xian",xianCode);
                if (org.apache.commons.lang3.StringUtils.isBlank(map.get("shi"))){
                    map.put("shi",attAdXBase.getAdFcode());
                }
            }else{
                attAdXBaseParam.setAdName("");
                attAdXBaseParam.setAdFullName(xian);
                attAdXBase = attAdXBaseDao.getBy(attAdXBaseParam);
                if(attAdXBase!=null){
                    String xianCode = attAdXBase.getAdCode();
                    map.put("xian",xianCode);
                    if (org.apache.commons.lang3.StringUtils.isBlank(map.get("shi"))){
                        map.put("shi",attAdXBase.getAdFcode());
                    }
                }else{
                    if(xian.endsWith("县")||xian.endsWith("区")){
                        xian = xian.substring(0,xian.length()-1);
                    }
                    attAdXBaseParam.setAdName(xian);
                    attAdXBaseParam.setAdGrad("4");
                    attAdXBase = attAdXBaseDao.getBy(attAdXBaseParam);
                    if(attAdXBase!=null){
                        String xianCode = attAdXBase.getAdCode();
                        map.put("xian",xianCode);
                        if (org.apache.commons.lang3.StringUtils.isBlank(map.get("shi"))){
                            map.put("shi",attAdXBase.getAdFcode());
                        }
                    }
                }
            }
        }
        return map;
    }
    public Map<String, String> checkRsBase(String rsvrNm, String adCd){
        if(rsvrNm.contains("水库水库")){
            rsvrNm = rsvrNm.replaceAll("水库水库","水库");
        }else if(rsvrNm.contains("小二型")){
            rsvrNm = rsvrNm.replaceAll("小二型","");
        }
        Map<String, String> map = new HashMap<>();
        AttRsBaseParam rsBaseParam = new AttRsBaseParam();
        rsBaseParam.setAdmDiv(adCd);
        rsBaseParam.setRsName(rsvrNm);
        List<AttRsBase> rsBaseList = attRsBaseService.findRsList(rsBaseParam);
        if(rsBaseList!=null&&rsBaseList.size()>0){
            if(rsBaseList.size()>1){
                for (AttRsBase attRs:rsBaseList) {
                    String name = attRs.getRsName();
                    if(rsvrNm.equals(name)){
                        map.put("rsCode",attRs.getRsCode());
                    }
                }
            }else{
                AttRsBase attRs = rsBaseList.get(0);
                map.put("rsCode",attRs.getRsCode());
            }
        }else{
            if(rsvrNm.contains("电站")&&!"汶洋水电站水库".equals(rsvrNm)){
                if (rsvrNm.contains("水电站")){
                    rsvrNm = rsvrNm.replaceAll("水电站","");
                }else if(rsvrNm.contains("电站")){
                    rsvrNm = rsvrNm.replaceAll("电站","");
                }
                rsBaseParam.setRsName(rsvrNm);
                rsBaseList = attRsBaseService.findRsList(rsBaseParam);
                if(rsBaseList!=null&&rsBaseList.size()>0){
                    if(rsBaseList.size()>1){
                        for (AttRsBase attRs:rsBaseList) {
                            String name = attRs.getRsName();
                            if(rsvrNm.equals(name)){
                                map.put("rsCode",attRs.getRsCode());
                            }
                        }
                    }else{
                        AttRsBase attRs = rsBaseList.get(0);
                        map.put("rsCode",attRs.getRsCode());
                    }
                }
            }
        }
        return map;
    }
    private static String encagl(String desc) {
        if ("小（2）型".equals(desc)) {
            return "5";
        }else if ("小（1）型".equals(desc)) {
            return "4";
        }else if ("中型".equals(desc)) {
            return "3";
        }else if ("大（2）型".equals(desc)) {
            return "2";
        }else if ("大（1）型".equals(desc)) {
            return "1";
        }
        return "";
    }
    private String typeMat(String desc){
        //1:混凝土坝;2:碾压混凝土坝;3:浆砌石坝;4:土坝;5:堆石坝;6:挡水坝;7:其他)
        if (desc.contains("碾压混凝土")) {
            return "2";
        }else if (desc.contains("混凝土")) {
            return "1";
        }else if (desc.contains("浆砌石坝")||desc.contains("土石混合")) {
            return "3";
        }else if ("土坝".equals(desc)||"粘土".equals(desc)) {
            return "4";
        }else if (desc.contains("堆石坝")||desc.contains("砌石")) {
            return "5";
        }else if ("挡水坝".equals(desc)) {
            return "6";
        }else{
            return "7";
        }
    }
    private String typeStr(String desc){
        //常态混凝土变曲拱坝;常态混凝土单曲拱坝;常态混凝土空腹重力坝;常态混凝土宽缝重力坝;常态混凝土实体重力坝;常态混凝土双曲拱坝;大头坝;
        // 混凝土心墙坝;均质土坝;连拱坝;面板堆石坝;碾压混凝土单曲拱坝;碾压混凝土双曲拱坝;碾压混凝土重力坝;碾压式土石坝;平板坝;其他;
        // 砌石拱坝;砌石重力坝;土石混合坝;粘土斜墙坝;粘土心墙坝
        if (desc.contains("重力坝")) {
            return "1";
        }else if (desc.contains("拱坝")) {
            return "2";
        }else if (desc.contains("支墩坝")) {
            return "3";
        }else if (desc.contains("均质")) {
            return "4";
        }else if (desc.contains("心墙坝")) {
            return "5";
        }else if (desc.contains("斜墙坝")) {
            return "6";
        }else if (desc.contains("面板")) {
            return "7";
        }else if (desc.contains("平板坝")) {
            return "8";
        }else if (desc.contains("大头坝")) {
            return "10";
        }else{
            return "9";
        }
    }
}