package tv.danmaku.ijk.media.player;

import androidx.media3.common.C;
import ea.a;
import fa.o;
import java.io.File;
import java.io.IOException;
import java.io.RandomAccessFile;
import java.nio.charset.StandardCharsets;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.util.Arrays;
import java.util.Objects;
import tv.danmaku.ijk.media.player.misc.IMediaDataSource;

/* JADX INFO: loaded from: classes3.dex */
public class RandomMediaDataSource implements IMediaDataSource {
    private static final int CHUNK_SIZE = 1048576;
    private static final int MODE_CURRENT = 0;
    private static final int MODE_LEGACY = 1;
    private static final int MODE_UNKNOWN = -1;
    private RandomAccessFile accessFile;
    private o currentCipher;
    private byte[] currentDecryptedData;
    private byte[] currentNonce;
    private o legacyCipher;
    private byte[] legacyNonce;
    private byte[] nextDecryptedData;
    private int mode = -1;
    private int lastChunkIndex = -1;

    public RandomMediaDataSource(File file, String str) {
        try {
            a.a();
            this.accessFile = new RandomAccessFile(file, "r");
            String strMd5 = md5(str);
            Objects.requireNonNull(strMd5);
            byte[] bytes = strMd5.getBytes(StandardCharsets.UTF_8);
            this.currentNonce = Arrays.copyOfRange(bytes, 0, 24);
            this.currentCipher = new o(Arrays.copyOfRange(bytes, 0, 32), 0, 2);
            byte[] bArrMd5Bytes = md5Bytes(str);
            byte[] bArr = new byte[32];
            System.arraycopy(bArrMd5Bytes, 0, bArr, 0, 16);
            System.arraycopy(bArrMd5Bytes, 0, bArr, 16, 16);
            this.legacyNonce = Arrays.copyOfRange(bArr, 0, 24);
            this.legacyCipher = new o(bArr, 0, 2);
        } catch (Exception e10) {
            e10.toString();
            e10.printStackTrace();
        }
    }

    private byte[] decryptChunk(byte[] bArr, boolean z10) throws Exception {
        int i10 = this.mode;
        if (i10 == 0) {
            return this.currentCipher.c(this.currentNonce, bArr);
        }
        if (i10 == 1) {
            return this.legacyCipher.c(this.legacyNonce, bArr);
        }
        byte[] bArrC = this.currentCipher.c(this.currentNonce, bArr);
        if (z10 && looksLikeMedia(bArrC)) {
            this.mode = 0;
            return bArrC;
        }
        byte[] bArrC2 = this.legacyCipher.c(this.legacyNonce, bArr);
        if (z10 && looksLikeMedia(bArrC2)) {
            this.mode = 1;
            return bArrC2;
        }
        this.mode = 0;
        return bArrC;
    }

    private int detectMode(byte[] bArr, byte[] bArr2) {
        return scoreMode(bArr, bArr2, 1) > scoreMode(bArr, bArr2, 0) ? 1 : 0;
    }

    private byte[] getDecryptedChunk(int i10, long j10) throws Exception {
        byte[] bArr;
        byte[] bArr2;
        int i11 = this.lastChunkIndex;
        if (i10 == i11 && (bArr2 = this.currentDecryptedData) != null) {
            return bArr2;
        }
        if (i10 == i11 + 1 && (bArr = this.nextDecryptedData) != null) {
            this.lastChunkIndex = i10;
            this.currentDecryptedData = bArr;
            this.nextDecryptedData = null;
            return bArr;
        }
        byte[] bArrLoadEncryptedChunk = loadEncryptedChunk(i10, j10);
        if (bArrLoadEncryptedChunk == null) {
            return null;
        }
        if (this.mode == -1 && i10 == 0) {
            this.mode = detectMode(bArrLoadEncryptedChunk, loadEncryptedChunk(1, j10));
        }
        this.currentDecryptedData = decryptChunk(bArrLoadEncryptedChunk, i10 == 0);
        this.lastChunkIndex = i10;
        byte[] bArrLoadEncryptedChunk2 = loadEncryptedChunk(i10 + 1, j10);
        this.nextDecryptedData = bArrLoadEncryptedChunk2 != null ? decryptChunk(bArrLoadEncryptedChunk2, false) : null;
        return this.currentDecryptedData;
    }

    private byte[] loadEncryptedChunk(int i10, long j10) throws IOException {
        long j11 = ((long) i10) * 1048576;
        if (j11 >= j10) {
            return null;
        }
        int iMin = (int) Math.min(1048576L, j10 - j11);
        byte[] bArr = new byte[iMin];
        if (readFullyAt(j11, bArr, iMin)) {
            return bArr;
        }
        return null;
    }

    private boolean looksLikeMedia(byte[] bArr) {
        if (bArr == null || bArr.length < 12) {
            return false;
        }
        if (bArr[4] == 102 && bArr[5] == 116 && bArr[6] == 121 && bArr[7] == 112) {
            return true;
        }
        return (bArr[0] & 255) == 26 && (bArr[1] & 255) == 69 && (bArr[2] & 255) == 223 && (bArr[3] & 255) == 163;
    }

    public static String md5(String str) {
        try {
            byte[] bArrDigest = MessageDigest.getInstance("MD5").digest(str.getBytes());
            StringBuilder sb = new StringBuilder();
            for (byte b10 : bArrDigest) {
                sb.append(String.format("%02x", Integer.valueOf(b10 & 255)));
            }
            return sb.toString();
        } catch (NoSuchAlgorithmException e10) {
            e10.printStackTrace();
            return "";
        }
    }

    private static byte[] md5Bytes(String str) throws NoSuchAlgorithmException {
        return MessageDigest.getInstance("MD5").digest(str.getBytes(StandardCharsets.UTF_8));
    }

    private int mediaScore(byte[] bArr, boolean z10) {
        int i10;
        if (bArr == null || bArr.length < 16) {
            return 0;
        }
        if (z10) {
            byte b10 = bArr[0];
            byte b11 = bArr[1];
            byte b12 = bArr[2];
            byte b13 = bArr[3];
            int i11 = ((b11 & 255) << 16) | ((b10 & 255) << 24) | ((b12 & 255) << 8) | (b13 & 255);
            i10 = (bArr[4] == 102 && bArr[5] == 116 && bArr[6] == 121 && bArr[7] == 112 && i11 >= 8 && i11 < 4096) ? 8 : 0;
            if ((b10 & 255) == 26 && (b11 & 255) == 69 && (b12 & 255) == 223 && (b13 & 255) == 163) {
                i10 += 8;
            }
        } else {
            i10 = 0;
        }
        byte[][] bArr2 = {new byte[]{109, 111, 111, 118}, new byte[]{109, 100, 97, 116}, new byte[]{116, 114, 97, 107}, new byte[]{109, 100, 105, 97}, new byte[]{115, 116, 98, 108}, new byte[]{115, 116, 115, 100}, new byte[]{115, 116, 99, 111}, new byte[]{99, 111, 54, 52}, new byte[]{102, 114, 101, 101}, new byte[]{115, 107, 105, 112}, new byte[]{117, 100, 116, 97}};
        int iMin = Math.min(bArr.length - 4, C.DEFAULT_BUFFER_SEGMENT_SIZE);
        for (int i12 = 0; i12 < 11; i12++) {
            byte[] bArr3 = bArr2[i12];
            int i13 = 0;
            while (true) {
                if (i13 >= iMin) {
                    break;
                }
                if (bArr[i13] == bArr3[0] && bArr[i13 + 1] == bArr3[1] && bArr[i13 + 2] == bArr3[2]) {
                    if (bArr[i13 + 3] == bArr3[3]) {
                        i10++;
                        break;
                    }
                }
                i13++;
            }
        }
        return i10;
    }

    private boolean readFullyAt(long j10, byte[] bArr, int i10) throws IOException {
        this.accessFile.seek(j10);
        int i11 = 0;
        while (i11 < i10) {
            int i12 = this.accessFile.read(bArr, i11, i10 - i11);
            if (i12 <= 0) {
                return false;
            }
            i11 += i12;
        }
        return true;
    }

    private int scoreMode(byte[] bArr, byte[] bArr2, int i10) {
        int iMediaScore;
        try {
            iMediaScore = mediaScore(i10 == 0 ? this.currentCipher.c(this.currentNonce, bArr) : this.legacyCipher.c(this.legacyNonce, bArr), true);
        } catch (Exception unused) {
            iMediaScore = 0;
        }
        if (bArr2 == null) {
            return iMediaScore;
        }
        try {
            return iMediaScore + mediaScore(i10 == 0 ? this.currentCipher.c(this.currentNonce, bArr2) : this.legacyCipher.c(this.legacyNonce, bArr2), false);
        } catch (Exception unused2) {
            return iMediaScore;
        }
    }

    @Override // tv.danmaku.ijk.media.player.misc.IMediaDataSource
    public void close() throws IOException {
        this.accessFile.close();
    }

    @Override // tv.danmaku.ijk.media.player.misc.IMediaDataSource
    public long getSize() throws IOException {
        return this.accessFile.length();
    }

    @Override // tv.danmaku.ijk.media.player.misc.IMediaDataSource
    public int readAt(long j10, byte[] bArr, int i10, int i11) {
        int i12 = 0;
        if (i11 == 0) {
            return 0;
        }
        try {
            RandomAccessFile randomAccessFile = this.accessFile;
            if (randomAccessFile != null && bArr != null && i10 >= 0 && i11 >= 0 && i10 + i11 <= bArr.length) {
                long length = randomAccessFile.length();
                if (j10 >= 0 && j10 < length) {
                    int iMin = (int) Math.min(i11, length - j10);
                    while (i12 < iMin) {
                        int i13 = (int) (j10 % 1048576);
                        byte[] decryptedChunk = getDecryptedChunk((int) (j10 / 1048576), length);
                        if (decryptedChunk == null || i13 >= decryptedChunk.length) {
                            break;
                        }
                        int iMin2 = Math.min(iMin - i12, decryptedChunk.length - i13);
                        System.arraycopy(decryptedChunk, i13, bArr, i10 + i12, iMin2);
                        i12 += iMin2;
                        j10 += (long) iMin2;
                    }
                    if (i12 > 0) {
                        return i12;
                    }
                    return -1;
                }
                return -1;
            }
            return -1;
        } catch (Exception e10) {
            e10.toString();
            return -1;
        }
    }
}