package com.poyee.base.service.impl;

import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.github.yulichang.wrapper.MPJLambdaWrapper;
import com.poyee.base.dto.UserInfo;
import com.poyee.common.exception.AuthException;
import com.poyee.annotation.MpjWapper;
import com.poyee.base.dto.BaseDto;
import com.poyee.base.dto.BaseReq;
import com.poyee.base.mapper.IBaseMapper;
import com.poyee.base.service.BaseService;
import com.poyee.framework.domain.MpjWrapper;
import com.poyee.common.exception.ServiceException;
import com.poyee.i18n.I18nUtils;
import com.poyee.redis.util.RedisUtils;
import com.poyee.util.DateUtils;
import com.poyee.util.ObjectUtil;
import com.poyee.util.ServletUtils;
import org.apache.commons.lang.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.lang.reflect.Field;
import java.util.*;

import static com.poyee.i18n.I18nMessageEnums.*;

/**
 * @param <E>
 * @param <R>
 * @param <D>
 */
@Service
public abstract class BaseServiceImpl<E extends IBaseMapper<D>, R extends BaseReq, D extends BaseDto> extends ServiceImpl<E, D> implements BaseService<R, D> {

    @Autowired
    protected RedisUtils redisUtils;

    /**
     * 获取当前用户ID
     * @return
     */
    public Long getUserId(){
        UserInfo userInfo = ServletUtils.getUserInfo();
        return StringUtils.isNotBlank(userInfo.getUserId())?Long.parseLong(userInfo.getUserId()): Long.valueOf(userInfo.getId());
    }
    /**
     * 获取当前用户ID
     * @return
     */
    public String getLoginName(){
        try {
            UserInfo userInfo = ServletUtils.getUserInfo();
            return StringUtils.isNotBlank(userInfo.getDisplayName()) ? userInfo.getDisplayName() : userInfo.getUserId();
        }catch (Exception e) {
            log.error("获取用户信息失败",e);
//            throw new AuthException(I18nUtils.get(GET_USER_INFO_ERROR));
        }
        return "游客";
    }
    /**
     * 检查用户权限
     * @param p
     * @param <P>
     */
    public <P extends BaseReq> void checkAndSetUserId(P p){
        try {
            UserInfo userInfo = ServletUtils.getUserInfo();
            //解析 p 中的user_id
            if (Objects.nonNull(p)) {
                Field userId = p.getClass().getDeclaredField("userId");
                if (Objects.nonNull(userId)) {
                    userId.setAccessible(true);
                    String typeName = userId.getType().getName();
                    if(Objects.equals("java.lang.Long",typeName)){
                        userId.set(p, Long.valueOf(userInfo.getId()));
                    }else if(Objects.equals("java.lang.Integer",typeName)){
                        userId.set(p, userInfo.getId());
                    }
                }
            }
        } catch (NoSuchFieldException ne) {
            log.error("请求参数中无userId",ne);
            throw new AuthException(402, I18nUtils.get(NO_PERMISSION, "【需指定用户】") );
        } catch (Exception e) {
            log.error("获取用户信息失败",e);
            throw new AuthException(I18nUtils.get(GET_USER_INFO_ERROR));
        }
    }
    /**
     * 检查商户权限
     * @param p
     * @param <P>
     */
    public <P extends BaseReq> void checkAndSetMerchantId(P p){
        try {
            if(p.isDoRedis()){
                log.debug(DateUtils.dateTime()+" 定时任务【"+p.getServiceMethodName()+"】缓存");
                return ;
            }
            UserInfo userInfo = ServletUtils.getUserInfo();
            if(userInfo.isMerchant()) {
                //解析 p 中的user_id
                if (Objects.nonNull(p)) {
                    Field merchantId = p.getClass().getDeclaredField("merchantId");
                    if (Objects.nonNull(merchantId)) {
                        merchantId.setAccessible(true);
                        String typeName = merchantId.getType().getName();
                        if (Objects.equals("java.lang.Long", typeName)) {
                            merchantId.set(p, Long.valueOf(userInfo.getMerchantId()));
                        } else if (Objects.equals("java.lang.Integer", typeName)) {
                            merchantId.set(p, userInfo.getMerchantId());
                        }
                    }
                }
            }
        } catch (NoSuchFieldException ne) {
            log.error("请求参数中无userId",ne);
            throw new AuthException(402, I18nUtils.get(NO_PERMISSION,"【权限不足】"));
        } catch (Exception e) {
            log.error("获取用户信息失败",e);
            throw new AuthException(I18nUtils.get(GET_USER_INFO_ERROR));
        }
    }
    /**
     * 检查商户权限
     * @param p
     * @param <P>
     */
    public <P extends BaseReq> void checkAndPutMerchantId(P p){
        try {
            UserInfo userInfo = ServletUtils.getUserInfo();
            if(userInfo.isMerchant()) {
                //解析 p 中的merchantId
                if (Objects.nonNull(p)) {
                    Field merchantId = p.getClass().getDeclaredField("merchantId");
                    if (Objects.nonNull(merchantId)) {
                        merchantId.setAccessible(true);
                        String typeName = merchantId.getType().getName();
                        if (Objects.equals("java.lang.Long", typeName)) {
                            merchantId.set(p, Long.valueOf(userInfo.getMerchantId()));
                        } else if (Objects.equals("java.lang.Integer", typeName)) {
                            merchantId.set(p, userInfo.getMerchantId());
                        }
                    }
                }
            }
        } catch (NoSuchFieldException | IllegalAccessException ne) {
            log.error("请求参数中无merchantId",ne);
            throw new AuthException(402, I18nUtils.get(NO_PERMISSION, "【权限不足】"));
        } catch (AuthException e) {
            log.error("获取用户信息失败",e);
        }
    }
    /**
     * 获取请求用户的信息
     *
     * @return
     */
    @Transactional
    @Override
    public UserInfo getUserInfo() {
        return ServletUtils.getUserInfo();
    }

    /**
     * @param req
     * @return
     */
    public MPJLambdaWrapper<D> mpjWrapper(Object req) {
        return mpjWrapper(new MPJLambdaWrapper<>(),req,"t");
    }

    /**
     * @param req
     * @return
     */
    public MPJLambdaWrapper<D> mpjWrapper(MPJLambdaWrapper<D> mpjLambdaWrapper,Object req,String alias) {
        try {
            if (null != req) {
                Field[] declaredFields = req.getClass().getDeclaredFields();
                Map<String, MpjWrapper> mpjWapperMap = new HashMap<>();
                for (Field field : declaredFields) {
                    field.setAccessible(true);
                    String name = field.getName();
                    //判断是否有注解 MpjWapper
                    MpjWapper mpjWapper = field.getAnnotation(MpjWapper.class);
                    if (Objects.nonNull(mpjWapper)) {
                        if (Objects.nonNull(mpjWapper.value()) ) {
                            MpjWrapper mpjWrapper = Optional.ofNullable(mpjWapperMap.get(mpjWapper.value()))
                                                            .orElse(new MpjWrapper());
                            if(Objects.nonNull(field.get(req))) {
                                mpjWrapper = mpjWrapper.builder(mpjWapper,alias, field.get(req));
                                mpjWapperMap.put(mpjWapper.value(), mpjWrapper);
                            }
                        }
                    }
                    //判断非使用属性
                    TableField tableField = field.getAnnotation(TableField.class);
                    if (Objects.isNull(tableField) || ( !Objects.isNull(tableField) && !tableField.exist()) ) {
                        continue;
                    }
                    Object value = field.get(req);
                    if(Objects.isNull(value)){
                        continue;
                    }
                    String column = alias+"."+ (Objects.isNull(tableField) ? ObjectUtil.toUnderScoreCase(name) : tableField.value());
                    if (Objects.equals("java.lang.String",field.getType().getName())
                            && StringUtils.isNotBlank((String) value)) {
                        mpjLambdaWrapper = mpjLambdaWrapper.like(column, value);
                    } else if ( Objects.equals("java.lang.Integer",field.getType() .getName())
                            || Objects.equals("java.lang.Long",field.getType() .getName())
                    ) {
                        mpjLambdaWrapper = mpjLambdaWrapper.eq(column, value);
                    }
                }
                if( mpjWapperMap.size() > 0){
                    //处理 非空条件
                    MPJLambdaWrapper<D> finalMpjLambdaWrapper = mpjLambdaWrapper;
                    mpjWapperMap.forEach((key, value) -> checkMpjWrapper(finalMpjLambdaWrapper, value));
                }
            }
        }catch (Exception ex ){
            ex.printStackTrace();
        }
        return mpjLambdaWrapper;
    }
    /**
     * @param mpjWrapper
     * @param wrapper
     */
    private void checkMpjWrapper(MPJLambdaWrapper<D> mpjWrapper ,MpjWrapper wrapper  ){
        try {
            MpjWapper field = wrapper.getField();
            String alias = wrapper.getAlias();
            String value =(StringUtils.isNotBlank(alias)?alias+".":"")+ field.value();
            String data = wrapper.getData();
            if(StringUtils.isBlank(data) || data.replaceAll(",","").length() == 0){
                return ;
            }
            switch (field.operator()) {
                case EQ:
                    Object eqVal = checkColumnType(wrapper, data);
                    mpjWrapper = mpjWrapper.eq(value, eqVal);
                    break;
                case NE:
                    Object neVal = checkColumnType(wrapper, data);
                    mpjWrapper = mpjWrapper.ne(value, neVal);
                    break;
                case BETWEEN:
                    String[] split = data.split(",");
                    if (split.length != 2) {
                        throw new ServiceException("参数错误");
                    }
                    Object val1 = checkColumnType(wrapper, split[0]);
                    Object val2 = checkColumnType(wrapper, split[1]);
                    mpjWrapper = mpjWrapper.between(value, val1, val2);
                    break;
            }
        }catch (Exception ex){
            throw new ServiceException("参数错误");
        }
    }

    /**
     * @param wrapper
     * @param data
     * @return
     */
    private Object checkColumnType(MpjWrapper wrapper ,Object data){
        Object obj = data;
        boolean isSame = data.getClass().getName().contains(wrapper.getField().columnType().name());
        if(isSame){
            return obj;
        }
        switch (wrapper.getField().columnType()) {
            case STRING:
                obj = data.toString();
                break;
            case NUMBER:
                obj = Double.parseDouble(data.toString());
                break;
            case DATE:
                obj = DateUtils.parseDate(data.toString());
                break;
            case BOOLEAN:
                obj = Boolean.parseBoolean(data.toString());
                break;
        }
        return obj;
    }

}