package com.basic.analy.service.impl;

import com.alibaba.fastjson.JSONObject;
import com.basic.analy.config.Result;
import com.basic.analy.controller.FileController;
import com.basic.analy.dao.MergeFromDao;
import com.basic.analy.entity.FaceResults;
import com.basic.analy.model.BbFace;
import com.basic.analy.dao.BbFaceDao;
import com.basic.analy.dao.BbPersonBaseDao;
import com.basic.analy.model.BbPerson;
import com.basic.analy.model.MergeFrom;
import com.basic.analy.service.BbPersonBaseService;
import com.basic.analy.service.FaceSdkTool;
import org.apache.log4j.Logger;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.HttpStatus;
import org.springframework.http.MediaType;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.util.*;


@Service
public class BbPersonBaseServiceImpl implements BbPersonBaseService {

    @Autowired
    private BbPersonBaseDao bbPersonBaseDao;
    @Autowired
    private BbFaceDao bbFaceDao;
    @Autowired
    private MergeFromDao mergeFromDao;
    @Autowired
    private BbPersonTemporaryServiceImpl temporaryServiceImpl;

    private Logger log = Logger.getLogger(FileController.class);

    @Override
    @Transactional
    public void insert(BbPerson bbPersonTemporary, BbFace bbFace) {
        try {
                String faceIds= UUID.randomUUID().toString();
                bbPersonTemporary.setFaceIds(faceIds);
                bbPersonTemporary.setCreateTime(new Date());
                bbPersonBaseDao.insertFromTemp(bbPersonTemporary);

                bbFace.setResourceId(faceIds);
                bbFace.setCreateTime(new Date());
                bbFaceDao.insertSelective(bbFace);

        }catch (Exception e){
            e.printStackTrace();
        }

    }

    @Override
    @Transactional
    public void insert1(BbPerson bbPersonBase) {
        try {

            bbPersonBaseDao.insertSelective(bbPersonBase);

        }catch (Exception e){
            e.printStackTrace();
        }

    }

    @Override
    @Transactional
    public void save(BbPerson bbPersonTemporary) {
        try {

            bbPersonTemporary.setUpdateTime(new Date());
            bbPersonBaseDao.updateByPrimaryKeySelective(bbPersonTemporary);

        }catch (Exception e){
            e.printStackTrace();
        }
    }

    @Override
    public BbPerson selectById(String id) {

        BbPerson bbPersonBase = bbPersonBaseDao.selectByPrimaryKey(id);
        return bbPersonBase;
    }

    @Override
    public List<BbPerson> select(Map<String, Object> param) {

        List<BbPerson> list = bbPersonBaseDao.findData(param);
        return list;
    }

    @Override
    public List<Map> selectAllAndFeature(String exPersonId) {
        return bbPersonBaseDao.selectAllAndFeature( exPersonId );
    }

    @Override
    public void delete(String id) {
        bbPersonBaseDao.updateByPrimaryKey(id);
    }

    @Override
    public int count(Map<String, Object> param) {

        int num = bbPersonBaseDao.count(param);
        return num;
    }

    @Override
    public String findFaceIdsByPhoto(String photos) {
        return  bbPersonBaseDao.findFaceIdsByPhoto(photos);
    }
    @Transactional
    @Override
    public void merge(String id,String mergeId,String userName) {
        String[] mergeFrom = mergeId.split(",");
        for (String s : mergeFrom) {
            bbPersonBaseDao.updateByPrimaryKey(s);
        }
        /**
         * 在新增之前先判断表中是否已存在该数据
         */
        System.out.println("打印的idid为"+id);
        MergeFrom merge = mergeFromDao.findById(id);
//        System.out.println("打印的合并id为"+merge.getId());
        if(merge!=null && merge.getId()!=null){
            /**
             * 能查出的话，说明库中有此人员
             */
            mergeFromDao.deleteMergePerson(merge.getId());
            MergeFrom mergeFrom1 = new MergeFrom();
            mergeFrom1.setPersonId(id);
            mergeFrom1.setMergeFrom(mergeId);
            mergeFrom1.setCreateTime(new Date());
            mergeFrom1.setCreateBy(userName);
            mergeFromDao.insertSelective(mergeFrom1);
        }else {
            MergeFrom mergeFrom1 = new MergeFrom();
            mergeFrom1.setPersonId(id);
            mergeFrom1.setMergeFrom(mergeId);
            mergeFrom1.setCreateTime(new Date());
            mergeFrom1.setCreateBy(userName);
            mergeFromDao.insertSelective(mergeFrom1);
        }
    }
    @Transactional
    @Override
    public Result editToSave(Map jsonMap, String userName) {

        Object obj =jsonMap.get("bean");
        String s = JSONObject.toJSONString(obj);
        BbPerson bbPersonTemporary=JSONObject.parseObject(s,BbPerson.class);
        String isMerge = (String)jsonMap.get("isMerge");
        String mergeId = (String)jsonMap.get("mergeFrom");
        String[] mergeFrom = null;
        if(mergeId!=null&&!mergeId.equals("")){
            mergeFrom = mergeId.split(",");
        }

        if(isMerge.equals("0")){
            //未合并，确定要新增
            log.info("临时库，未合并，直接新增");
            bbPersonTemporary.setCreateBy(userName);
            bbPersonTemporary.setCreateTime(new Date());
            insert1(bbPersonTemporary);
            //在临时库中删除此人
            temporaryServiceImpl.delete(bbPersonTemporary.getId());

        }else {
            //要保存的是合并后的人
            //如果是临时库里来的，则有路径有特征值和总库一样，但某id所对应的图片变了则其对应的特征值也要变，需要由图片路径查到faceids，更新保存人员的faceids
            boolean containId = temporaryServiceImpl.isContainId(bbPersonTemporary.getId());
            if(containId){
                //如果containId为true则临时库有此人，说明用的是临时库的id，此操作为新增
                log.info("containId为true则临时库有此人，说明用的是临时库的id，此操作为新增");
                bbPersonTemporary.setCreateBy(userName);
                bbPersonTemporary.setCreateTime(new Date());
                insert1(bbPersonTemporary);

                //将被合并的人从总库删除并在mergeFrom表中插入一条数据
                for (String s1 : mergeFrom) {
                    log.info("删除了这个id的人"+s1);
                    delete(s1);
                }
                merge(bbPersonTemporary.getId(),mergeId,userName);
                //在临时库中删除此人
                temporaryServiceImpl.delete(bbPersonTemporary.getId());

            }else{
                //如果containId为false则临时库无此人，说明用的是总库的id，此操作为更新、
                this.save(bbPersonTemporary);
                //将被合并的人从总库和临时库中删除并在mergeFrom表中插入一条数据
                for (String s1 : mergeFrom) {
                    log.info("删除了这个id的人"+s1);
                    //不判断某个id具体是哪个库里的人，对于每个id各删一遍
                    this.delete(s1);
                    temporaryServiceImpl.delete(s1);
                }
                merge(bbPersonTemporary.getId(),mergeId,userName);
            }
        }


        return Result.custom("保存成功", HttpStatus.OK.value(),true,"");
    }

    public List selectLikerPerson(int liker, byte[] imageData) throws Exception {
        //从底库拿到所有人的特征值（需要一个关联查询faceIDs  resourceId）
        List<Map> featureList = selectAllAndFeature(null);
        log.info("底库中需要对比的人脸有："+featureList.size()+"份数据");
//        byte[] imgdata = FastDFSUtil2.downloadFDFS(path.substring(0,6),path.substring(7));
//        ArrayList<FaceResults> faceResults = FaceSdkTool.extractFace(imageData);
        List<Map> baseList = new ArrayList<>();
        if(featureList.size()>0){
            for(Map featureMap : featureList){
                Float likeVal =0.0f;
                if((byte[])featureMap.get("feature")!=null && !"".equals((byte[])featureMap.get("feature"))){
                    likeVal = FaceSdkTool.compareFeature((byte[])featureMap.get("feature"), imageData);
                   // log.info("相似值liker是："+likeVal);
                }

                if(likeVal*100>liker){

                    featureMap.put("liker",Math.round(likeVal*100));
                    featureMap.remove("feature");

                    baseList.add(featureMap);
                }
            }

        }
        return baseList;
    }
}