package com.doumee.biz.zbom.impl;

import com.alibaba.fastjson.JSONObject;
import com.auth0.jwt.JWT;
import com.auth0.jwt.algorithms.Algorithm;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
import com.doumee.biz.zbom.ZbomIAMService;
import com.doumee.biz.zbom.model.*;
import com.doumee.core.constants.ResponseStatus;
import com.doumee.core.exception.BusinessException;
import com.doumee.core.utils.Constants;
import com.doumee.core.utils.DateUtil;
import com.doumee.dao.business.*;
import com.doumee.dao.business.model.*;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.scheduling.annotation.Async;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.util.*;

/**
 * 人员信息表Service实现
 * @author 江蹄蹄
 * @date 2023/11/30 15:33
 */
@Service
public class ZbomIAMServiceImpl implements ZbomIAMService {

    @Autowired
    private UsersMapper usersMapper;
    @Autowired
    private IamRoleMapper iamRoleMapper;
    @Autowired
    private ShopMapper shopMapper;
    @Autowired
    private CategorySegMapper categorySegMapper;

    @Autowired
    private RedisTemplate<String, Object> redisTemplate;
    @Autowired
    private IamInterfaceLogMapper iamInterfaceLogMapper;
    @Autowired
    private SegmentsMapper segmentsMapper;
    /**
     * 是否开发者
     */
    @Value("${debug_model}")
    private Boolean isDebug;


    /**
     * 初始化同步用户
     * @param params
     */
    @Override
    public void startUserInit(String params) {
    }
    /**
     * 初始化同步用户
     * @param params
     */
    @Override
    public void startOrgInit(String params) {
    }
    @Override
    @Transactional(rollbackFor = {BusinessException.class,Exception.class})
    public void updateRoleInfo(String token, String uuid, String timestamp, IamUpdateRoleModel upateModel){
        if(upateModel == null ||StringUtils.isBlank(upateModel.getId()) ){
            return;
        }
        isValidToken(uuid,timestamp,token);

            IamRole role = iamRoleMapper.selectOne(new QueryWrapper<IamRole>().lambda()
                    .eq(IamRole::getIamId,upateModel.getId())
                    .eq(IamRole::getIsdeleted,Constants.ZERO)
                    .last("limit 1"));
            if(role == null){
                role = new IamRole();
                role.setCreateDate(new Date());
                iamRoleMapper.insert(initRoleInfo(role,upateModel));
            }else {
                role.setEditDate(new Date());
                iamRoleMapper.updateById(initRoleInfo(role,upateModel));
            }


    }

    private IamRole initRoleInfo(IamRole role, IamUpdateRoleModel upateModel) {
        role.setEditDate(new Date());
        role.setIsdeleted(Constants.ZERO);
        role.setIamId(upateModel.getId());
        role.setAppId(upateModel.getAppId());
        role.setName(upateModel.getName());
        role.setEid(upateModel.getEid());
        role.setCode(upateModel.getCode());
        role.setStatus(upateModel.getStatus());
        role.setRegister(upateModel.getRegister());
        role.setSyncDate(role.getEditDate());
        role.setType(upateModel.getType());
        role.setRemark(upateModel.getRemark());
        role.setLabels(upateModel.getLabel());
        role.setCustomUnique(upateModel.getCustomUnique());
        return role;
    }

    @Override
    @Transactional(rollbackFor = {BusinessException.class,Exception.class})
    public void updateShopInfo(String token, String uuid, String timestamp, List<IamUpdateShopModel> shopList) {
        if(shopList == null ||shopList.size() == 0){
            return;
        }
        isValidToken(uuid,timestamp,token);
        List<Shop> addShops = new ArrayList<>();
        List<Shop> updateShops = new ArrayList<>();
        List<String> segDelOrgIds = new ArrayList<>();
        List<CategorySeg> categorySegList = new ArrayList<>();
        List<Segments> segmentsList = new ArrayList<>();
        Date date  = new Date();
        for(IamUpdateShopModel model : shopList){
            Shop shop = shopMapper.selectOne(new QueryWrapper<Shop>().lambda()
                    .eq(Shop::getOrgId,model.getIdtOrgId())
                    .last("limit 1"));
            if(shop == null){
                shop = new Shop();
                shop.setCreateDate(date);
                addShops.add(initShopInfo(shop,model,date));
            }else {
                segDelOrgIds.add(shop.getCode());
                updateShops.add(initShopInfo(shop,model,date));
            }
            //处理品类数据逻辑
            dealCategorySegData(date,shop,model.getCategory(),categorySegList,segmentsList);
        }

        if(addShops.size()>0){
            shopMapper.insert(addShops);
        }
        if(updateShops.size()>0){
            for (Shop shop :updateShops){
                shopMapper.updateById(shop);
            }
        }
        if(segDelOrgIds.size()>0){
            categorySegMapper.delete(new UpdateWrapper<CategorySeg>().lambda() .in(CategorySeg::getOrgId,segDelOrgIds));
        }
        if(categorySegList.size()>0){
            categorySegMapper.insert(categorySegList);
        }
        if(segmentsList.size()>0){
            segmentsMapper.insert(segmentsList);
        }
    }
    private void dealSegmentData(Date date, IamCategoryModel model, Shop shop, List<Segments> segmentsList) {
        if(StringUtils.isNotBlank(model.getSegment1())){
            //如果战区不为空
            if(newSegment(model.getSegment1(),Constants.ZERO,segmentsList)
                    && segmentsMapper.selectCount(new QueryWrapper<Segments>().lambda()
                    .eq(Segments::getSegmentId,model.getSegment1())
                    .eq(Segments::getUnitCode,model.getUnitCode())
                    .eq(Segments::getType,Constants.ZERO)) ==0){
                segmentsList.add(initSegmentData(model,date,Constants.ZERO));
            }
        }
        if(StringUtils.isNotBlank(model.getSegment2())){
            //如果省区不为空
            if(newSegment(model.getSegment2(),Constants.ONE,segmentsList) && segmentsMapper.selectCount(new QueryWrapper<Segments>().lambda()
                    .eq(Segments::getSegmentId,model.getSegment2())
                    .eq(Segments::getParentId,model.getSegment1())
                    .eq(Segments::getUnitCode,model.getUnitCode())
                    .eq(Segments::getType,Constants.ONE)) ==0){
                segmentsList.add(initSegmentData(model,date,Constants.ONE));
            }
        }
        if(StringUtils.isNotBlank(model.getSegment3())){
            //如果片区不为空
            if(newSegment(model.getSegment3(),Constants.TWO,segmentsList) && segmentsMapper.selectCount(new QueryWrapper<Segments>().lambda()
                    .eq(Segments::getSegmentId,model.getSegment3())
                    .eq(Segments::getUnitCode,model.getUnitCode())
                    .eq(Segments::getParentId,model.getSegment2())
                    .eq(Segments::getType,Constants.TWO)) ==0){
                segmentsList.add(initSegmentData(model,date,Constants.TWO));
            }
        }
    }

    private boolean newSegment(String segId2, int one, List<Segments> segmentsList) {
        for(Segments s : segmentsList){
            if(StringUtils.equals(s.getSegmentId(),segId2) && Constants.equalsInteger(one,s.getType())){
                return false;
            }
        }
        return true;
    }

    private Segments initSegmentData(IamCategoryModel model, Date date,  int type) {
        Segments data = new Segments();
        data.setCreateDate(date);
        data.setEditDate(date);
        data.setIsdeleted(Constants.ZERO);
        data.setStatus(Constants.ZERO);
        data.setUnitCode(model.getUnitCode());
        data.setType(type);
        if(type ==Constants.ZERO){
            data.setName(model.getMeaning1());
            data.setSegmentId(model.getSegment1());
            data.setParentId(null);
            data.setRemark(model.getMeaning1());
        }else if(type ==Constants.ONE){
            data.setName(model.getMeaning2());
            data.setSegmentId(model.getSegment2());
            data.setParentId(model.getSegment1());
            data.setRemark(model.getMeaning1()+"/"+model.getMeaning2());
        }else{
            data.setName(model.getMeaning3());
            data.setSegmentId(model.getSegment3());
            data.setParentId(model.getSegment2());
            data.setRemark(model.getMeaning1()+"/"+model.getMeaning2()+"/"+model.getMeaning3());
        }
        return data;
    }
    private void dealCategorySegData(Date date, Shop shop, List<IamCategoryModel> categoryModels, List<CategorySeg> categorySegList, List<Segments> segmentsList) {
       if(categoryModels==null || categoryModels.size() ==0){
           return;
       }
       for(IamCategoryModel model :categoryModels){
           dealSegmentData(date,model,shop,segmentsList);
           categorySegList.add(initInsertCategorySeg(date,model,shop));
       }
    }
    private CategorySeg initInsertCategorySeg(Date date, IamCategoryModel model, Shop shop) {
        CategorySeg data = new CategorySeg();
        data.setCreateDate(date);
        data.setEditDate(date);
        data.setIsdeleted(Constants.ZERO);
        data.setOrgId(shop.getCode());
        data.setSegId(model.getSegment1());
        data.setSegId2(model.getSegment2());
        data.setSegId3(model.getSegment3());
        data.setSegName(model.getMeaning1());
        data.setSegName2(model.getMeaning2());
        data.setSegName3(model.getMeaning3());
        data.setShipToAddress(model.getShipToAddress());
        data.setShipToPhone(model.getShipToPhone());
        data.setShipToPerson(model.getShipToPerson());
        data.setBrandId(model.getAccountSiteId());
        data.setUnitCode(model.getUnitCode());
        data.setSiteCode(model.getSiteCode());
        data.setScode(model.getRelevanceCode());
        if(shop.getSiteCode() ==null){
            shop.setSiteCode("");
        }
        shop.setSiteCode(shop.getSiteCode()+model.getSiteCode()+";");
        return data;
    }

    private Shop initShopInfo(Shop shop, IamUpdateShopModel model, Date date) {
        shop.setEditDate(date);
        shop.setOrgId(model.getIdtOrgId());
        shop.setName(model.getIdtOrgName());
        shop.setCode(model.getIdtOrgCode());
        shop.setType(model.getIdtOrgFirstLevelType());

        shop.setStatus(Constants.parseIntByStr(model.getIdtOrgStatus()));
        shop.setSecondType(model.getIdtOrgSecondLevelType());
        shop.setAttribute(model.getIdtOrgAttribute());
        if(model.getScode()!=null){
            shop.setCountry(model.getScode().getCountry());
            shop.setProvinceName(model.getScode().getProvinceName());
            shop.setProvinceCode(model.getScode().getProvinceNum());
            shop.setCityName(model.getScode().getCityName());
            shop.setCityCode(model.getScode().getCityNum());
            shop.setAreaName(model.getScode().getCountyName());
            shop.setAreaCode(model.getScode().getCountyNum());
            shop.setTown(model.getScode().getTown());
            shop.setGlCode(model.getScode().getRelevanceCodeGL());
            shop.setGlName(model.getScode().getRelevanceNameGL());
            shop.setZcode(model.getScode().getRelevanceZCode());
        }
        if(model.getFcode()!=null){
            shop.setScode(model.getFcode().getRelevanceCode());
            shop.setCountry(model.getFcode().getCountry());
            shop.setProvinceName(model.getFcode().getProvinceName());
            shop.setProvinceCode(model.getFcode().getProvinceNum());
            shop.setCityName(model.getFcode().getCityName());
            shop.setCityCode(model.getFcode().getCityNum());
            shop.setAreaName(model.getFcode().getCountyName());
            shop.setAreaCode(model.getFcode().getCountyNum());
            shop.setTown(model.getFcode().getTown());
            shop.setRegAddr(model.getFcode().getRegistrationAddress());
            shop.setLegalPhone(model.getFcode().getContactPhone());
            shop.setLegalName(model.getFcode().getLegalPerson());
            shop.setLegalIdcode(model.getFcode().getLegalIdentification());
        }
        if(model.getShop()!=null){
            shop.setUnitCode(model.getShop().getUnitCode());
            shop.setScode(model.getShop().getRelevanceCode());
            shop.setFcode(model.getShop().getAccountNumber());
        }
        if(StringUtils.equals( model.getIdtOrgStatus(),"-1")){
            shop.setIsdeleted(Constants.ONE);
        }else{
            shop.setIsdeleted(Constants.ZERO);
        }
        shop.setParentIamId(model.getIdtOrgParentId());
        return  shop;
    }

    private void isValidToken(String uuid, String timestamp, String token) {
        if (!StringUtils.equalsIgnoreCase( getToken( uuid, timestamp), token)) {
            throw  new BusinessException(ResponseStatus.BAD_REQUEST.getCode(), "对不起，token错误~");
        }
    }

    @Override
    @Transactional(rollbackFor = {BusinessException.class,Exception.class})
    public void updateUserInfo(String token, String uuid, String timestamp, IamUpdateUserModel upateUserModel){
        if(upateUserModel == null ||upateUserModel.getIdtUserId() == null){
            return;
        }
        isValidToken(uuid,timestamp,token);

        Users users = usersMapper.selectOne(new QueryWrapper<Users>().lambda()
                .eq(Users::getIamId,upateUserModel.getIdtUserId())
                .last("limit 1"));
        if(users == null){
            users = initUserModel(users,upateUserModel);
            usersMapper.insert(users);
        }else {
            users = initUserModel(users,upateUserModel);
            usersMapper.updateById(users);
        }
    }

    private Users initUserModel(Users users, IamUpdateUserModel upateUserModel) {
        if(users == null){
            users = new Users();
            users.setCreateDate(new Date());
        }
        users.setEditDate(new Date());
        users.setSex(upateUserModel.getIdtUserGender());
        users.setIamUsername(upateUserModel.getAppAccountNo());
        users.setCode(upateUserModel.getIdtUserWorkNo());
        users.setName(upateUserModel.getIdtUserName());
        users.setPassword(upateUserModel.getAppAccountPwd());
        users.setPhone(upateUserModel.getIdtUserMobile());
        users.setIamId(upateUserModel.getIdtUserId());
        users.setStatus(upateUserModel.getAppAccountStatus());
        users.setIsdeleted(Constants.ZERO);
        users.setRemark(JSONObject.toJSONString(upateUserModel));
        users.setRoleNames(null);
        users.setRoleCodes(null);
        users.setCardImg("-");
        users.setRoleIds(null);
        users.setUserTypes(null);
        if( upateUserModel.getUserTypes() !=null){
            for(IamUserTypeModel type : upateUserModel.getUserTypes()){
                if(StringUtils.isBlank(users.getUserTypes())){
                    users.setUserTypes("");
                }
                users.setUserTypes(users.getUserTypes()+"["+type.getIdtUserTypeCode()+"];");
            }
        }
        if( upateUserModel.getRoles() !=null){
            for(IamUserRoleModel t : upateUserModel.getRoles()){
                if(StringUtils.isBlank(users.getRoleIds())){
                    users.setRoleIds("");
                }
                if(StringUtils.isBlank(users.getRoleNames())){
                    users.setRoleNames("");
                }
                if(StringUtils.isBlank(users.getRoleCodes())){
                    users.setRoleCodes("");
                }
                users.setRoleIds(users.getRoleIds()+"["+t.getId()+"];");
                users.setRoleNames(users.getRoleNames()+"["+t.getName()+"];");
                users.setRoleCodes(users.getRoleCodes()+"["+t.getCode()+"];");
            }
        }
        if(upateUserModel.getJobs()!=null){
            String orgId = null;
            for(IamUserJobModel job : upateUserModel.getJobs()){
                if(StringUtils.equals(job.getFirstLevelType(),Constants.TWO+"")){
                    orgId = job.getOrgId();
                    break;
                }
            }
            users.setIamOrgId(orgId);
            if(orgId !=null){
                Shop shop = shopMapper.selectOne(new QueryWrapper<Shop>().lambda()
                        .eq(Shop::getOrgId,orgId)
                        .last("limit 1"));
                users.setDepartmentId(shop ==null?null:shop.getId());
            }
        }
        return  users;
    }

    public  String getToken(String uuid,String time) {
        String appid = (String) redisTemplate.opsForValue().get(Constants.RedisKeys.IAM_APPID);
        String appKey =  (String)redisTemplate.opsForValue().get(Constants.RedisKeys.IAM_APPKEY) ;
        String token = JWT.create().withIssuer(appid).withIssuedAt(DateUtil.getDateFromString(time)).withJWTId(uuid).sign(Algorithm.HMAC256(appKey));
        token = String.join(" ", "Bearer", token);
        return  token;
    }
    @Override
    @Async
    public  void  saveInterfaceLog(String url,int type,String name, String token, String uuid, String timestamp, Object obj,Integer success,String respone){
            Map<String,Object> map = new HashMap<>();
            map.put("token",token);
            map.put("uuid",uuid);
            map.put("timestamp",timestamp);
            map.put("data", obj);
            IamInterfaceLog log = new IamInterfaceLog();
            log.setCreateDate(new Date());
            log.setUrl(url);
            log.setEditDate(log.getCreateDate());
            log.setPlat(Constants.ZERO);
            log.setName(name);
            log.setIsdeleted(Constants.ZERO);
            log.setRequest(JSONObject.toJSONString(map));
            log.setType(type);
            log.setSuccess(success);
            log.setRepose(respone);
            iamInterfaceLogMapper.insert(log);
    }
}