package cn.cslg.pas.service;

import cn.cslg.pas.common.PatentRightContent;
import cn.cslg.pas.common.TreeBuild;
import cn.cslg.pas.common.TreeNode;
import cn.cslg.pas.common.model.params.PatentRightParams;
import cn.cslg.pas.common.utils.StringUtils;
import cn.cslg.pas.common.utils.ThrowException;
import cn.cslg.pas.domain.Authority;
import cn.cslg.pas.domain.Patent;
import cn.cslg.pas.domain.PatentRight;
import cn.cslg.pas.mapper.PatentRightMapper;
import cn.cslg.pas.service.patentRightSplit.*;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.BeanUtils;
import org.springframework.context.annotation.Lazy;
import org.springframework.stereotype.Service;

import java.util.ArrayList;
import java.util.List;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import java.util.stream.Collectors;

/**
 * @author Administrator
 * @description 针对表【os_patent_right(专利权利要求)】的数据库操作Service
 * @createDate 2022-04-16 10:09:24
 */
@Slf4j
@Service
@RequiredArgsConstructor(onConstructor_ = {@Lazy})
public class PatentRightService extends ServiceImpl<PatentRightMapper, PatentRight> {
    private final PatentService patentService;
    private final PatentRightSplitCNService patentRightSplitCNService;
    private final PatentRightSplitENService patentRightSplitENService;
    private final PatentRightSplitJPService patentRightSplitJPService;
    private final PatentRightSplitKRService patentRightSplitKRService;

    public List<PatentRight> getPatentRightByPatentNo(String patentNo) {
        Patent patent = patentService.getByPatentNo(patentNo);
        if (patent == null) {
            patent = new Patent();
        }
        LambdaQueryWrapper<PatentRight> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.eq(PatentRight::getPatentId, patent.getId());
        queryWrapper.orderByAsc(PatentRight::getSort);
        return this.list(queryWrapper);
    }

    public List<PatentRight> getPatentRightByPatentId(Integer patentId) {
        LambdaQueryWrapper<PatentRight> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.eq(PatentRight::getPatentId, patentId);
        queryWrapper.orderByAsc(PatentRight::getSort);
//        List<PatentRight> patentRights = this.list(queryWrapper);
//        if (patentRights != null && patentRights.size() > 0) {
//            PatentRight patentRight = patentRights.get(0);
//            //创建PatentRightParams对象保存权要基本信息
//            PatentRightParams patentRightParams = new PatentRightParams();
//            patentRightParams.setPatentId(patentId);  //装载专利id
//            patentRightParams.setPatentNo(patentService.getById(patentId).getPatentNo());
//            patentRightParams.setContent(patentRight.getContent());  //装载权利要求原文
//            patentRightParams.setContentOut(patentRight.getContentOut());  //装载权利要求译文
//            patentRights = PatentRightUtils.formatPatentRight(patentRightParams);
//            return patentRights;
//        }
        return this.list(queryWrapper);
    }

    public List<PatentRight> getPatentRightByPatentIds(List<Integer> patentIds) {
        if (patentIds == null || patentIds.size() == 0) {
            return new ArrayList<>();
        }
        LambdaQueryWrapper<PatentRight> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.in(PatentRight::getPatentId, patentIds);
        queryWrapper.orderByAsc(PatentRight::getSort);
        return this.list(queryWrapper);
    }

    public void deleteByPatentId(Integer patentId) {
        this.remove(Wrappers.<PatentRight>lambdaQuery().eq(PatentRight::getPatentId, patentId));
    }

    public void importPatentRight(Integer localPatentId, Integer importPatentId, List<PatentRight> importPatentRightList) {
        this.deleteByPatentId(localPatentId);
        List<PatentRight> patentRightList = importPatentRightList.stream().filter(item -> item.getPatentId().equals(importPatentId)).collect(Collectors.toList());
        for (PatentRight patentRight : patentRightList) {
            patentRight.setId(null);
            patentRight.setPatentId(localPatentId);
        }
        this.saveOrUpdateBatch(patentRightList);
    }

    public void importAuthority(PatentRightParams params) {
        List<Authority> splits = splits(params);
        List<Authority> authorities = relationshipAuthority(splits);
        List<Authority> authorities1 = relationshipAuthority3(authorities);
        List<Authority> authorities2 = relationshipAuthority2(authorities1);
        List<Authority> authorities3 = relationshipAuthority4(authorities2);
        for (Authority a : authorities3) {
            Authority authority = new Authority();
            authority.setContent(a.getContent());
            String join = StringUtils.join(a.getFatherID(), ",");
            authority.setFID(join);
            String join1 = StringUtils.join(a.getSonID(), ",");
            authority.setSID(join1);
            authority.setPatentID(params.getPatentId());
            authority.setType(a.getType());
            authority.insert();

        }
    }

    public List<Authority> splits(PatentRightParams params) {
        //去掉全要开头的""
        List<Authority> list = new ArrayList<>();
        String selfContent = params.getContent();
        if (selfContent == null) {
            selfContent = "";
        }
        //청구항 2. 삭제(是否删除代办)
        //  selfContent.replaceAll("청구항(\\s)(^\\d*$+)(\\s)삭제","");
        selfContent.replaceAll("''", "");
        selfContent.replaceAll("(^\\d*$+)-(^\\d*$+)(\\.)(\\s)(canceled)", "");
//        selfContent.replaceAll("(^\\d*$+)(.)(\\s)(canceled)","");
        selfContent.replaceAll("\n", " ");

        //找到1. 2. ...这种格式的正则表达式
        String str1 = "(^\\d*$+)(\\.)";
        //找到[001]或者[002]这种格式的
        String str2 = "(\\[)(^[1-9]/d*$+)(\\])";
        //【請求項 1】
        String str3 = "(\\【請求項)(^[1-9]/d*$+)(\\】)";
        //청구항 1()
        String str4 = "청구항(\\s)(^[1-9]/d*$+)(\\.)";
        Pattern p4 = Pattern.compile(str4);
        Matcher m4 = p4.matcher(selfContent);
        List<Integer> integers1 = new ArrayList<>();
        while (m4.find()) {
            integers1.add(m4.start());
        }
        if (integers1.size() != 0) {
            for (int i = integers1.size() - 1; i >= 0; i--) {
                String str = selfContent.substring(integers1.get(i));
                Authority authority = new Authority();
                authority.setContent(str);
                list.add(authority);

            }
            Authority authority = new Authority();
            authority.setContent(selfContent);
            list.add(authority);
            return list;
        }


        Pattern p = Pattern.compile(str1);
        Matcher m = p.matcher(selfContent);
        //判断找到的数量
        List<Integer> integers = new ArrayList<>();
        while (m.find()) {
            integers.add(m.start());
        }
        if (integers.size() != 0) {
            for (int i = integers.size() - 1; i > 0; i--) {
                String str = selfContent.substring(integers.get(i));
                Authority authority1 = new Authority();
                authority1.setContent(str);
                list.add(authority1);

            }
            Authority authority1 = new Authority();
            authority1.setContentOut(selfContent);
            list.add(authority1);
            return list;
        }

        Pattern compile = Pattern.compile(str2);
        Matcher matcher = compile.matcher(selfContent);
        List<Integer> start = new ArrayList<>();
        while (matcher.find()) {
            start.add(matcher.start());

        }
        if (start.size() != 0) {
            for (int i = start.size() - 1; i > 0; i--) {
                String str = selfContent.substring(integers.get(i));
                Authority authority2 = new Authority();
                authority2.setContent(str);
                list.add(authority2);

            }
            Authority authority2 = new Authority();
            authority2.setContent(selfContent);
            list.add(authority2);
            return list;
        }


        Pattern compile1 = Pattern.compile(str3);
        Matcher matcher1 = compile1.matcher(selfContent);
        List<Integer> start1 = new ArrayList<>();

        while (matcher1.find()) {
            start1.add(matcher1.start());

        }
        if (start1.size() != 0) {
            for (int i = start1.size() - 1; i >= 0; i--) {
                String str = selfContent.substring(integers.get(i));
                Authority authority3 = new Authority();
                authority3.setContent(str);
                list.add(authority3);
            }

            Authority authority3 = new Authority();
            authority3.setContent(selfContent);
            list.add(authority3);
        }
        return list;
    }


    /**
     * 英文下的处理方式(草稿)
     */
    private List<Authority> relationshipAuthority(List<Authority> list) {

        List<Authority> authorities = list;
        //英文下的claim 1，claim2 的正则表达式
        String str1 = "(claim)(\\s)(^\\d*$+)";
        Pattern p = Pattern.compile(str1);
        for (int i = 0; i < list.size(); i++) {
            //去掉空格
            authorities.get(i).getContent().replaceAll(" ", "");
            Matcher m = p.matcher(authorities.get(i).getContent());
            if (!m.find()) {
                list.get(i).setFID(null);
                list.get(i).setType(0);
                return list;
            } else {
                //找到了
                String group = m.group(0);
                //把claim去掉只剩下面的数字
                String substring = group.substring(5);
                int j = Integer.parseInt(substring);
                List<Integer> sonID = list.get(j - 1).getSonID();
                sonID.add(authorities.get(i).getId());
                list.get(j - 1).setSonID(sonID);
                List<Integer> fatherID = list.get(i).getFatherID();
                fatherID.add(list.get(j - 1).getId());
                list.get(i).setFatherID(fatherID);
                //设置为
                list.get(i).setType(1);
            }
        }
        return list;
    }

    /**
     * 小日子的语言下的处理模式
     */
    private List<Authority> relationshipAuthority3(List<Authority> list) {
        List<Authority> authorities = list;
        //英文下的claim 1，claim2 的正则表达式
        String str1 = "(前記第)(^\\d*$+)";
        Pattern p = Pattern.compile(str1);
        for (int i = 0; i < list.size(); i++) {

            Matcher m = p.matcher(authorities.get(i).getContent());
            if (!m.find()) {
                list.get(i).setFID(null);
                list.get(i).setType(0);
                return list;
            } else {
                //找到了
                String group = m.group(0);
                //把claim去掉只剩下面的数字
                String substring = group.substring(3);
                int j = Integer.parseInt(substring);
                List<Integer> sonID = list.get(j - 1).getSonID();
                sonID.add(authorities.get(i).getId());
                list.get(j - 1).setSonID(sonID);
                List<Integer> fatherID = list.get(i).getFatherID();
                fatherID.add(list.get(j - 1).getId());
                list.get(i).setFatherID(fatherID);
                //设置为
                list.get(i).setType(1);
            }
        }
        return list;
    }

    /**
     * 中文下的处理方式
     */
    public List<Authority> relationshipAuthority2(List<Authority> list) {
        //中文下权利要求1，权利要求2，权利要求3
        String str1 = "(权利要求)(^\\d*$+)";
        //中文下权利要求1至
        String str2 = "(权利要求)(^\\d*$+)(至)(^\\d*$+)";
        //中文下权利要求 或
        String str3 = "(权利要求)(^\\d*$+)(或)(^\\d*$+)";

        Pattern p = Pattern.compile(str1);
        Pattern p1 = Pattern.compile(str2);
        Pattern p2 = Pattern.compile(str3);
        for (int i = 0; i < list.size(); i++) {
            Matcher matcher = p.matcher(list.get(i).getContent());
            if (matcher.find()) {
                list.get(i).setType(1);
                //找到满足第一情况
                Matcher matcher1 = p1.matcher(list.get(i).getContent());
                if (matcher1.find()) {
                    //找到满足第一和第二种情况按第二种情况处理
                    String group = matcher1.group(0);
                    String str5 = "^\\d*$+";
                    Pattern p3 = Pattern.compile(str5);
                    Matcher matcher2 = p3.matcher(group);
                    if (matcher2.find()) {
                        String group1 = matcher2.group(0);
                        String group2 = matcher2.group(1);
                        Integer j = Integer.parseInt(group1);
                        Integer k = Integer.parseInt(group2);
                        for (int l = j - 1; l < k; l++) {
                            List<Integer> sonID = list.get(l).getSonID();
                            sonID.add(list.get(i).getId());
                            list.get(l).setSonID(sonID);
                            List<Integer> fatherID = list.get(i).getFatherID();
                            fatherID.add(list.get(l).getId());
                            list.get(i).setFatherID(fatherID);
                        }
                    }
                } else {
                    Matcher matcher2 = p2.matcher(list.get(i).getContent());
                    if (matcher2.find()) {
                        //找到满足第三和第一情况按第三中情况处理
                        String group = matcher1.group(0);
                        String str6 = "^\\d*$+";
                        Pattern p3 = Pattern.compile(str6);
                        Matcher matcher3 = p3.matcher(group);
                        if (matcher3.find()) {
                            String group1 = matcher2.group(0);
                            String group2 = matcher2.group(1);
                            Integer j = Integer.parseInt(group1);
                            Integer k = Integer.parseInt(group2);
                            List<Integer> sonID = list.get(j).getSonID();
                            sonID.add(list.get(i).getId());
                            list.get(j).setSonID(sonID);
                            List<Integer> fatherID = list.get(i).getFatherID();
                            fatherID.add(list.get(j).getId());
                            list.get(i).setFatherID(fatherID);
                            List<Integer> sonID1 = list.get(k).getSonID();
                            sonID1.add(list.get(i).getId());
                            list.get(k).setSonID(sonID1);
                            List<Integer> fatherID1 = list.get(i).getFatherID();
                            fatherID1.add(list.get(k).getId());
                            list.get(i).setFatherID(fatherID1);
                        }
                    } else {
                        //只满足第一中情况
                        String group = matcher.group(0);
                        String str7 = "^\\d*$+";
                        Pattern p3 = Pattern.compile(str7);
                        Matcher matcher3 = p3.matcher(group);
                        if (matcher3.find()) {
                            String group1 = matcher2.group(0);
                            Integer j = Integer.parseInt(group1);
                            List<Integer> sonID = list.get(j).getSonID();
                            sonID.add(list.get(i).getId());
                            list.get(j).setSonID(sonID);
                            List<Integer> fatherID = list.get(i).getFatherID();
                            fatherID.add(list.get(j).getId());
                            list.get(i).setFatherID(fatherID);
                        }
                    }

                }
            } else {
                list.get(i).setType(0);
                list.get(i).setFID(null);
            }
        }
        return list;
    }

    /**
     * 韩文下的处理
     */
    public List<Authority> relationshipAuthority4(List<Authority> list) {
        //韩文情况下的正则表达式
        String str1 = "제(\\s)(^\\d*$+)항";     //"제 1항에" ;
        String str3 = "제(\\s)(^\\d*$+)항(\\s)또는(\\s)제(^\\d*$+)항";//제 1항 또는 제 2항에 있어서 这种情况下的正则表达式
        Pattern p = Pattern.compile(str1);
        for (int i = 0; i < list.size(); i++) {

//            list.get(i).getContent().replaceAll(" ", "");
            Matcher m = p.matcher(list.get(i).getContent());
            if (!m.find()) {
                list.get(i).setFID(null);
                list.get(i).setType(0);

            } else {
                //找到了
                Pattern compile = Pattern.compile(str3);
                Matcher matcher1 = compile.matcher(list.get(i).getContent());
                if (matcher1.find()) {
                    String group = m.group(0);
                    String str2 = "(^\\d*$+)";
                    Pattern p1 = Pattern.compile(str1);
                    Matcher matcher = p1.matcher(group);
                    String group1 = matcher.group(0);
                    String group2 = matcher.group(1);
                    Integer j = Integer.parseInt(group1);
                    Integer k = Integer.parseInt(group2);
                    List<Integer> sonID = list.get(j).getSonID();
                    sonID.add(list.get(i).getId());
                    list.get(j).setSonID(sonID);
                    List<Integer> fatherID = list.get(i).getFatherID();
                    fatherID.add(list.get(j).getId());
                    list.get(i).setFatherID(fatherID);
                    List<Integer> sonID1 = list.get(k).getSonID();
                    sonID1.add(list.get(i).getId());
                    list.get(k).setSonID(sonID1);
                    List<Integer> fatherID1 = list.get(i).getFatherID();
                    fatherID1.add(list.get(k).getId());
                    list.get(i).setFatherID(fatherID1);


                } else {
                    String group = m.group(0);
                    String str2 = "(^\\d*$+)";
                    Pattern p1 = Pattern.compile(str1);
                    Matcher matcher = p1.matcher(group);
                    String substring = matcher.group(0);
                    int j = Integer.parseInt(substring);
                    List<Integer> sonID = list.get(j - 1).getSonID();
                    sonID.add(list.get(i).getId());
                    list.get(j - 1).setSonID(sonID);
                    List<Integer> fatherID = list.get(i).getFatherID();
                    fatherID.add(list.get(j - 1).getId());
                    list.get(i).setFatherID(fatherID);
                    //设置为
                    list.get(i).setType(1);
                }
            }
        }
        return list;

    }

    /**
     * 1.格式化权要 2.理出主次权要父子关系 3.权要表"os_patent_right"更新或新增权要
     *
     * @param params 权利要求相关数据
     */
    public void updatePatentRight(PatentRightParams params) {
        try {

            if (params.getContent() == null || params.getContent().trim().equals("")) {
                return;
            }

            //不进行拆分，原文直接保存入库
            PatentRight patentRight = new PatentRight()
                    .setPatentId(params.getPatentId())
                    .setContent(params.getContent())
                    .setContentOut(params.getContentOut());
            if (patentRight.getContent() != null && !patentRight.getContent().equals("")) {
                this.deleteByPatentId(patentRight.getPatentId());
                this.saveOrUpdate(patentRight);
            }

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

    }

    /**
     * 查询权要树
     *
     * @param patentNo 专利号
     * @return 返回权要树集合
     */
    public List<TreeNode> queryPatentRightTree(String patentNo) {
        log.info("开始处理【查询权要树】的业务，业务参数为：patentNo={}", patentNo);

        //根据专利号查询出专利
        List<Patent> patents = patentService.list(new LambdaQueryWrapper<Patent>().eq(Patent::getPatentNo, patentNo));

        //判断若专利不存在，则返回错误提示"专利已不存在，请尝试刷新页面"
        if (patents == null || patents.size() == 0) {
            ThrowException.throwXiaoShiException("专利已不存在，请尝试刷新页面");
        }

        Patent patent = patents.get(0);
        Integer patentId = patent.getId();

        //根据专利id查询出权要
        List<PatentRight> patentRights = this.list(new LambdaQueryWrapper<PatentRight>().eq(PatentRight::getPatentId, patentId));

        //装载权要原文
        PatentRightParams params = new PatentRightParams();
        params.setPatentId(patentId);
        params.setPatentNo(patent.getPatentNo());
        //对获得的权利要求集合，判断集合元素个数若为1则为原文文本；若大于1则为已经拆分了的多个权要文本，此时就将其合并回原文文本
        if (patentRights.size() == 1) {
            params.setContent(patentRights.get(0).getContent());
        } else if (patentRights.size() > 1) {
            StringBuilder contentBuilder = new StringBuilder();
            patentRights.forEach(patentRight -> {
                contentBuilder.append(patentRight.getContent()).append("\n");
            });
            params.setContent(contentBuilder + "");
        }

        //调用拆分权要工厂类方法，返回对应该国家专利的拆分权要方法的对象
        PatentRightSplitService obj = getPatentRightSplitServiceObj(patent.getPatentNo());
        //对象调用拆分权要方法，返回处理过的（经过拆分、理出主附权要、理出层级关系的）权要集合
        List<PatentRightContent> patentRightContents = obj.formatPatentRight(params);

        List<TreeNode> treeNodeList = new ArrayList<>();

        //判断若处理后的权要集合只有1个元素并且类型type=-1、排序号sort=-1，则表示本次拆分失败，则直接返回整个权要
        if (patentRightContents.size() == 1 && patentRightContents.get(0).getType() == -1 && patentRightContents.get(0).getSort() == -1) {
            treeNodeList.add(new TreeNode(patentRightContents.get(0).getSort(), null, patentRightContents.get(0).getContent()));
            return treeNodeList;
        }

        for (PatentRightContent patentRightContent : patentRightContents) {
            treeNodeList.add(new TreeNode(patentRightContent.getSort(), patentRightContent.getParentSorts(), patentRightContent.getContent()));
        }
        //开始进行权要树装载
        try {
            TreeBuild treeBuild = new TreeBuild(treeNodeList);
            treeNodeList = treeBuild.buildTree();
        } catch (Exception e) {
            e.printStackTrace();
        }
        return treeNodeList;

    }

    /**
     * 给原始权要进行拆分
     *
     * @param patentNo 专利号
     * @return 返回拆分后的权要
     */
    public List<PatentRight> formatPatentRights(String patentNo) {
        Patent patent = patentService.getByPatentNo(patentNo);
        if (patent == null) {
            patent = new Patent();
        }
        LambdaQueryWrapper<PatentRight> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.eq(PatentRight::getPatentId, patent.getId());
        queryWrapper.orderByAsc(PatentRight::getSort);
        List<PatentRight> patentRights = this.list(queryWrapper);

        //装载权要原文
        PatentRightParams params = new PatentRightParams();
        params.setPatentId(patent.getId());
        params.setPatentNo(patentNo);
        //对获得的权利要求集合，判断集合元素个数若为1则为原文文本；若大于1则为已经拆分了的多个权要文本，此时就将其合并回原文文本
        if (patentRights.size() == 1) {
            params.setContent(patentRights.get(0).getContent());
        } else if (patentRights.size() > 1) {
            StringBuilder contentBuilder = new StringBuilder();
            patentRights.forEach(patentRight -> {
                contentBuilder.append(patentRight.getContent()).append("\n");
            });
            params.setContent(contentBuilder + "");
        }

        //调用拆分权要工厂类方法，返回对应该国家专利的拆分权要方法的对象
        PatentRightSplitService obj = getPatentRightSplitServiceObj(patent.getPatentNo());
        //对象调用拆分权要方法，返回处理过的（经过拆分、理出主附权要、理出层级关系的）权要集合
        List<PatentRightContent> patentRightContents = obj.formatPatentRight(params);

        List<PatentRight> finalPatentRights = new ArrayList<>();
        patentRightContents.forEach(patentRightContent -> {
            PatentRight patentRight = new PatentRight();
            BeanUtils.copyProperties(patentRightContent, patentRight);
            finalPatentRights.add(patentRight);
        });

        return finalPatentRights;
    }


    public PatentRightSplitService getPatentRightSplitServiceObj(String patentNo) {
        String country = patentNo.substring(0, 2);
        switch (country) {
            case "CN":
                return patentRightSplitCNService;  //拆分中国专利
            case "JP":
                return patentRightSplitJPService;  //拆分日本专利
            case "KR":
                return patentRightSplitKRService;  //拆分韩国专利
            default:
                return patentRightSplitENService;  //拆分英文专利

        }

    }


}