package com.common.core.service;

import com.common.annotation.NoEncryption;
import com.common.core.crypto.ColumnHandler;
import com.common.core.crypto.CryptoHandler;
import com.common.core.enums.ResultCodeEnum;
import com.common.core.exception.BizException;
import com.jfinal.plugin.activerecord.Model;
import com.jfinal.plugin.activerecord.Record;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;

import java.lang.reflect.Array;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.List;
import java.util.stream.Collectors;

/**
 * @author 廖振钦
 * @Date 2022-01-11 20:05
 * */
@Slf4j
@Service
public class CryptoService {
    // 用于数据库的某些字段加密解密
    public static final CryptoHandler<String, String> CRYPTO_HANDLER = new ColumnHandler();

    /**
     * @Title: 对record某些列解密
     */
    public List<Record> decryptoColumnRecord(List<Record> list, String[] columns){
        int size = list.size();
        for(int i = 0; i < size; i++){
            Record record = list.get(i);
            decryptoColumnRecord(record, columns);
        }
        return list;
    }

    public List<Record> decryptoColumnRecord(List<Record> list){
        int size = list.size();
        for(int i = 0; i < size; i++){
            Record record = list.get(i);
            decryptoRecord(record);
        }
        return list;
    }

    /**
     * @Title: 对record某些列解密
     */
    public Record decryptoColumnRecord(Record record, String[] columns){
        for(String column : columns){
            if(isSM(column)) {
                record.set(column, CRYPTO_HANDLER.decrypto(record.getStr(column)));
            }
        }
        return record;
    }

    public Record decryptoRecord(Record record){
        String[] columns = record.getColumnNames();
        for(String column : columns){
            if(isSM(column)) {
                record.set(column, CRYPTO_HANDLER.decrypto(record.getStr(column)));
            }
        }
        return record;
    }

    /** ========================     model加密 start  ======================== **/

    /**
     * @Title: 对model全部列加密
     */
    public <T extends Model<T>> List<T> encryptoModel(List<T> list){
        int size = list.size();
        for(int i = 0; i < size; i++){
            T model = list.get(i);
            encryptoModel(model);
        }
        return list;
    }

    /**
     * @Title: 对model某些列加密
     */
//    public <T extends Model<T>> List<T> encryptoColumnModel(List<T> list, String[] columns){
//        int size = list.size();
//        for(int i = 0; i < size; i++){
//            T model = list.get(i);
//            encryptoColumnModel(model, columns);
//        }
//        return list;
//    }

    /**
     * @Title: 对model全部列加密
     */
    public <T extends Model<T>> T encryptoModel(T model){
        String[] columnNames = model._getAttrNames();
        for(String column : columnNames){
            if(isSM(column)) {
                model.set(column, CRYPTO_HANDLER.encrypto(model.getStr(column)));
            }
        }
        return model;
    }

    /**
     * @Title: 对model某些列加密
     */
    public <T extends Model<T>> T encryptoColumnModel(T model, String[] columns){
        for(String column : columns){
            if(isSM(column)) {
                model.set(column, CRYPTO_HANDLER.encrypto(model.getStr(column)));
            }
        }
        return model;
    }

    /**
     *
     * @param model
     * @param <T>
     * @param columns
     * @return
     */
//    public <T> T encryptColumnModel(T model, String[] columns){
//        List<T> modelList = new ArrayList<>();
//        if (model instanceof Object) {
////            modelList.add(models);
//            T t = encryptColumn(model, columns);
//            return t;
//        }else if (model instanceof List) {
//            List models= (List) model;
//            modelList.addAll(models);
//            for(int i = 0; i < modelList.size(); i++){
//                T modelOne = modelList.get(i);
//                T t = encryptColumn(modelOne, columns);
//            modelList.add(t);
//            }
//            return (T) modelList;
//        }
////        int size = modelList.size();
////        List<T> ts = new ArrayList<>();
////        for(int i = 0; i < size; i++){
////            T model = modelList.get(i);
////            T t = encryptColumn(model, columns);
//////            modelList.add(t);
////        }
//
//        return null;
//    }

    /**
     * @Title: 对model某些列加密
     */
    public <T> List<T> encryptColumnModel(List<T> list, String[] columns) {
        List<T> modelList = new ArrayList<>();
        int size = list.size();
        for(int i = 0; i < size; i++){
            T model = list.get(i);
            T t = encryptColumn(model, columns);
            modelList.add(t);
        }
        return modelList;
    }

    /**
     * @Title: 对model某些列加密
     */
    public <T> T encryptColumnModel(T model, String[] columns)  {
        T t = encryptColumn(model, columns);
        return t;
    }

    /**
     *  对model字段加密
     * @param model
     * @param columns
     * @param <T>
     * @return
     */
    public <T> T encryptColumn(T model, String[] columns)  {
        Field[] fields = model.getClass().getDeclaredFields();
        for(String column : columns){
            if(isSM(column)) {
                for (int i = 0; i < fields.length; i++) {
                    if (column.equals(fields[i].getName())) {
                        String encrypto = CRYPTO_HANDLER.encrypto((String) getFieldValueByName(fields[i].getName(), model));
                        fields[i].setAccessible(true);
                        try {
                            fields[i].set(model,encrypto);
                        } catch (IllegalAccessException e) {
                            log.error("encryptColumn failed",e);
                        }
                    }
                }
            }
        }
        return model;
    }

    /**
     *  对model没有@NoEncryption字段加密
     * @param model
     * @param <T>
     * @return
     */
    public <T> T encryptModelColumns(T model) {
        Field[] fields = model.getClass().getDeclaredFields();
        for (Field field : fields) {
            if (isSM(field.getName()) && !field.isAnnotationPresent(NoEncryption.class)) {
                Object value=getFieldValueByName(field.getName(), model);
                if(value!=null && value.getClass().isArray()){
                    String[] valueArray=(String[])value;
                    ArrayList<String> list=new ArrayList();
                    for (String s : valueArray) {
                        list.add(CRYPTO_HANDLER.encrypto(s));
                    }
                    field.setAccessible(true);
                    try {
                        field.set(model, list.toArray(new String[0]));
                    } catch (IllegalAccessException e) {
                        log.error("encryptModelColumns failed",e);
                    }
                }else {
                    String encrypto = CRYPTO_HANDLER.encrypto((String) value);
                    field.setAccessible(true);
                    try {
                        field.set(model, encrypto);
                    } catch (IllegalAccessException e) {
                        log.error("encryptModelColumns failed",e);
                    }
                }
            }
        }
        return model;
    }

    /**
     *  对model字段解密
     * @param model
     * @param columns
     * @param <T>
     * @return
     */
    public <T> T decryptColumn(T model, String[] columns) {
        try {
            Field[] fields = model.getClass().getDeclaredFields();
            for (String column : columns) {
                if (isSM(column)) {
                    for (int i = 0; i < fields.length; i++) {
                        if (column.equals(fields[i].getName())) {
                            String encrypto = CRYPTO_HANDLER.decrypto((String) getFieldValueByName(fields[i].getName(), model));
                            fields[i].setAccessible(true);
                            fields[i].set(model, encrypto);
                        }
                    }
                }
            }
            return model;
        }catch (Exception e){
            throw new BizException(ResultCodeEnum.DECRYPT_ERROR);
        }
    }

    /**
     *  对model没有@NoEncryption字段解密
     * @param model
     * @param <T>
     * @return
     */
    public <T> T decryptModelColumns(T model,Class clz) {
        Field[] fields = clz.getDeclaredFields();
        for (Field field : fields) {
            if (isSM(field.getName()) && !field.isAnnotationPresent(NoEncryption.class)) {
                String decrypto = CRYPTO_HANDLER.decrypto((String) getFieldValueByName(field.getName(), model));
                field.setAccessible(true);
                try {
                    if(decrypto!=null)
                    field.set(model, decrypto);
                } catch (IllegalAccessException e) {
                    log.error("decryptModelColumns failed",e);
                }
            }
        }
        return model;
    }

    /**
     *  对List<Model>没有@NoEncryption字段解密
     * @param models
     * @return
     */
    public <T> List<T> decryptModelListColumns(List<T> models,Class clz) {
        return models.stream().map(model -> decryptModelColumns(model,clz)).collect(Collectors.toList());
    }

    /**
     * 根据属性名获取属性值
     * @param fieldName
     * @param o
     * @return
     */
    private Object getFieldValueByName(String fieldName, Object o) {
        try {
            String firstLetter = fieldName.substring(0, 1).toUpperCase();
            String getter = "get" + firstLetter + fieldName.substring(1);
            Method method = o.getClass().getMethod(getter, new Class[]{});
            Object value = method.invoke(o, new Object[]{});
            return value;
        } catch (Exception e) {
            log.error("getFieldValueByName failed",e);
        }
        return null;
    }

    /** ========================     model加密 end  ======================== **/



    /** ========================     model解密 start  ======================== **/

    /**
     * @param <T>
     * @Title: 对model全部列解密
     */

    public <T extends Model<T>> List<T> decryptoModel(List<T> list){
        int size = list.size();
        for(int i = 0; i < size; i++){
            T model = list.get(i);
            decryptoModel(model);
        }
        return list;
    }

    /**
     * @param <T>
     * @Title: 对model某些列解密
     */

    public <T extends Model<T>> List<T> decryptoColumnModel(List<T> list, String[] columns){
        int size = list.size();
        for(int i = 0; i < size; i++){
            T model = list.get(i);
            decryptoColumnModel(model, columns);
        }
        return list;
    }

    /**
     * @Title: 对model全部列解密
     */
    public <T extends Model<T>> T decryptoModel(T model){
        String[] columnNames = model._getAttrNames();
        for(String column : columnNames){
            if(isSM(column)) {
                model.set(column, CRYPTO_HANDLER.decrypto(model.getStr(column)));
            }
        }
        return model;
    }

    /**
     * @Title: 对model某些列解密
     */
    public <T extends Model<T>> T decryptoColumnModel(T model, String[] columns){
        for(String column : columns){
            if(isSM(column)) {
                model.set(column, CRYPTO_HANDLER.decrypto(model.getStr(column)));
            }
        }
        return model;
    }

    public boolean isSM(String column){
        if(!"id".equals(column) && !"create_time".equals(column) && !"update_time".equals(column) && !"is_delete".equals(column)
                && !"dataId".equals(column)&& !"isDelete".equals(column)&& !"sfRecordId".equals(column)) {
            return true;
        }else{
            return false;
        }
    }


   /** ========================     model解密 end  ======================== **/


   public Object convertor(Object src, Object target){
       Class<?> srcClass = src.getClass();
       Class<?> targetClass = target.getClass();
       Field[] fields = srcClass.getDeclaredFields();
       for (Field field : fields) {
           if (isSM(field.getName()) && !field.getName().contains("Encrypt")) {
               field.setAccessible(true);
               Object value = null;
               try {
                   value = field.get(src);
                   Class<?> methodParamTypes = getMethodParamTypes(target, "set" + captureName(field.getName())+"Encrypt");
                   Method method = targetClass.getDeclaredMethod("set" +captureName(field.getName())+"Encrypt",methodParamTypes);
                   method.setAccessible(true);
                   method.invoke(target,value);
               } catch (Exception e) {
                   log.error("convertor failed",e);
               }
           }
       }
       return target;
   }

    public String captureName(String name){
        name = name.substring(0,1).toUpperCase()+name.substring(1);
        return name;
    }

    public Class<?> getMethodParamTypes(Object classInstance,String methodName){
        Method[] methods = classInstance.getClass().getMethods();
        Class<?> param = null;
        for (int i = 0; i < methods.length; i++) {
            if (methodName.equals(methods[i].getName())) {
                param = methods[i].getParameterTypes()[0];
            }
        }
        return param;
    }
}