package com.seewo.libnfc.mifare.classic;

import android.nfc.Tag;
import android.nfc.tech.MifareClassic;
import android.util.Log;
import com.seewo.libnfc.cipher.AESTool;
import com.seewo.libnfc.customer.NfcData;
import com.seewo.libnfc.mifare.MifareCallback;
import com.seewo.libnfc.mifare.MifareHelper;
import java.io.IOException;

/* JADX INFO: loaded from: classes.dex */
public class MifareClassicHelper implements MifareHelper {
    private static final int DEFAULT_BLOCK_LENGTH = 16;
    private static final String LOG_TAG = "MifareClassicHelper";
    private static final String TAG = "MifareClassicHelper";
    private final MifareClassic mMFC;
    private MifareCallback mMifareClassicCallback;
    private byte[] mKey = {-14, -1, -1, -1, -1, -1, -1, 7, -128, 105, -14, -1, -1, -1, -1, -1};
    private byte[] mComplementValus = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};

    public MifareClassicHelper(Tag tag) {
        this.mMFC = MifareClassic.get(tag);
    }

    @Override // com.seewo.libnfc.mifare.MifareHelper
    public void setResultCallback(MifareCallback mifareCallback) {
        this.mMifareClassicCallback = mifareCallback;
    }

    /* JADX INFO: Access modifiers changed from: private */
    public void onWriteResult(boolean z) {
        MifareCallback mifareCallback = this.mMifareClassicCallback;
        if (mifareCallback != null) {
            mifareCallback.onWrite(z);
        }
    }

    public boolean isMifareClassic() {
        return this.mMFC != null;
    }

    public int getSize() {
        return this.mMFC.getSize();
    }

    public int getSectorCount() {
        return this.mMFC.getSectorCount();
    }

    public int getBlockCount() {
        return this.mMFC.getBlockCount();
    }

    public int getBlockCountInSector(int i) {
        return this.mMFC.getBlockCountInSector(i);
    }

    public boolean isConnected() {
        return this.mMFC.isConnected();
    }

    public void connect() throws IOException {
        try {
            MifareClassic mifareClassic = this.mMFC;
            if (mifareClassic == null) {
                return;
            }
            mifareClassic.connect();
        } catch (IOException e) {
            Log.d(LOG_TAG, "Error while connecting to tag.ex:" + e.getMessage());
            throw e;
        }
    }

    public void close() {
        try {
            this.mMFC.close();
        } catch (IOException e) {
            Log.e(LOG_TAG, "Error on closing tag." + e);
        }
    }

    private boolean authenticate(int i, byte[] bArr, boolean z) {
        try {
            if (!z) {
                if (this.mMFC.authenticateSectorWithKeyA(i, MifareClassic.KEY_DEFAULT)) {
                    return true;
                }
                return this.mMFC.authenticateSectorWithKeyA(i, bArr);
            }
            if (this.mMFC.authenticateSectorWithKeyB(i, MifareClassic.KEY_DEFAULT)) {
                return true;
            }
            return this.mMFC.authenticateSectorWithKeyB(i, bArr);
        } catch (IOException e) {
            Log.e(LOG_TAG, "Error authenticating with tag.\n" + e);
            return false;
        }
    }

    @Override // com.seewo.libnfc.mifare.MifareHelper
    public byte[] readBlock(int i, int i2, byte[] bArr, boolean z) {
        if (this.mMFC.getSectorCount() - 1 < i) {
            return new byte[0];
        }
        if (this.mMFC.getBlockCountInSector(i) - 1 < i2) {
            return new byte[0];
        }
        if (!authenticate(i, bArr, z)) {
            return new byte[0];
        }
        try {
            return this.mMFC.readBlock(this.mMFC.sectorToBlock(i) + i2);
        } catch (IOException e) {
            Log.e(LOG_TAG, "Error readBlock\n" + e);
            return new byte[0];
        }
    }

    @Override // com.seewo.libnfc.mifare.MifareHelper
    public void readData() {
        new Thread(new Runnable() { // from class: com.seewo.libnfc.mifare.classic.MifareClassicHelper.1
            @Override // java.lang.Runnable
            public void run() {
                synchronized (MifareClassicHelper.this.mMFC) {
                    try {
                        if (!MifareClassicHelper.this.checkConnect()) {
                        } else {
                            MifareClassicHelper.this.readUserData();
                        }
                    } catch (Exception e) {
                        Log.w(MifareClassicHelper.TAG, e.getMessage(), e);
                        if (MifareClassicHelper.this.mMifareClassicCallback != null) {
                            MifareClassicHelper.this.mMifareClassicCallback.onDataRead(null);
                        }
                    }
                }
            }
        }).start();
    }

    /* JADX INFO: Access modifiers changed from: private */
    public void readUserData() {
        NfcData nfcData = new NfcData();
        int i = 1;
        byte[] block = readBlock(0, 1, AESTool.PROWISE_KEY_HEAD, false);
        if (block == null) {
            MifareCallback mifareCallback = this.mMifareClassicCallback;
            if (mifareCallback != null) {
                mifareCallback.onDataRead(null);
                return;
            }
            return;
        }
        int i2 = block[0] & 255;
        byte b = block.length >= 2 ? block[1] : (byte) 0;
        int i3 = i2 / 16;
        if (i2 % 16 != 0) {
            i3++;
        }
        byte[] bArr = new byte[i2];
        int i4 = 0;
        int i5 = 0;
        while (i3 > 0) {
            if (i4 >= 3) {
                i++;
                i4 = 0;
            } else {
                byte[] block2 = readBlock(i, i4, AESTool.PROWISE_KEY_HEAD, false);
                if (block2 != null) {
                    System.arraycopy(block2, 0, bArr, i5 * 16, 16);
                }
                i3--;
                i4++;
                i5++;
            }
        }
        if (b < NfcData.Customers.values().length) {
            nfcData.setCustomer(NfcData.Customers.values()[b]);
        } else {
            nfcData.setCustomer(NfcData.Customers.OTHERS);
        }
        nfcData.setmRawData(bArr);
        close();
        MifareCallback mifareCallback2 = this.mMifareClassicCallback;
        if (mifareCallback2 != null) {
            mifareCallback2.onDataRead(nfcData);
        }
    }

    public boolean writeBlock(int i, int i2, byte[] bArr, byte[] bArr2, boolean z) {
        if (this.mMFC.getSectorCount() - 1 < i || this.mMFC.getBlockCountInSector(i) - 1 < i2 || bArr.length != 16 || !authenticate(i, bArr2, z)) {
            return false;
        }
        try {
            this.mMFC.writeBlock(this.mMFC.sectorToBlock(i) + i2, bArr);
            return true;
        } catch (IOException e) {
            Log.e(LOG_TAG, "catch a exception when writeBlock\n" + e);
            return false;
        }
    }

    @Override // com.seewo.libnfc.mifare.MifareHelper
    public void writeData(final byte[] bArr, final NfcData.Customers customers) {
        if (bArr == null) {
            return;
        }
        new Thread(new Runnable() { // from class: com.seewo.libnfc.mifare.classic.MifareClassicHelper.2
            @Override // java.lang.Runnable
            public void run() {
                synchronized (MifareClassicHelper.this.mMFC) {
                    try {
                    } catch (Exception e) {
                        Log.w(MifareClassicHelper.TAG, e.getMessage(), e);
                        MifareClassicHelper.this.onWriteResult(false);
                    }
                    if (!MifareClassicHelper.this.checkConnect()) {
                        MifareClassicHelper.this.onWriteResult(false);
                        return;
                    }
                    if (!MifareClassicHelper.this.writeConfigData(bArr, customers)) {
                        MifareClassicHelper.this.onWriteResult(false);
                        return;
                    }
                    if (!MifareClassicHelper.this.writeUserData(bArr)) {
                        MifareClassicHelper.this.onWriteResult(false);
                    } else if (!MifareClassicHelper.this.writeAllKey()) {
                        MifareClassicHelper.this.onWriteResult(false);
                    } else {
                        MifareClassicHelper.this.close();
                        MifareClassicHelper.this.onWriteResult(true);
                    }
                }
            }
        }).start();
    }

    /* JADX INFO: Access modifiers changed from: private */
    public boolean writeUserData(byte[] bArr) {
        byte[] bArr2 = this.mComplementValus;
        int length = bArr.length / 16;
        if (bArr.length % 16 != 0) {
            length++;
        }
        int i = length;
        int i2 = 0;
        int i3 = 0;
        int i4 = 1;
        while (i > 0) {
            if (i2 >= 3) {
                i4++;
                i2 = 0;
            } else {
                System.arraycopy(bArr, i3 * 16, bArr2, 0, 16);
                if (!writeBlock(i4, i2, bArr2, AESTool.PROWISE_KEY_HEAD, false)) {
                    return false;
                }
                i--;
                i2++;
                i3++;
            }
        }
        return true;
    }

    /* JADX INFO: Access modifiers changed from: private */
    public boolean checkConnect() {
        try {
            if (isConnected()) {
                return true;
            }
            connect();
            return true;
        } catch (Exception e) {
            Log.e(LOG_TAG, "catch a exception on a new Thread exec connect\n" + e);
            return false;
        }
    }

    /* JADX INFO: Access modifiers changed from: private */
    public boolean writeConfigData(byte[] bArr, NfcData.Customers customers) {
        byte[] bArr2 = this.mComplementValus;
        bArr2[0] = (byte) bArr.length;
        bArr2[1] = (byte) customers.ordinal();
        return writeBlock(0, 1, bArr2, AESTool.PROWISE_KEY_HEAD, false);
    }

    /* JADX INFO: Access modifiers changed from: private */
    public boolean writeAllKey() {
        for (int i = 0; i < this.mMFC.getSectorCount(); i++) {
            if (!writeBlock(i, 3, this.mKey, AESTool.PROWISE_KEY_HEAD, false)) {
                return false;
            }
        }
        return true;
    }
}