package com.ggg.common.utils.excel;

import java.io.File;
import java.io.FileInputStream;
import java.io.InputStream;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.net.HttpURLConnection;
import java.net.URL;
import java.net.URLConnection;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Date;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;

import org.apache.poi.hssf.usermodel.HSSFSheet;
import org.apache.poi.hssf.usermodel.HSSFWorkbook;
import org.apache.poi.ss.usermodel.Cell;
import org.apache.poi.ss.usermodel.CellType;
import org.apache.poi.ss.usermodel.Row;
import org.apache.poi.xssf.usermodel.XSSFSheet;
import org.apache.poi.xssf.usermodel.XSSFWorkbook;

/**
 * Excel
 */
public class ImportExcel<T> {
    Class<T> clazz;

    public ImportExcel(Class<T> clazz) {
        this.clazz = clazz;
    }

    /**
     * @Description: 导入excel文件
     * @param {String} 本地excel路径
     * @param {String} 网络url上的excel路径
     * @param {String...} pattern
     * @return {*}
     */    
    public Collection<T> importExcel(String filePath, String urlPath, String... pattern) {
        Collection<T> dist = new ArrayList();
        try {
            /**
             * 类反射得到调用方法
             */
            // 得到目标目标类的所有的字段列表
            Field filed[] = clazz.getDeclaredFields();
            // 将所有标有Annotation的字段，也就是允许导入数据的字段,放入到一个map中
            Map fieldmap = new HashMap();
            // 循环读取所有字段
            for (int i = 0; i < filed.length; i++) {
                Field f = filed[i];
                // 得到单个字段上的Annotation
                ExcelAnnotation exa = f.getAnnotation(ExcelAnnotation.class);
                // 如果标识了Annotationd的话
                if (exa != null) {
                    // 构造设置了Annotation的字段的Setter方法
                    String fieldname = f.getName();
                    String setMethodName = "set"
                            + fieldname.substring(0, 1).toUpperCase()
                            + fieldname.substring(1);
                    // 构造调用的method，
                    Method setMethod = clazz.getMethod(setMethodName,
                            new Class[]{f.getType()});
                    // 将这个method以Annotaion的名字为key来存入。
                    fieldmap.put(exa.exportName(), setMethod);
                }
            }
            /**
             * excel的解析开始
             */
            // 将传入的File构造为FileInputStream;
            FileInputStream in = null;
            InputStream ini = null;
            // 得到工作表
            XSSFWorkbook book = null;
            if (urlPath == null || urlPath.isEmpty()) {//使用本地文件模式
                in = new FileInputStream(new File(filePath));
                book = new XSSFWorkbook(in);
            } else {//直接导入网络url文件
                URL url = new URL(urlPath);
                URLConnection urlconn = url.openConnection(); // 试图连接并取得返回状态码
                urlconn.connect();
                HttpURLConnection httpconn = (HttpURLConnection) urlconn;
                int HttpResult = httpconn.getResponseCode();
                if (HttpResult != HttpURLConnection.HTTP_OK) {
                    System.out.print("无法连接到");
                } else {
                    int filesize = urlconn.getContentLength(); // 取数据长度
                    System.out.println("取数据长度====" + filesize);
                    urlconn.getInputStream();
                    ini = urlconn.getInputStream();
                    book = new XSSFWorkbook(ini);
                }
            }
            // // 得到第一页
            XSSFSheet sheet = book.getSheetAt(0);
            // // 得到第一面的所有行
            Iterator<Row> row = sheet.rowIterator();

            /**
             * 标题解析
             */
            // 得到第一行，也就是标题行
            Row title = row.next();
            // 得到第一行的所有列
            Iterator<Cell> cellTitle = title.cellIterator();
            // 将标题的文字内容放入到一个map中。
            Map titlemap = new HashMap();
            // 从标题第一列开始
            int i = 0;
            // 循环标题所有的列
            while (cellTitle.hasNext()) {
                Cell cell = cellTitle.next();
                String value = cell.getStringCellValue();
                titlemap.put(i, value);
                System.out.println("title_i:" + i + "_" + value);
                i = i + 1;
            }
            /**
             * 解析内容行
             */
            //用来格式化日期的DateFormat
            SimpleDateFormat sf;
            if (pattern.length < 1) {
                sf = new SimpleDateFormat("yyyy-MM-dd");
            } else {
                sf = new SimpleDateFormat(pattern[0]);
            }
            while (row.hasNext()) {
                // 标题下的第一行
                Row rown = row.next();

                // 行的所有列
                Iterator<Cell> cellbody = rown.cellIterator();
                // 得到传入类的实例
                T tObject = clazz.newInstance();
                // 遍历一行的列

                while (cellbody.hasNext()) {
                    Cell cell = cellbody.next();
                    int k = cell.getColumnIndex();
                    // 这里得到此列的对应的标题
                    String titleString = (String) titlemap.get(k);
                    // 如果这一列的标题和类中的某一列的Annotation相同，那么则调用此类的的set方法，进行设值
                    if (fieldmap.containsKey(titleString)) {
                        System.out.println("titleString:" + titleString + "_K:" + k);
                        Method setMethod = (Method) fieldmap.get(titleString);
                        //得到setter方法的参数
                        Class<?>[] ts = setMethod.getParameterTypes();
                        //只要一个参数
                        Object xclass = ts[0];
                        //判断参数类型
                        if (xclass.toString().equals("class java.lang.String")) {
                            cell.setCellType(CellType.STRING);
                            System.out.println("cell.getStringCellValue_class java.lang.String:" + cell.getStringCellValue());
                            if (!cell.getStringCellValue().isEmpty()) {
                                setMethod.invoke(tObject, cell.getStringCellValue());
                            }
                        } else if (xclass.toString().equals("class java.util.Date")) {
                            try {
                                setMethod.invoke(tObject, cell.getDateCellValue());
                            } catch (Exception e) {
                                cell.setCellType(CellType.STRING);
                                setMethod.invoke(tObject, sf.parse(cell.getStringCellValue()));
                                System.out.println("Exception:" + e.getMessage());
                            }
                        } else if (xclass.toString().equals("boolean")) {
                            cell.setCellType(CellType.STRING);
                            if (!cell.getStringCellValue().isEmpty()) {
                                boolean boolName = true;
                                if (cell.getStringCellValue().equals("否")) {
                                    boolName = false;
                                }
                                setMethod.invoke(tObject, boolName);
                            }
                        } else if (xclass.toString().equals("class java.lang.Long")) {
                            cell.setCellType(CellType.STRING);
                            if (!cell.getStringCellValue().isEmpty()) {
                                try {
                                    setMethod.invoke(tObject, Long.parseLong(cell.getStringCellValue()));
                                } catch (Exception e){
                                    setMethod.invoke(tObject, 0L);
                                }
                            }
                        } else if (xclass.toString().equals("float")) {
                            cell.setCellType(CellType.STRING);
                            if (!cell.getStringCellValue().isEmpty()) {
                                try {
                                    setMethod.invoke(tObject, Float.parseFloat(cell.getStringCellValue()));
                                } catch (Exception e) {
                                    setMethod.invoke(tObject, 0.00f);
                                }
                            }
                        } else if (xclass.toString().equals("int")) {
                            cell.setCellType(CellType.STRING);
                            if (!cell.getStringCellValue().isEmpty()) {
                                try {
                                    setMethod.invoke(tObject, Integer.parseInt(cell.getStringCellValue()));
                                } catch (Exception e){
                                    setMethod.invoke(tObject, 0);
                                }
                            }
                        } else {
                            System.out.println("xClass__:" + xclass.toString());
                        }
                    }
                }
                dist.add(tObject);
            }
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
        return dist;
    }

    public static void main(String[] args) {
//        ImportExcel<Loginfo> test = new ImportExcel(Loginfo.class);
//        File file = new File("D:\\testOne.xls");
//        Long befor = System.currentTimeMillis();
//        List<Loginfo> result = (ArrayList) test.importExcel(file);
//
//        Long after = System.currentTimeMillis();
//        System.out.println("此次操作共耗时：" + (after - befor) + "毫秒");
//        // for (int i = 0; i < result.size(); i++) {
//        // Loginfo loginfo=result.get(i);
//        // System.out.println("导入的信息为："+loginfo.getLogInfo()+loginfo.getUserip()+loginfo.getUsername());
//        // }
//
//        System.out.println("共转化为List的行数为：" + result.size());
    }
}