package com.brilliance.isc.common.transaction.newcheck.bopdec;

import com.brilliance.isc.bo.Bopcod;
import com.brilliance.isc.common.transaction.newcheck.ValidResult;
import com.brilliance.isc.mda.dao.BopcodMapper;
import com.brilliance.mda.runtime.mda.util.Dates;
import com.brilliance.mda.runtime.mda.util.MdaUtils;
import com.brilliance.mda.runtime.mda.util.Strings;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import java.math.BigDecimal;
import java.text.DateFormat;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.List;

@Component
public class BopdecCommon {

    @Autowired
    private BopcodMapper bopcodMapper;

    public Boolean isValidEntpCode(String custCode){
        ///检测组织机构代码
        int[] ws = { 3, 7, 9, 10, 5, 8, 4, 2 };
        String str = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ";
        String regex = "([0-9A-Z]){8}[0-9|X]";
        if (!custCode.matches(regex)) {
            return false;
        }
        int sum = 0;
        for (int i = 0; i < 8; i++) {
            sum += str.indexOf(String.valueOf(custCode.charAt(i))) * ws[i];
        }
        int c9 = 11 - (sum % 11);
        String sc9 = String.valueOf(c9);
        if (11 == c9) {
            sc9 = "0";
        }else if (10 == c9) {
            sc9 = "X";
        }
        return sc9.equals(String.valueOf(custCode.charAt(8)));
    }

    public   boolean containsValue(String fcyacc,String splstr) {
        boolean bool=false;
        String [] s= splstr.split("-");
        int len=s.length;
        for(int i=1;i<len;i++) {
            bool= fcyacc.contains(s[i]);
            if(bool){
                break;
            }
        }
        return bool;
    }

    public  boolean indexGt(String fld,String str) {
        boolean bool=false;
        if (MdaUtils.isEmpty(fld)) {
            return false;
        }
        if (str.indexOf(fld)>0) {
            bool = true;
        }
        return bool;
    }

    public  boolean startsWithValue(String fld,String splstr) {
        boolean bool=false;
        if (MdaUtils.isEmpty(fld)) {
            return false;
        }
        String [] s= splstr.split("-");
        int len=s.length;
        for(int i=1;i<len;i++) {
            bool= fld.startsWith(s[i]);
            if(bool) {
                break;
            }
        }
        return bool;
    }

    public  boolean isChinese(String content) {
        ///判断字符串中是否含有中文字符
        char[] charArr = content.toCharArray();
        for(int i = 0; i < charArr.length; i ++) {
            if(charArr[i] >= 19968 && charArr[i] <= 40869)
                return true;
        }
        return false;
    }

    public  boolean isALLChinese(String content) {
        if (MdaUtils.isEmpty(content)) {
            return false;
        }
        ///判断字符串中是否全为中文字符
        char[] charArr = content.toCharArray();
        Boolean flag = true;
        for(int i = 0; i < charArr.length; i ++) {
            if(!(charArr[i] >= 19968 && charArr[i] <= 40869)) {
                return false;
            }
        }
        return flag;
    }

    public boolean startsWithValueUpper(String fld,String splstr) {
        boolean bool=false;
        if (MdaUtils.isEmpty(fld)) {
            return false;
        }
        String [] s= splstr.split("-");
        int len=s.length;
        for(int i=1;i<len;i++) {
            bool= fld.toUpperCase().startsWith(s[i]);
            if(bool) {
                break;
            }
        }
        return bool;
    }

    public boolean containsValueUpper(String fld,String splstr) {
        boolean bool=false;
        if (MdaUtils.isEmpty(fld)) {
            return false;
        }
        String [] s= splstr.split("-");
        int len=s.length;
        for(int i=1;i<len;i++) {
            bool= fld.toUpperCase().contains(s[i]);
            if(bool) {
                break;
            }
        }
        return bool;
    }

    public  boolean indexLe(String fld,String str) {
        boolean bool=false;
        if (MdaUtils.isEmpty(fld)) {
            return false;
        }
        if (str.indexOf(fld)<0) {
            bool = true;
        }
        return bool;
    }

    public Date getCoreSysDay() {
        return Dates.today();
    }

    public  String format(Date date, String pattern) {
        DateFormat dateFormat = new SimpleDateFormat(pattern);
        if (date != null) {
            return dateFormat.format(date);
        }else {
            return null;
        }
    }

    public String insteadPercent(String start , String first, String last) {
        String bb = "";
        int shi = start.indexOf(first);
        int fei = start.indexOf(last);
        int length = first.length();
        if (shi >= 0 && fei >= 0 && fei - shi > length) {
            shi = shi + length;
            bb  = start.substring(shi, fei);

        }
        return bb;
    }

    /*
  #!输出error结果
  #!===================================
  #!参数：  typ    A 结汇金额, 现汇金额, 其它金额至少输入一项
  #!        typ    B 结汇金额、现汇金额、其它金额之和不能大于收入款金额
  #!        typ    C 不能与交易编码1相同
  #!        typ    D 两个交易编码对应的金额之和必须等于收入款金额
  #!        typ    E 付款金额必须大于零
  #!        typ    F 购/结汇金额不为0,则汇率不能为空
  #!        typ    G 扣费金额币种必须同时为空或者同时有值
  #!        typ    H 两个交易编码对应的金额之和必须等于实际付款金额!
  #!        typ    I 两个交易编码对应的金额之和必须等于汇款金额!
  #!        typ    J 购汇金额, 现汇金额, 其它金额至少输入一项!
  #!        typ    K 购汇金额、现汇金额、其它金额之和不能大于实际付款金额!
  #!        typ    L 购汇金额、现汇金额、其它金额之和不能大于汇款金额!
  #!        typ    M 相应金额1必须大于或等于相应金额2
  #!===================================
  */
    public ValidResult checkErrorText(String typ ) {
        switch (typ){
            case "A":
                return ValidResult.build(false, "结汇金额, 现汇金额, 其它金额至少输入一项!");
            case "B":
                return ValidResult.build(false, "结汇金额、现汇金额、其它金额之和应不大于收入款金额!");
            case "C":
                return ValidResult.build(false, "不能与交易编码1相同!");
            case "D":
                return ValidResult.build(false, "两个交易编码对应的金额之和必须等于收入款金额!");
            case "E":
                return ValidResult.build(false, "付款金额必须大于零!");
            case "F":
                return ValidResult.build(false, "购/结汇金额不为0,则汇率不能为空!");
            case "G":
                return ValidResult.build(false, "扣费的币种金额必须同时为空或者同时输入有值!");
            case "H":
                return ValidResult.build(false, "两个交易编码对应的金额之和必须等于付款金额!");
            case "I":
                return ValidResult.build(false, "两个交易编码对应的金额之和必须等于汇款金额!");
            case "J":
                return ValidResult.build(false, "购汇金额, 现汇金额, 其它金额至少输入一项!");
            case "K":
                return ValidResult.build(false, "购汇金额、现汇金额、其它金额之和应等于付款金额!");
            case "L":
                return ValidResult.build(false, "购汇金额、现汇金额、其它金额之和应等于汇款金额!");
            case "M":
                return ValidResult.build(false, "相应金额1必须大于或等于相应金额2!");
        }
        return null;
    }

    /*
			  #!对结汇金额(购汇), 现汇金额, 其它金额做检核
			  #!===================================
			  #!返回值：ture   需要检核
			  #!        false  不需要检核
			  #!        tamt   收入款金额/对外付款金额/汇款金额
			  #!        lamt   现汇金额
			  #!参数：  typ    A 结汇金额(购汇), 现汇金额, 其它金额至少输入一项
			  #!        typ    B 结汇金额、现汇金额、其它金额之和不能大于收入款金额
			  #!        typ    C 购汇金额、现汇金额、其它金额之和应等于付款金额
			  #!===================================
			  */
    public boolean checkAmt(BigDecimal tamt, BigDecimal lamt, BigDecimal famt,BigDecimal oamt,String typ ) {
        boolean rul = false;
        BigDecimal amt= BigDecimal.ZERO;
        BigDecimal zero = BigDecimal.ZERO;
        if ("A".equals(typ)) {
            if (famt.compareTo(zero) == 0 && lamt.compareTo(zero) == 0 && oamt.compareTo(zero) == 0) {
                rul = true;
            }
        }
        //#假设结汇金额(购汇)、现汇金额、其它金额、收入款金额都为同一币种
        amt = famt.add(lamt).add(oamt);
        if ("B".equals(typ) ) {
            if (amt.compareTo(tamt) > 0) {
                rul = true;
            }
        }
        if ("C".equals(typ) ) {
            if (amt.compareTo(tamt) != 0) {
                rul = true;
            }
        }
        return rul;
    }

    //依据收入和支出标志，判断是否是资本项目下编码，目前给结售汇使用
    //dir：I 收入  ；O 支出
    //cod：交易编码
    //涉外收支有部分未启用，所以在境内划转中需要单独判断一下
    public boolean jshisZb(String transName,String dir,String cod) {
        if(MdaUtils.isEmpty(cod)||MdaUtils.isEmpty(dir)) {
            return false;
        }
        String head = cod.substring(0,1);
        String traNam = Strings.mid(transName.toLowerCase(),1,3);
        if("35678".contains(head)) {
            return true;
        }
        if("903010".equals(cod)||"923010".equals(cod)||"923020".equals(cod)||"923090".equals(cod)||"924030".equals(cod)||"929010".equals(cod)||"929090".equals(cod)) {
            if("dbe".equals(traNam)||"dbf".equals(traNam)) {
                return true;
            }
        }
        return false;
    }

    //资本项目下交易提示类
    //2021年四月需求《境内收入申报单》、《境内汇款申请书》、《境内付款承兑通知书》：交易编码1和交易编码2，判断是否是资本项目，增加921010,921020,924010,929040,929050,929060,929070。
    public boolean tsisZb(String transName,String dir,String cod) {
        if(MdaUtils.isEmpty(cod)||MdaUtils.isEmpty(dir)) {
            return false;
        }
        String traNam = Strings.mid(transName.toLowerCase(),1,3);
        if("921010".equals(cod)||"921020".equals(cod)||"924010".equals(cod)||"929040".equals(cod)||"929050".equals(cod)||"929060".equals(cod)||"929070".equals(cod)) {
            return true;
        }
        return false;
    }

    public boolean isZb(String cod) {
        //判断是否资本项目类型
        if(MdaUtils.isEmpty(cod)) {
            return false;
        }
        //return "56789".contains(cod.substring(0,1));
        //35678和部分29
        String head=cod.substring(0,1);
        if("356789".contains(head)) {
            return true;
        }
        if("226000".equals(cod)) {
            return true;
        }else{
            return false;
        }
    }

    public boolean isZbxm(String cod,String dir){
        if(MdaUtils.isEmpty(cod)) {
            return false;
        }
        Bopcod bopcod = new Bopcod();
        bopcod.setCod(cod);
        bopcod.setDir(dir);
        bopcod.setTyp("C");
        List<Bopcod> bopcodList = bopcodMapper.listByUniqueKey(bopcod);
        if(bopcodList.size() > 0){
            return true;
        }
        return false;
    }
}
