package com.sunyard.sge.database;

import com.sunyard.SydApiException;
import com.sunyard.proto.Util;
import com.sunyard.sge.log.LogFactory;
import com.sunyard.util.SYMUtil;
import org.apache.logging.log4j.Logger;
import racal.sunyard.main.SydApi4j;

import java.util.Arrays;
import java.util.List;

/**
 * 上海黄金交易所 - 数据库加密方案
 */
public class SydApi4Database implements SydApi {

    private SydApi4j[] hsms = null;
    private boolean isShortLinkMode = false;

    public SydApi4Database() {
        isShortLinkMode = true;
    }

    public SydApi4Database(SydApi4j[] hsms) {
        this.hsms = hsms;
    }

    @Override
    public SydApi SYD_Short_Connect_Ex(String[] pcIpList, int[] iPortList, int iConnectTimeOut, int allDealTimeOut) {
        Logger log = LogFactory.getLogger();
        if (LogFactory.iLogLevel==3) {
            log.debug("SYD_Connect_Ex方法接收参数:pcIpList:{},iPortList:{},iConnectTimeOut:{},iDealTimeOut:{}", Arrays.toString(pcIpList), Arrays.toString(iPortList), iConnectTimeOut, allDealTimeOut);
        }

        if (pcIpList.length!=iPortList.length) {
            throw new IllegalArgumentException("ip与端口数量不一致");
        }

        SydApi4j[] apis = new SydApi4j[pcIpList.length];
        int iDealTimeOut = allDealTimeOut / pcIpList.length;
        for (int i = 0; i < pcIpList.length ; i++) {

            try {

                apis[i] = (SydApi4j) new SydApi4j().connect(pcIpList[i], iPortList[i], null, iConnectTimeOut, iDealTimeOut);

            }catch ( Exception e) {
                // 忽略错误
                log.error("网络连接错误 {} {} - 忽略",pcIpList[i], iPortList[i]);
            }

        }

        hsms = apis;
        isShortLinkMode = true;
        return this;
    }

    @Override
    public void SYD_Disconnect_Ex() {
        if (isShortLinkMode) {
            if ( null == hsms ){
                return;
            }

            for (int i = 0; i < hsms.length; i++) {
                SydApi4j api = hsms[i];
                if (null != api) {
                    try {
                        api.disconnect();
                    } catch (Exception e) {

                    }
                }
            }
        }
        // 配合链接池，不再需要释放。
    }

    @Override
    public String SYD_SM3_Hash_ShortData(byte[] pcData) {
        Logger log = LogFactory.getLogger();
        if (LogFactory.iLogLevel==3) {
            log.debug("SYD_SM3_Hash_ShortData方法接收参数：pcData：{}", Arrays.toString(pcData));
        }
        if (null == this.hsms || this.hsms.length < 1) {
            throw new SydApiException(-1);
        }

        SydApiException le = null;
        for (SydApi4j api : this.hsms) {
            try {
                byte[] hash = api.SYD_SM3_LongData(pcData, null, 0);
                log.debug("api.SYD_SM3_LongData方法返回值：{}",Arrays.toString(hash));
                return Util.bytes2HexString(hash);
            } catch (SydApiException e) {
                le = e;
                if (e.getRetCode() < 0) {
                    continue;
                }
                throw e;
            }
        }
        throw le;
    }

    @Override
    public LongDataReturn<String, String> SYD_SM3_Hash_LongData(byte[] pcData, int iPkgNum, String pcProcData) {
        Logger log = LogFactory.getLogger();
        if (LogFactory.iLogLevel==3) {
            log.debug("SYD_SM3_Hash_LongData方法接收参数：pcData：{},iPkgNum：{},pcProcData：{}", Arrays.toString(pcData), iPkgNum, pcProcData);
        }

        if (null == this.hsms || this.hsms.length < 1) {
            throw new SydApiException(-1);
        }

        byte[] procData = null;
        if (2 == iPkgNum || 3 == iPkgNum) {
            procData = Util.hexString2Bytes(pcProcData);
            log.debug("Util.hexString2Bytes方法返回值：{}",Arrays.toString(procData));

        }
        SydApiException le = null;
        for (SydApi4j api : this.hsms) {
            try {
                byte[] hash = api.SYD_SM3_LongData(pcData, procData, iPkgNum);
                log.debug("api.SYD_SM3_LongData方法返回值：{}",Arrays.toString(hash));
                if (0 == iPkgNum || 3 == iPkgNum) {
                    return new LongDataReturn<String, String>(null, Util.bytes2HexString(hash));
                } else {
                    return new LongDataReturn<String, String>(Util.bytes2HexString(hash), null);
                }
            } catch (SydApiException e) {
                le = e;
                if (e.getRetCode() < 0) {
                    continue;
                }
                throw e;
            }
        }
        throw le;
    }

    @Override
    public byte[] SYD_SM4_ShortData(int iKeyIndex, byte[] pcData, int iFlag) {
        Logger log = LogFactory.getLogger();
        if (LogFactory.iLogLevel==3) {
            log.debug("SYD_SM4_ShortData方法接收参数：iKeyIndex：{},pcData：{},iFlag：{}", iKeyIndex, Arrays.toString(pcData), iFlag);
        }
        if (iFlag==Consts.ECB_DEC && null==pcData||pcData.length==0){
            throw new SydApiException(19);
        }
        if (null == this.hsms || this.hsms.length < 1) {
            throw new SydApiException(-1);
        }

        String keyIndex = String.format("%08d", iKeyIndex);
        SydApiException le = null;
        for (SydApi4j api : this.hsms) {
            try {

                if (Consts.ECB_ENC == iFlag) {
                    return api.SYMEncryptData(
                            com.sunyard.SydApi.NALG_SM4,
                            "SK" + SYMUtil.genPrivateKeyMark("000000", "00A", keyIndex),
                            1,
                            pcData);
                } else {
                    return api.SYMDecryptData(
                            com.sunyard.SydApi.NALG_SM4,
                            "SK" + SYMUtil.genPrivateKeyMark("000000", "00A", keyIndex),
                            1,
                            pcData);
                }
            } catch (SydApiException e) {
                le = e;
                if (e.getRetCode() < 0) {
                    continue;
                }
                throw e;
            }
        }
        throw le;
    }

    @Override
    public List<byte[]> SYD_SM4_BatchData(int[] iKeyIndex, List<byte[]> pcData, int iFlag) {
        Logger log = LogFactory.getLogger();
        if (LogFactory.iLogLevel==3) {
            log.debug("SYD_SM4_BatchData方法接收参数：iKeyIndex：{},pcData元素个数为：{},iFlag：{}", iKeyIndex, pcData.size(), iFlag);
        }
        if (iFlag==Consts.ECB_DEC){
            for (byte[] pcdata:pcData){
                if (null==pcData||pcdata.length==0) {
                    throw new SydApiException(19);
                }
            }
        }
        if (null == this.hsms || this.hsms.length < 1) {
            throw new SydApiException(-1);
        }

        String[] keys = new String[iKeyIndex.length];
        for (int i = 0; i < iKeyIndex.length; i++) {
            keys[i] = "SK" + SYMUtil.genPrivateKeyMark("000000", "00A", String.format("%08d", iKeyIndex[i]));
        }

        SydApiException le = null;
        for (SydApi4j api : this.hsms) {
            try {
                if (Consts.ECB_ENC == iFlag) {
                    return api.SYMEncryptDecryptBatchData(8, 1, null, keys, 1, pcData);

                } else {
                    return api.SYMEncryptDecryptBatchData(9, 1, null, keys, 1, pcData);
                }
            } catch (SydApiException e) {
                le = e;
                if (e.getRetCode() < 0) {
                    continue;
                }
                throw e;
            }
        }
        throw le;
    }

    @Override
    public byte[] SYD_SM4_LongData(int iKeyIndex, byte[] pcData, int iPkgNum, int iFlag) {
        Logger log = LogFactory.getLogger();
        if (LogFactory.iLogLevel==3) {
            log.debug("SYD_SM4_LongData方法接收参数：iKeyIndex：{},pcData：{},iPkgNum：{},iFlag：{}", iKeyIndex, Arrays.toString(pcData), iPkgNum, iFlag);
        }
        if (iFlag==Consts.ECB_DEC&&null==pcData||pcData.length==0){
            throw new SydApiException(19);
        }
        if (null == this.hsms || this.hsms.length < 1) {
            throw new SydApiException(-1);
        }
        String keyIndex = String.format("%08d", iKeyIndex);

        SydApiException le = null;
        for (SydApi4j api : this.hsms) {
            try {
                if (Consts.ECB_ENC == iFlag) {
                    return api.SYD_SM4_LongData(
                            8,
                            1, null,
                            "SK" + SYMUtil.genPrivateKeyMark("000000", "00A", keyIndex),
                            1,
                            pcData, iPkgNum);
                } else {
                    return api.SYD_SM4_LongData(
                            9,
                            1, null,
                            "SK" + SYMUtil.genPrivateKeyMark("000000", "00A", keyIndex),
                            1,
                            pcData, iPkgNum);
                }

            } catch (SydApiException e) {
                le = e;
                if (e.getRetCode() < 0) {
                    continue;
                }
                throw e;
            }
        }
        throw le;
    }

    @Override
    public String[] SYD_SM4Mac_BatchData(int[] iKeyIndex, List<byte[]> pcData) {
        Logger log = LogFactory.getLogger();
        if (LogFactory.iLogLevel==3) {
            log.debug("SYD_SM4Mac_BatchData：iKeyIndex：{},pcData元素个数为：{}", iKeyIndex, pcData.size());
        }
        if (null == this.hsms || this.hsms.length < 1) {
            throw new SydApiException(-1);
        }

        String[] keys = new String[iKeyIndex.length];
        for (int i = 0; i < iKeyIndex.length; i++) {
            keys[i] = "SK" + SYMUtil.genPrivateKeyMark("000000", "00A", String.format("%08d", iKeyIndex[i]));
        }
        SydApiException le = null;
        for (SydApi4j api : this.hsms) {
            try {
                List<byte[]> list = api.SYMEncryptDecryptBatchData(8, 2, null, keys, 1, pcData);
                String[] ret = new String[list.size()];
                for (int i = 0; i < list.size(); i++) {
                    byte[] mac = new byte[16];
                    byte[] buff = list.get(i);
                    System.arraycopy(buff, buff.length - 16, mac, 0, 16);
                    ret[i] = Util.bytes2HexString(buff);
                }
                return ret;

            } catch (SydApiException e) {
                le = e;
                if (e.getRetCode() < 0) {
                    continue;
                }
                throw e;
            }
        }
        throw le;
    }

    @Override
    public boolean[] SYD_SM4Mac_BatchData(int[] iKeyIndex, List<byte[]> pcData, String[] pcMac) {
        Logger log = LogFactory.getLogger();
        if (LogFactory.iLogLevel==3) {
            log.debug("SYD_SM4Mac_BatchData方法接收参数：iKeyIndex：{},pcData元素个数为：{},pcMac：{}", iKeyIndex, pcData.size(), Arrays.toString(pcMac));
        }
        if (null == this.hsms || this.hsms.length < 1) {
            throw new SydApiException(-1);
        }

        String[] keys = new String[iKeyIndex.length];
        for (int i = 0; i < iKeyIndex.length; i++) {
            keys[i] = "SK" + SYMUtil.genPrivateKeyMark("000000", "00A", String.format("%08d", iKeyIndex[i]));
        }
        SydApiException le = null;
        for (SydApi4j api : this.hsms) {
            try {
                List<byte[]> list = api.SYMEncryptDecryptBatchData(8, 2, null, keys, 1, pcData);
                boolean[] ret = new boolean[list.size()];
                for (int i = 0; i < list.size(); i++) {
                    byte[] mac = new byte[16];
                    byte[] buff = list.get(i);
                    System.arraycopy(buff, buff.length - 16, mac, 0, 16);
                    ret[i] = pcMac[i].equals(Util.bytes2HexString(buff));
                }

                return ret;
            } catch (SydApiException e) {
                le = e;
                if (e.getRetCode() < 0) {
                    continue;
                }
                throw e;
            }
        }
        throw le;
    }

    @Override
    public LongDataReturn<String, String> SYD_SM4Mac_LongData(int iKeyIndex, byte[] pcData, int iPkgNum, String pcProcData) {
        Logger log = LogFactory.getLogger();
        if (LogFactory.iLogLevel==3) {
            log.debug("SYD_SM4Mac_LongData方法接收参数：iKeyIndex：{},pcData：{},iPkgNum：{},pcProcData：{}", iKeyIndex, Arrays.toString(pcData), iPkgNum, pcProcData);
        }
        if (null == this.hsms || this.hsms.length < 1) {
            throw new SydApiException(-1);
        }

        String keyIndex = String.format("%08d", iKeyIndex);

        byte[] iv = null;

        // 仅一包 和 第一包 忽略 pcProcData 参数
        if (Consts.PkgNumAll != iPkgNum && Consts.PkgNumHead != iPkgNum) {
            iv = pcProcData.getBytes();
        }

        SydApiException le = null;
        for (SydApi4j api : this.hsms) {
            try {
                byte[] ret = api.SYD_SM4_LongData(
                        8,
                        2, iv,
                        "SK" + SYMUtil.genPrivateKeyMark("000000", "00A", keyIndex),
                        1,
                        pcData, iPkgNum);

                byte[] mac = new byte[16];
                System.arraycopy(ret, ret.length - 16, mac, 0, 16);

                // 仅一包 和 尾包 返回最终结果
                if (Consts.PkgNumAll == iPkgNum || Consts.PkgNumTail == iPkgNum) {
                    return new LongDataReturn<>(null, Util.bytes2HexString(mac));
                } else {
                    // 返回中间值
                    return new LongDataReturn<>(Util.bytes2HexString(mac), null);
                }

            } catch (SydApiException e) {
                le = e;
                if (e.getRetCode() < 0) {
                    continue;
                }
                throw e;
            }
        }
        throw le;
    }

    @Override
    public LongDataReturn<String, Boolean> SYD_SM4Mac_LongData(int iKeyIndex, byte[] pcData, int iPkgNum, String pcProcData, String pcMac) {
        Logger log = LogFactory.getLogger();
        if (LogFactory.iLogLevel==3) {
            log.debug("SYD_SM4Mac_LongData方法接收参数：iKeyIndex：{},pcData：{},iPkgNum：{},pcProcData：{}", iKeyIndex, Arrays.toString(pcData), iPkgNum, pcProcData, pcMac);
        }
        LongDataReturn<String, String> ret = SYD_SM4Mac_LongData(iKeyIndex, pcData, iPkgNum, pcProcData);

        // 仅一包 和 尾包 返回最终结果
        if (Consts.PkgNumAll == iPkgNum || Consts.PkgNumTail == iPkgNum) {
            return new LongDataReturn<>(null, pcMac.equals(ret.getData()));
        } else {
            // 返回中间值
            return new LongDataReturn<>(ret.getProcData(), false);
        }
    }

    @Override
    public String SYD_SM4Mac_ShortData(int iKeyIndex, byte[] pcData) {
        Logger log = LogFactory.getLogger();
        if (LogFactory.iLogLevel==3) {
            log.debug("SYD_SM4Mac_ShortData方法接收参数：iKeyIndex：{},pcData：{},iFlag：{}", iKeyIndex, Arrays.toString(pcData));
        }
        if (null == this.hsms || this.hsms.length < 1) {
            throw new SydApiException(-1);
        }

        String keyIndex = "SK" + SYMUtil.genPrivateKeyMark("000000", "00A", String.format("%08d", iKeyIndex));
        log.debug("\"SK\" + SYMUtil.genPrivateKeyMark方法返回值：{}",keyIndex);
        SydApiException le = null;
        for (SydApi4j api : this.hsms) {
            try {

                return api.SYD_SM4Mac_ShortData(keyIndex, pcData);

            } catch (SydApiException e) {
                le = e;
                if (e.getRetCode() < 0) {
                    continue;
                }
                throw e;
            }
        }
        throw le;
    }

    @Override
    public boolean SYD_SM4Mac_ShortData(int iKeyIndex, byte[] pcData, String pcMac) {
        Logger log = LogFactory.getLogger();
        if (LogFactory.iLogLevel==3) {
            log.debug("SYD_SM4Mac_ShortData方法接收参数：{}", iKeyIndex, Arrays.toString(pcData), pcMac);
        }
        if (null == this.hsms || this.hsms.length < 1) {
            throw new SydApiException(-1);
        }

        if (null == pcMac) {
            throw new IllegalArgumentException();
        }

        String mac = this.SYD_SM4Mac_ShortData(iKeyIndex, pcData);
        log.debug(this+".SYD_SM4Mac_ShortData方法返回值：{}",mac);
        return pcMac.equals(mac);
    }
}