package cn.cslg.pas.service;

import cn.cslg.pas.common.model.params.PatentRightParams;
import cn.cslg.pas.common.utils.PatentUtils;
import cn.cslg.pas.common.utils.Response;
import cn.cslg.pas.common.utils.StringUtils;
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 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 org.springframework.context.annotation.Lazy;
import org.springframework.stereotype.Service;

import java.util.ArrayList;
import java.util.Arrays;
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
 */
@Service
@RequiredArgsConstructor(onConstructor_ = {@Lazy})
public class PatentRightService extends ServiceImpl<PatentRightMapper, PatentRight> {

    private final PatentService patentService;

    public List<PatentRight> getPatentRightByPatentNo(String patentNo) {
        Patent patent = patentService.getByPatentNo(patentNo);
        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);
        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;

    }


    public void updatePatentRight(PatentRightParams params) {
        ArrayList<PatentRight> patentRights = new ArrayList<>();
        //获取国家(公开号的前两位)
        String country = PatentUtils.getPatentCountry(params.getPatentNo());

        //权利要求原文
        String content = params.getContent();
        //权利要求译文
        String contentOut = params.getContentOut();
        //先去掉所有换行符，使原文和原文译文都连起来
        content = content.replaceAll("\n", "");
        contentOut = contentOut.replaceAll("\n", "").replaceAll(" +", "");
        if (StringUtils.isNotEmpty(content)) {
            //先删除原来的专利权要
            this.deleteByPatentId(params.getPatentId());
            if (country.equals("CN") || country.equals("JP")) {
                String regex;
                if (content.contains("1.")) {
                    regex = "。[0-9]+[.]";
                } else if (content.contains("1、")) {
                    regex = "。[0-9]+[、]";
                } else if (content.contains("[001]")) {
                    regex = "\\[[0-9]+]";
                } else {
                    regex = "";
                }

                Pattern compile = Pattern.compile(regex);
                Matcher matcher = compile.matcher(content);
                Matcher matcherOut = compile.matcher(contentOut);
                while (matcher.find()) {
                    String matcherGroup = matcher.group();
                    matcherGroup = matcherGroup.substring(1).replace(".", "\\.");
                    content = content.replaceFirst(matcherGroup, "\n" + matcherGroup);
                }
                while (matcherOut.find()) {
                    String matcherGroup = matcherOut.group();
                    matcherGroup = matcherGroup.substring(1).replace(".", "\\.");
                    contentOut = contentOut.replaceFirst(matcherGroup, "\n" + matcherGroup);
                }
                String[] strs = content.split("\n");
                String[] strsOut = contentOut.split("\n");

                //定义父权要排序号
                String regex1 = "权利要求[0-9]+";
                String regex2 = "权利要求[0-9]+[至或～-]+[0-9]+";
                for (int i = 0; i < strs.length; i++) {
                    PatentRight patentRight = new PatentRight()
                            .setPatentId(params.getPatentId())
                            .setContent(strs[i])
                            .setContentOut(strsOut[i])
                            .setSort(i);
                    if (strs[i].contains("权利要求")) {
                        patentRight.setType(1);
                        Pattern compile1 = Pattern.compile(regex1);
                        Matcher matcher1 = compile1.matcher(strs[i]);
                        Pattern compile2 = Pattern.compile(regex2);
                        Matcher matcher2 = compile2.matcher(strs[i]);
                        if (matcher2.find()) {
                            String parentNum = matcher2.group().substring(matcher2.group().indexOf("求") + 1);
                            String[] parentNums;
                            String chr;
                            if (parentNum.contains("～")) {
                                chr = "～";
                            } else if (parentNum.contains("-")) {
                                chr = "-";
                            } else if (parentNum.contains("至")) {
                                chr = "至";
                            } else if (parentNum.contains("或")) {
                                chr = "或";
                            } else {
                                chr = "";
                            }
                            parentNums = parentNum.split(chr);
                            StringBuilder builder = new StringBuilder();
                            if (!chr.equals("或")) {
                                for (int j = Integer.parseInt(parentNums[0]) - 1; j < Integer.parseInt(parentNums[parentNums.length - 1]); j++) {
                                    if ((builder + "").equals("")) {
                                        builder.append(j);
                                    } else {
                                        builder.append(",").append(j);
                                    }
                                }
                            } else {
                                for (String num : parentNums) {
                                    if ((builder + "").equals("")) {
                                        builder.append(Integer.parseInt(num) - 1);
                                    } else {
                                        builder.append(",").append(Integer.parseInt(num) - 1);
                                    }
                                }
                            }
                            patentRight.setParentSort(builder + "");
                            patentRights.add(patentRight);
                        } else if (matcher1.find()) {
                            String parentNum = matcher1.group().substring(matcher1.group().indexOf("求") + 1);
                            patentRight.setParentSort((Integer.parseInt(parentNum) - 1) + "");
                            patentRights.add(patentRight);
                        }

                    } else {
                        patentRight.setType(0);
                        patentRight.setParentSort("-1");
                        patentRights.add(patentRight);
                    }
                }
            } else {
                String regex = "[0-9]+\\. ";
                String regexOut;
                if (contentOut.contains("1.")) {
                    regexOut = "。[0-9]+[.]";
                } else if (contentOut.contains("1、")) {
                    regexOut = "。[0-9]+[、]";
                } else if (contentOut.contains("[001]")) {
                    regexOut = "\\[[0-9]+]";
                } else {
                    regexOut = "";
                }
                Pattern compile = Pattern.compile(regex);
                Matcher matcher = compile.matcher(content);
                Pattern compileOut = Pattern.compile(regexOut);
                Matcher matcherOut = compileOut.matcher(contentOut);
                while (matcher.find()) {
                    String matcherGroup = matcher.group();
                    matcherGroup = matcherGroup.replace(".", "\\.");
                    content = content.replaceFirst(matcherGroup, "\n" + matcherGroup);
                }
                while (matcherOut.find()) {
                    String matcherOutGroup = matcherOut.group();
                    matcherOutGroup = matcherOutGroup.substring(1).replace(".", "\\.");
                    contentOut = contentOut.replaceFirst(matcherOutGroup, "\n" + matcherOutGroup);
                }
                content = content.substring(content.indexOf("1. "));
                contentOut = contentOut.substring(contentOut.indexOf("1."));
                String[] strs = content.split("\n");
                String[] strsOut = contentOut.split("\n");

                String regex1 = "claim [0-9]+";
                String regex2 = "claims [0-9]+ or [0-9]+";
                for (int i = 0; i < strs.length; i++) {
                    PatentRight patentRight = new PatentRight()
                            .setPatentId(params.getPatentId())
                            .setContent(strs[i])
                            .setContentOut(strsOut[i])
                            .setSort(i);
                    if (strs[i].contains("claim")) {
                        patentRight.setType(1);
                        Pattern compile1 = Pattern.compile(regex1);
                        Matcher matcher1 = compile1.matcher(strs[i]);
                        Pattern compile2 = Pattern.compile(regex2);
                        Matcher matcher2 = compile2.matcher(strs[i]);
                        if (matcher2.find()) {
                            String parentNum = matcher2.group().substring(matcher2.group().indexOf("s") + 2);
                            String[] parentNums;
                            if (parentNum.contains(" or ")) {
                                parentNums = parentNum.split(" or ");
                            } else {
                                parentNums = new String[0];
                            }
                            StringBuilder builder = new StringBuilder();
                            for (String num : parentNums) {
                                if ((builder + "").equals("")) {
                                    builder.append(Integer.parseInt(num) - 1);
                                } else {
                                    builder.append(",").append(Integer.parseInt(num) - 1);
                                }
                            }
                            patentRight.setParentSort(builder + "");
                            patentRights.add(patentRight);
                        } else if (matcher1.find()) {
                            String parentNum = matcher1.group().substring(matcher1.group().indexOf("m") + 2);
                            patentRight.setParentSort((Integer.parseInt(parentNum) - 1) + "");
                            patentRights.add(patentRight);
                        }

                    } else {
                        patentRight.setType(0);
                        patentRight.setParentSort("-1");
                        patentRights.add(patentRight);
                    }
                }
            }

        }
        this.saveOrUpdateBatch(patentRights);

    }


}