package com.kofax.kmc.kui.uicontrols;

import android.content.Context;
import android.content.res.TypedArray;
import android.graphics.Bitmap;
import android.graphics.Canvas;
import android.graphics.Color;
import android.graphics.DashPathEffect;
import android.graphics.Paint;
import android.graphics.Path;
import android.graphics.Point;
import android.graphics.Rect;
import android.os.Bundle;
import android.os.Parcelable;
import android.util.AttributeSet;
import android.view.MotionEvent;
import android.view.ScaleGestureDetector;
import android.view.View;
import android.view.WindowManager;
import com.google.android.gms.maps.model.BitmapDescriptorFactory;
import com.kofax.BuildConfig;
import com.kofax.R;
import com.kofax.kmc.ken.engines.data.BoundingRect;
import com.kofax.kmc.ken.engines.data.BoundingTetragon;
import com.kofax.kmc.ken.engines.data.Image;
import com.kofax.kmc.kui.uicontrols.data.ImageCacheType;
import com.kofax.kmc.kut.utilities.Licensing;
import com.kofax.kmc.kut.utilities.error.ErrorInfo;
import com.kofax.kmc.kut.utilities.error.IllegalArgumentException;
import com.kofax.kmc.kut.utilities.error.KmcException;
import com.kofax.kmc.kut.utilities.error.KmcRuntimeException;
import com.kofax.mobile.sdk._internal.c;
import com.kofax.mobile.sdk._internal.dagger.Injector;
import com.kofax.mobile.sdk._internal.k;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Iterator;
import java.util.List;
import java.util.UUID;

/* loaded from: classes3.dex */
public class ImgReviewEditCntrl extends View implements View.OnTouchListener {
    private static final String TAG = "ImgReviewEditCntrl";
    private static final float kT = 25.0f;
    private static final int kU = 35;
    private Image image;
    private int kV;
    private int kW;
    private Point kX;
    private Point kY;
    private Point kZ;
    private Point lA;
    private Point lB;
    private int lC;
    private int lD;
    private int lE;
    private Line_Style_Solid lF;
    private BoundingTetragon lG;
    private String lH;
    private boolean lI;
    private c lJ;
    private ImageCacheType lK;
    private final List<BoundingRect> lL;
    private final Rect lM;
    private boolean lN;
    private float lO;
    private Point la;
    private int lb;
    private Paint lc;
    private Paint ld;
    private boolean le;
    private boolean lf;
    private int lg;
    private boolean lh;
    boolean li;
    private float lj;
    private float lk;
    private float ll;
    private float lm;
    private float ln;
    private float lo;
    private Point lp;
    private Point lq;
    private Point lr;
    private Point ls;
    private boolean lt;
    private float lu;
    private float lv;
    private Bitmap lw;
    private Point lx;
    private Point ly;
    private Rect lz;
    private int rotation;
    public ScaleGestureDetector scaleGestureDetector;
    private int state;

    /* loaded from: classes3.dex */
    public enum Line_Style_Solid {
        LINE_STYLE_SOLID,
        LINE_STYLE_DOTTED
    }

    public void setImage(Image image) throws KmcException {
        az();
        this.image = image;
        if (image != null) {
            this.lO = image.getImageBitmapScaling().floatValue();
            this.image.getImageRepresentation();
            if (this.image.getImageRepresentation().equals(Image.ImageRep.IMAGE_REP_BITMAP) || this.image.getImageRepresentation().equals(Image.ImageRep.IMAGE_REP_BOTH)) {
                if (this.image.getImageBitmapScaling().floatValue() == 1.0f) {
                    String str = TAG;
                    StringBuilder sb = new StringBuilder("[Bitmap]bm.getHeight() = ");
                    sb.append(this.image.getImageBitmapHeight());
                    k.e(str, sb.toString());
                    StringBuilder sb2 = new StringBuilder("[Bitmap]bm.getWidth() = ");
                    sb2.append(this.image.getImageBitmapWidth());
                    k.e(str, sb2.toString());
                    this.lO = 0.5f;
                    this.lw = this.image.createScaledBitmap(0.5f);
                }
                if (this.lw != null) {
                    av();
                    invalidate();
                    return;
                }
                return;
            }
            if (this.image.getImageRepresentation().equals(Image.ImageRep.IMAGE_REP_FILE)) {
                try {
                    if (this.image.getImageBitmapScaling().floatValue() == 1.0f) {
                        this.lO = 0.5f;
                    }
                    if (this.image.getImageFileRep() == Image.ImageFileRep.FILE_STORED) {
                        Integer imageDPI = this.image.getImageDPI();
                        String imageMetaData = this.image.getImageMetaData();
                        Image.FriendI friendI = new Image.FriendI(this.image, BuildConfig.APPLICATION_ID);
                        this.image.imageReadFromFile(this.lO);
                        friendI.setImageMetaData(imageMetaData);
                        if (imageDPI != null) {
                            this.image.setImageDPI(imageDPI.intValue());
                        }
                    } else {
                        this.image.imageReadFromFileBuffer(this.lO);
                    }
                    Bitmap bitmap = this.lw;
                    if (bitmap != null) {
                        bitmap.recycle();
                        this.lw = null;
                    }
                    Bitmap v = v(this.image);
                    this.lw = v;
                    if (v != null) {
                        this.image.imageClearBitmap();
                        k.c(TAG, "--------------image.imageClearBitmap()");
                    }
                    if (this.lw != null) {
                        av();
                        invalidate();
                        return;
                    }
                    return;
                } catch (KmcException unused) {
                    throw new KmcException(ErrorInfo.KMC_UI_SCALING_FACTOR);
                }
            }
            return;
        }
        throw new KmcException(ErrorInfo.KMC_UI_IMAGE_NULL);
    }

    private Bitmap v(Image image) {
        Bitmap imageBitmap = image.getImageBitmap();
        int width = imageBitmap.getWidth();
        int height = imageBitmap.getHeight();
        Bitmap createBitmap = Bitmap.createBitmap(width, height, Bitmap.Config.ARGB_8888);
        int[] iArr = new int[width * height];
        imageBitmap.getPixels(iArr, 0, width, 0, 0, width, height);
        createBitmap.setPixels(iArr, 0, width, 0, 0, width, height);
        return createBitmap;
    }

    private void av() {
        this.lk = this.lw.getHeight();
        this.lj = this.lw.getWidth();
        String str = TAG;
        StringBuilder sb = new StringBuilder("image Wd&ht = ");
        sb.append(this.lj);
        sb.append(" ");
        sb.append(this.lk);
        k.c(str, sb.toString());
        float height = getHeight();
        float width = getWidth();
        StringBuilder sb2 = new StringBuilder("displayHt ");
        sb2.append(height);
        sb2.append("  displayWd = ");
        sb2.append(width);
        k.c("InitImage", sb2.toString());
        Point d = d(new Point((int) width, (int) height), new Point((int) this.lj, (int) this.lk));
        this.ll = (width - d.x) / 2.0f;
        this.lm = (height - d.y) / 2.0f;
        this.ln = this.lj / d.x;
        this.lz = a(this.lj, this.lk, d.x, d.y);
        this.state = 0;
        this.ly.x = 0;
        this.ly.y = 0;
        this.lu = 1.0f;
        this.lv = 1.0f;
        this.le = false;
        this.lo = getDisplayToBitmapScalingFactor();
    }

    public void showCropRectangle(boolean z) {
        this.lt = z;
        invalidate();
    }

    public void setCropLineColor(int i) {
        this.lC = i;
        invalidate();
    }

    public void setCropCornerColor(int i) {
        this.lD = i;
        invalidate();
    }

    public void setCropLineStyle(Line_Style_Solid line_Style_Solid) {
        this.lF = line_Style_Solid;
        invalidate();
    }

    public void setCropTetragon(BoundingTetragon boundingTetragon) {
        this.lG = boundingTetragon;
        if (boundingTetragon != null) {
            String str = TAG;
            StringBuilder sb = new StringBuilder("setCropTetragon[scale value = ]");
            sb.append(this.lO);
            k.c(str, sb.toString());
            this.ls.x = (int) (this.lG.getTopLeft().x * this.lO);
            this.ls.y = (int) (this.lG.getTopLeft().y * this.lO);
            this.lr.x = (int) (this.lG.getTopRight().x * this.lO);
            this.lr.y = (int) (this.lG.getTopRight().y * this.lO);
            this.lq.x = (int) (this.lG.getBottomLeft().x * this.lO);
            this.lq.y = (int) (this.lG.getBottomLeft().y * this.lO);
            this.lp.x = (int) (this.lG.getBottomRight().x * this.lO);
            this.lp.y = (int) (this.lG.getBottomRight().y * this.lO);
            this.lN = true;
        }
        invalidate();
    }

    public void showHighlights(BoundingRect[] boundingRectArr) {
        clearHighlights();
        if (boundingRectArr != null) {
            Collections.addAll(this.lL, boundingRectArr);
        }
    }

    public void clearHighlights() {
        this.lL.clear();
    }

    public void setHighlightColor(int i) {
        this.lE = i;
        invalidate();
    }

    public BoundingTetragon getCropTetragon() {
        if (this.lG == null) {
            this.lG = new BoundingTetragon();
        }
        try {
            this.lG.setTopLeft(new Point((int) (this.ls.x / this.lO), (int) (this.ls.y / this.lO)));
            this.lG.setTopRight(new Point((int) (this.lr.x / this.lO), (int) (this.lr.y / this.lO)));
            this.lG.setBottomLeft(new Point((int) (this.lq.x / this.lO), (int) (this.lq.y / this.lO)));
            this.lG.setBottomRight(new Point((int) (this.lp.x / this.lO), (int) (this.lp.y / this.lO)));
        } catch (NullPointerException unused) {
        }
        return this.lG;
    }

    /* JADX INFO: Access modifiers changed from: package-private */
    /* renamed from: com.kofax.kmc.kui.uicontrols.ImgReviewEditCntrl$1, reason: invalid class name */
    /* loaded from: classes3.dex */
    public static /* synthetic */ class AnonymousClass1 {
        static final int[] lP;

        static {
            int[] iArr = new int[ImageCacheType.values().length];
            lP = iArr;
            try {
                iArr[ImageCacheType.MEMORY.ordinal()] = 1;
            } catch (NoSuchFieldError unused) {
            }
            try {
                lP[ImageCacheType.DISK.ordinal()] = 2;
            } catch (NoSuchFieldError unused2) {
            }
        }
    }

    public void setImageCacheType(ImageCacheType imageCacheType) {
        int i = AnonymousClass1.lP[imageCacheType.ordinal()];
        if (i == 1) {
            this.lJ = Injector.getInjector(getContext()).getMemoryBitmapCache();
        } else if (i == 2) {
            this.lJ = Injector.getInjector(getContext()).getDiskBitmapCache();
        } else {
            throw new IllegalArgumentException("Invalid ImageCacheType ".concat(String.valueOf(imageCacheType)));
        }
        this.lK = imageCacheType;
    }

    public ImgReviewEditCntrl(Context context) {
        super(context);
        this.kV = 0;
        this.kX = new Point();
        this.kY = new Point();
        this.le = false;
        this.lf = true;
        this.lg = -1;
        this.state = 0;
        this.lh = false;
        this.li = false;
        this.lo = 1.0f;
        this.lu = BitmapDescriptorFactory.HUE_RED;
        this.lv = 1.0f;
        this.lx = new Point();
        this.ly = new Point();
        this.lA = new Point(0, 0);
        this.lC = -16776961;
        this.lD = -16776961;
        this.lE = -256;
        this.lI = true;
        this.lK = ImageCacheType.MEMORY;
        this.lL = new ArrayList();
        this.lM = new Rect();
        this.lN = false;
        b(context);
        setImageCacheType(this.lK);
    }

    public ImgReviewEditCntrl(Context context, AttributeSet attributeSet) {
        super(context, attributeSet);
        this.kV = 0;
        this.kX = new Point();
        this.kY = new Point();
        this.le = false;
        this.lf = true;
        this.lg = -1;
        this.state = 0;
        this.lh = false;
        this.li = false;
        this.lo = 1.0f;
        this.lu = BitmapDescriptorFactory.HUE_RED;
        this.lv = 1.0f;
        this.lx = new Point();
        this.ly = new Point();
        this.lA = new Point(0, 0);
        this.lC = -16776961;
        this.lD = -16776961;
        this.lE = -256;
        this.lI = true;
        this.lK = ImageCacheType.MEMORY;
        this.lL = new ArrayList();
        this.lM = new Rect();
        this.lN = false;
        b(context);
        a(context, attributeSet);
        setImageCacheType(this.lK);
    }

    public ImgReviewEditCntrl(Context context, AttributeSet attributeSet, int i) {
        super(context, attributeSet, i);
        this.kV = 0;
        this.kX = new Point();
        this.kY = new Point();
        this.le = false;
        this.lf = true;
        this.lg = -1;
        this.state = 0;
        this.lh = false;
        this.li = false;
        this.lo = 1.0f;
        this.lu = BitmapDescriptorFactory.HUE_RED;
        this.lv = 1.0f;
        this.lx = new Point();
        this.ly = new Point();
        this.lA = new Point(0, 0);
        this.lC = -16776961;
        this.lD = -16776961;
        this.lE = -256;
        this.lI = true;
        this.lK = ImageCacheType.MEMORY;
        this.lL = new ArrayList();
        this.lM = new Rect();
        this.lN = false;
        b(context);
        a(context, attributeSet);
        setImageCacheType(this.lK);
    }

    private void a(Context context, AttributeSet attributeSet) {
        TypedArray obtainStyledAttributes = context.obtainStyledAttributes(attributeSet, R.styleable.img_review_edit_cntrl);
        Boolean valueOf = Boolean.valueOf(obtainStyledAttributes.getBoolean(R.styleable.img_review_edit_cntrl_retain_image, true));
        if (valueOf != null) {
            setRetainImage(valueOf.booleanValue());
        }
        obtainStyledAttributes.recycle();
    }

    private void b(Context context) {
        setOnTouchListener(this);
        this.scaleGestureDetector = new ScaleGestureDetector(context, new a(this, null));
        this.lc = new Paint();
        this.ls = new Point();
        this.lr = new Point();
        this.lq = new Point();
        this.lp = new Point();
        this.ly.x = 0;
        this.ly.y = 0;
        setLayerType(1, null);
    }

    @Override // android.view.View.OnTouchListener
    public boolean onTouch(View view, MotionEvent motionEvent) {
        if (this.lw == null) {
            return false;
        }
        this.lh = true;
        this.scaleGestureDetector.onTouchEvent(motionEvent);
        int action = motionEvent.getAction();
        this.kV = motionEvent.getPointerCount();
        String str = TAG;
        StringBuilder sb = new StringBuilder("PINCH COUNT(start) = ");
        sb.append(motionEvent.getPointerCount());
        k.c(str, sb.toString());
        if (this.kV > 1) {
            this.le = true;
            this.li = false;
        }
        int x = (int) motionEvent.getX();
        int y = (int) motionEvent.getY();
        if (action == 0) {
            if (getParent() != null) {
                getParent().requestDisallowInterceptTouchEvent(true);
            }
            this.la = new Point(x, y);
            Point point = new Point(x, y);
            this.kZ = point;
            Point b = b(point);
            this.state = 0;
            if (e(b, this.ls)) {
                this.state = 1;
                this.lb = 1;
            } else if (e(b, this.lr)) {
                this.state = 1;
                this.lb = 2;
            } else if (e(b, this.lq)) {
                this.state = 1;
                this.lb = 3;
            } else if (e(b, this.lp)) {
                this.state = 1;
                this.lb = 4;
            } else {
                int c = c(x, y);
                this.kW = c;
                if (c != 0) {
                    this.state = 2;
                }
                if (this.state == 0 && this.le && this.lu > 1.0f) {
                    this.state = 3;
                    if (this.lA.x == 0) {
                        this.lA.x = 0;
                        this.lA.y = 0;
                    }
                    this.lx.x = this.kZ.x - this.lA.x;
                    this.lx.y = this.kZ.y - this.lA.y;
                }
            }
        } else if (action != 1) {
            if (action == 2) {
                if (this.le && !this.lf) {
                    return true;
                }
                this.kZ = new Point(x, y);
                Point b2 = b(new Point(this.kZ.x, this.kZ.y));
                int i = this.state;
                if (i != 3 && !this.lt) {
                    return true;
                }
                if (i == 1) {
                    int i2 = this.lb;
                    if (i2 == 1) {
                        Point point2 = this.ls;
                        this.ls = b2;
                        if (!a(this.lq, b2, this.lr, i2)) {
                            this.ls = point2;
                        }
                        if (this.ls.x > this.lj || this.ls.y > this.lk || this.ls.x < 0 || this.ls.y < 0) {
                            this.ls = point2;
                        }
                        if (this.ls.y > this.lq.y) {
                            this.ls = point2;
                        }
                        if (this.ls.x > this.lr.x) {
                            this.ls = point2;
                        }
                    } else if (i2 == 2) {
                        Point point3 = this.lr;
                        this.lr = b2;
                        if (!a(this.lp, b2, this.ls, i2)) {
                            this.lr = point3;
                        }
                        if (this.lr.x > this.lj || this.lr.y > this.lk || this.lr.x < 0 || this.lr.y < 0) {
                            this.lr = point3;
                        }
                        if (this.lr.y > this.lp.y) {
                            this.lr = point3;
                        }
                        if (this.ls.x > this.lr.x) {
                            this.lr = point3;
                        }
                    } else if (i2 == 3) {
                        Point point4 = this.lq;
                        this.lq = b2;
                        if (!a(this.ls, b2, this.lp, i2)) {
                            this.lq = point4;
                        }
                        if (this.lq.x > this.lj || this.lq.y > this.lk || this.lq.x < 0 || this.lq.y < 0) {
                            this.lq = point4;
                        }
                        if (this.lq.y < this.ls.y) {
                            this.lq = point4;
                        }
                        if (this.lp.x < this.lq.x) {
                            this.lq = point4;
                        }
                    } else if (i2 == 4) {
                        Point point5 = this.lp;
                        this.lp = b2;
                        if (!a(this.lr, b2, this.lq, i2)) {
                            this.lp = point5;
                        }
                        if (this.lp.x > this.lj || this.lp.y > this.lk || this.lp.x < 0 || this.lp.y < 0) {
                            this.lp = point5;
                        }
                        if (this.lp.y < this.lr.y) {
                            this.lp = point5;
                        }
                        if (this.lp.x < this.lq.x) {
                            this.lp = point5;
                        }
                    }
                } else if (i == 2) {
                    Point point6 = new Point(x, y);
                    this.kZ = point6;
                    a(this.kW, point6);
                } else if (i == 3) {
                    this.ly.x = this.kZ.x - this.lx.x;
                    this.ly.y = this.kZ.y - this.lx.y;
                    StringBuilder sb2 = new StringBuilder("PanOffset ");
                    sb2.append(this.ly.x);
                    sb2.append(" ");
                    sb2.append(this.ly.y);
                    sb2.append(" ");
                    sb2.append(this.kZ.x);
                    sb2.append(" ");
                    sb2.append(this.kZ.y);
                    sb2.append(" PanOrn ");
                    sb2.append(this.lx.x);
                    sb2.append(" ");
                    sb2.append(this.lx.y);
                    k.c("PanOrigin", sb2.toString());
                }
            }
        } else if (this.le) {
            this.lf = true;
            StringBuilder sb3 = new StringBuilder("firstPinchThisGesture ");
            sb3.append(this.lf);
            k.c("State", sb3.toString());
            aw();
        }
        invalidate();
        return true;
    }

    private void aw() {
        this.state = 0;
        StringBuilder sb = new StringBuilder("panoffset = ");
        sb.append(this.ly.x);
        sb.append(" ");
        sb.append(this.ly.y);
        k.c("PanOffset", sb.toString());
        Point a2 = a(new Point(0, 0));
        if (a2.x > getWidth() / 2) {
            float width = (a2.x - (getWidth() / 2)) + 1;
            this.ly.x = (int) (r3.x - width);
        }
        if (a2.y > getHeight() / 2) {
            float height = (a2.y - (getHeight() / 2)) + 1;
            this.ly.y = (int) (r2.y - height);
        }
        Point a3 = a(new Point((int) this.lj, (int) this.lk));
        if (a3.x < getWidth() / 2) {
            Point point = this.ly;
            point.x = (int) (point.x - ((a3.x - (getWidth() / 2)) - 1));
        }
        if (a3.y < getHeight() / 2) {
            Point point2 = this.ly;
            point2.y = (int) (point2.y - ((a3.y - (getHeight() / 2)) - 1));
        }
        this.lA.x = this.ly.x;
        this.lA.y = this.ly.y;
        if (this.lu == 1.0d) {
            this.ly.x = 0;
            this.ly.y = 0;
            this.lA.x = 0;
            this.lA.y = 0;
        }
        invalidate();
    }

    /* JADX INFO: Access modifiers changed from: package-private */
    /* loaded from: classes3.dex */
    public class a extends ScaleGestureDetector.SimpleOnScaleGestureListener {
        private final int lR;
        private final int lS;
        final ImgReviewEditCntrl lT;

        private a(ImgReviewEditCntrl imgReviewEditCntrl) {
            this.lT = imgReviewEditCntrl;
            this.lR = 1;
            this.lS = 15;
        }

        /* synthetic */ a(ImgReviewEditCntrl imgReviewEditCntrl, AnonymousClass1 anonymousClass1) {
            this(imgReviewEditCntrl);
        }

        @Override // android.view.ScaleGestureDetector.SimpleOnScaleGestureListener, android.view.ScaleGestureDetector.OnScaleGestureListener
        public boolean onScale(ScaleGestureDetector scaleGestureDetector) {
            this.lT.lv *= this.lT.scaleGestureDetector.getScaleFactor();
            StringBuilder sb = new StringBuilder("focus.x= ");
            sb.append(scaleGestureDetector.getFocusX());
            sb.append(" focus.y = ");
            sb.append(scaleGestureDetector.getFocusY());
            k.c("Zoom", sb.toString());
            Point point = new Point((int) scaleGestureDetector.getFocusX(), (int) scaleGestureDetector.getFocusY());
            if (this.lT.lg != this.lT.kV) {
                this.lT.lf = true;
            }
            if (this.lT.lf) {
                this.lT.lf = false;
                ImgReviewEditCntrl imgReviewEditCntrl = this.lT;
                imgReviewEditCntrl.lB = imgReviewEditCntrl.b(point);
            }
            if (this.lT.lv < 1.0f) {
                this.lT.lv = 1.0f;
            }
            if (this.lT.lv > 15.0f) {
                this.lT.lv = 15.0f;
            }
            if (this.lT.lv == 1.0f) {
                this.lT.ly.x = 0;
                this.lT.ly.y = 0;
                this.lT.state = 0;
                StringBuilder sb2 = new StringBuilder("state = ");
                sb2.append(this.lT.state);
                k.c("State", sb2.toString());
                this.lT.le = false;
            }
            ImgReviewEditCntrl imgReviewEditCntrl2 = this.lT;
            imgReviewEditCntrl2.lu = imgReviewEditCntrl2.lv;
            ImgReviewEditCntrl imgReviewEditCntrl3 = this.lT;
            Point a = imgReviewEditCntrl3.a(imgReviewEditCntrl3.lB);
            Point point2 = new Point(point.x - a.x, point.y - a.y);
            this.lT.ly.x += point2.x;
            this.lT.ly.y += point2.y;
            ImgReviewEditCntrl imgReviewEditCntrl4 = this.lT;
            imgReviewEditCntrl4.lg = imgReviewEditCntrl4.kV;
            StringBuilder sb3 = new StringBuilder("prevNumTouches = ");
            sb3.append(this.lT.lg);
            sb3.append(" numtouches = ");
            sb3.append(this.lT.kV);
            k.c("State", sb3.toString());
            this.lT.invalidate();
            return true;
        }
    }

    @Override // android.view.View
    protected void onDraw(Canvas canvas) {
        super.onDraw(canvas);
        if (isInEditMode()) {
            return;
        }
        canvas.getClipBounds(new Rect());
        int i = (int) (this.lj * 0.075d);
        if (!this.lh && this.lt && !this.lN) {
            this.ls.set(i, i);
            this.lr.set(((int) this.lj) - i, i);
            this.lq.set(i, ((int) this.lk) - i);
            this.lp.set(((int) this.lj) - i, ((int) this.lk) - i);
        }
        Bitmap bitmap = this.lw;
        if (bitmap == null || bitmap.isRecycled()) {
            return;
        }
        canvas.save();
        canvas.scale(1.0f, 1.0f);
        Paint paint = new Paint(2);
        Point a2 = a(new Point(0, 0));
        Rect rect = new Rect(0, 0, (int) this.lj, (int) this.lk);
        if (this.lu == BitmapDescriptorFactory.HUE_RED) {
            this.lu = 1.0f;
        }
        String str = TAG;
        StringBuilder sb = new StringBuilder("origin = ");
        sb.append(a2.x);
        sb.append(" ");
        sb.append(a2.y);
        k.c(str, sb.toString());
        canvas.drawBitmap(this.lw, rect, new Rect(a2.x, a2.y, ((int) (this.lz.width() * this.lu)) + a2.x, ((int) (this.lz.height() * this.lu)) + a2.y), paint);
        canvas.restore();
        if (this.lt) {
            a(canvas);
        }
        a(a2, canvas);
    }

    private void a(Point point, Canvas canvas) {
        ax();
        Iterator<BoundingRect> it = this.lL.iterator();
        while (it.hasNext()) {
            a(point, canvas, it.next());
        }
    }

    private void ax() {
        if (this.ld == null) {
            Paint paint = new Paint();
            this.ld = paint;
            paint.setStyle(Paint.Style.FILL);
        }
        ay();
    }

    private void ay() {
        int parseLong = (int) Long.parseLong(Integer.toString(this.lE, 16), 16);
        this.ld.setColor(Color.argb(100, (parseLong >> 16) & 255, (parseLong >> 8) & 255, parseLong & 255));
    }

    private void a(Point point, Canvas canvas, BoundingRect boundingRect) {
        if (b(boundingRect)) {
            setHighlightRectangle(boundingRect);
            b(this.lu, this.lo);
            this.lM.offset(point.x, point.y);
            canvas.drawRect(this.lM, this.ld);
        }
    }

    private boolean b(BoundingRect boundingRect) {
        return boundingRect != null && boundingRect.getRectTop() > 0;
    }

    private void setHighlightRectangle(BoundingRect boundingRect) {
        this.lM.set(boundingRect.getRectLeft(), boundingRect.getRectTop(), boundingRect.getRectRight(), boundingRect.getRectBottom());
    }

    private void b(float f, float f2) {
        this.lM.set(Math.round(r0.left * f * f2), Math.round(this.lM.top * f * f2), Math.round(this.lM.right * f * f2), Math.round(this.lM.bottom * f * f2));
    }

    private float getDisplayToBitmapScalingFactor() {
        float f = 1.0f;
        if (this.image != null) {
            try {
                int width = ((WindowManager) getContext().getSystemService("window")).getDefaultDisplay().getWidth() - this.lz.width();
                if (this.image.getImageRepresentation() == Image.ImageRep.IMAGE_REP_BITMAP && this.image.getImageBitmap() != null && !this.image.getImageBitmap().isRecycled()) {
                    f = Utility.getDisplayToBitmapScalingFactor(getContext(), this.image.getImageBitmap().getWidth(), width);
                } else if (this.image.getImageFileWidth() != null) {
                    f = Utility.getDisplayToBitmapScalingFactor(getContext(), this.image.getImageFileWidth().intValue(), width);
                }
            } catch (IOException unused) {
            }
        }
        return f;
    }

    private Rect a(float f, float f2, float f3, float f4) {
        float f5;
        float f6;
        Rect rect = new Rect();
        if (f2 > this.lj) {
            f6 = (int) ((f4 / f2) * f);
            if (f6 > f3) {
                f5 = (int) ((f2 / f) * f3);
                f6 = f3;
            }
            f5 = f4;
        } else {
            float f7 = (int) ((f2 / f) * f3);
            if (f7 > f4) {
                f6 = (int) ((f4 / f2) * f);
                f5 = f4;
            } else {
                f5 = f7;
                f6 = f3;
            }
        }
        rect.left = (int) ((f3 - f6) / 2.0f);
        rect.right = (int) (f6 + rect.left);
        rect.top = ((int) (f4 - f5)) / 2;
        rect.bottom = (int) (f5 + rect.top);
        return rect;
    }

    Point d(Point point, Point point2) {
        Point point3 = new Point();
        if (point2.y > point2.x) {
            point3.y = point.y;
            point3.x = (int) ((point.y / point2.y) * point2.x);
            if (point3.x > point.x) {
                point3.x = point.x;
                point3.y = (int) ((point2.y / point2.x) * point.x);
            }
        } else {
            point3.x = point.x;
            point3.y = (int) ((point2.y / point2.x) * point.x);
            if (point3.y > point.y) {
                point3.y = point.y;
                point3.x = (int) ((point.y / point2.y) * point2.x);
            }
        }
        return point3;
    }

    private void a(Canvas canvas) {
        Line_Style_Solid line_Style_Solid = this.lF;
        if (line_Style_Solid != null) {
            if (line_Style_Solid.equals(Line_Style_Solid.LINE_STYLE_DOTTED)) {
                this.lc.setPathEffect(new DashPathEffect(new float[]{10.0f, 10.0f}, 10.0f));
            } else {
                this.lc.setPathEffect(new DashPathEffect(new float[]{BitmapDescriptorFactory.HUE_RED, BitmapDescriptorFactory.HUE_RED}, BitmapDescriptorFactory.HUE_RED));
            }
        }
        this.lc.setStrokeWidth(5.0f);
        this.lc.setColor(this.lC);
        this.lc.setStyle(Paint.Style.STROKE);
        this.lc.setAntiAlias(true);
        Point a2 = a(this.ls);
        Point a3 = a(this.lr);
        Point a4 = a(this.lq);
        Point a5 = a(this.lp);
        Path path = new Path();
        path.moveTo(a2.x, a2.y);
        path.lineTo(a3.x, a3.y);
        path.moveTo(a3.x, a3.y);
        path.lineTo(a5.x, a5.y);
        path.moveTo(a5.x, a5.y);
        path.lineTo(a4.x, a4.y);
        path.moveTo(a4.x, a4.y);
        path.lineTo(a2.x, a2.y);
        path.close();
        canvas.drawPath(path, this.lc);
        this.lc.setStyle(Paint.Style.FILL);
        this.lc.setColor(this.lD);
        canvas.drawCircle(a2.x, a2.y, kT, this.lc);
        canvas.drawCircle(a3.x, a3.y, kT, this.lc);
        canvas.drawCircle(a4.x, a4.y, kT, this.lc);
        canvas.drawCircle(a5.x, a5.y, kT, this.lc);
    }

    private boolean e(Point point, Point point2) {
        float f = this.ln * 35.0f;
        if (point.x >= point2.x - f && point.x <= point2.x + f && point.y >= point2.y - f && point.y <= point2.y + f) {
            this.li = false;
            return true;
        }
        if (this.lu > 1.0f) {
            this.li = true;
        }
        return false;
    }

    private boolean a(Point point, Point point2, Point point3, int i) {
        double abs = Math.abs((Math.atan2(point2.y - point3.y, point2.x - point3.x) * 180.0d) / 3.141592653589793d) + Math.abs((Math.atan2(point2.y - point.y, point2.x - point.x) * 180.0d) / 3.141592653589793d);
        return (i == 2 || i == 4) ? abs < 175.0d : abs > 175.0d || abs < 2.0d;
    }

    private void a(int i, Point point) {
        Point b = b(point);
        Point b2 = b(this.la);
        float f = b.x - b2.x;
        float f2 = b.y - b2.y;
        if (i == 1) {
            if (this.kX.y + f2 >= this.lq.y || this.kX.y + f2 >= this.lp.y || this.kX.y + f2 < BitmapDescriptorFactory.HUE_RED || this.kY.y + f2 < BitmapDescriptorFactory.HUE_RED) {
                return;
            }
            this.ls.y = (int) (this.kX.y + f2);
            this.lr.y = (int) (this.kY.y + f2);
            return;
        }
        if (i == 2) {
            if (this.kX.x + f >= this.lp.x || this.kY.x + f >= this.lr.x || this.kX.x + f < BitmapDescriptorFactory.HUE_RED || this.kY.x + f < BitmapDescriptorFactory.HUE_RED) {
                return;
            }
            this.ls.x = (int) (this.kX.x + f);
            StringBuilder sb = new StringBuilder("[pointmove]pointImage.x = ");
            sb.append(this.ls.x);
            k.c("Zoom", sb.toString());
            this.lq.x = (int) (this.kY.x + f);
            return;
        }
        if (i == 3) {
            if (this.kX.x + f <= this.ls.x || this.kY.x + f <= this.lq.x || this.kX.x + f > this.lj || this.kY.x + f > this.lj) {
                return;
            }
            this.lr.x = (int) (this.kX.x + f);
            this.lp.x = (int) (this.kY.x + f);
            return;
        }
        if (i == 4) {
            int i2 = (int) f2;
            if (this.kX.y + i2 <= this.ls.y || this.kY.y + i2 <= this.lr.y || this.kX.y + i2 > this.lk || this.kY.y + i2 >= this.lk) {
                return;
            }
            this.lq.y = (int) (this.kX.y + f2);
            this.lp.y = (int) (this.kY.y + f2);
        }
    }

    private int c(int i, int i2) {
        Point b = b(new Point(i, i2));
        Point point = this.ls;
        Point point2 = this.lr;
        if (a(b, false, point, point2)) {
            this.kX.x = point.x;
            this.kX.y = point.y;
            this.kY.x = point2.x;
            this.kY.y = point2.y;
            this.li = false;
            return 1;
        }
        Point point3 = this.lr;
        Point point4 = this.lp;
        if (a(b, true, point3, point4)) {
            this.kX.x = point3.x;
            this.kX.y = point3.y;
            this.kY.x = point4.x;
            this.kY.y = point4.y;
            this.li = false;
            return 3;
        }
        Point point5 = this.ls;
        Point point6 = this.lq;
        if (a(b, true, point5, point6)) {
            this.kX.x = point5.x;
            this.kX.y = point5.y;
            this.kY.x = point6.x;
            this.kY.y = point6.y;
            this.li = false;
            return 2;
        }
        Point point7 = this.lq;
        Point point8 = this.lp;
        if (!a(b, false, point7, point8)) {
            this.li = true;
            return 0;
        }
        this.kX.x = point7.x;
        this.kX.y = point7.y;
        this.kY.x = point8.x;
        this.kY.y = point8.y;
        this.li = false;
        return 4;
    }

    private boolean a(Point point, boolean z, Point point2, Point point3) {
        float f = this.ln;
        float f2 = kT * f;
        float f3 = f * 35.0f;
        float f4 = point3.x - point2.x;
        if (f4 == BitmapDescriptorFactory.HUE_RED) {
            return ((float) point.x) >= ((float) point3.x) - f2 && ((float) point.x) <= ((float) point3.x) + f2;
        }
        float f5 = (point3.y - point2.y) / f4;
        float f6 = point2.y - (point2.x * f5);
        if (z) {
            float f7 = (point.y - f6) / f5;
            return ((float) point.x) >= f7 - f3 && ((float) point.x) <= f7 + f3 && ((float) point.y) >= ((float) point2.y) + f3 && ((float) point.y) <= ((float) point3.y) - f3;
        }
        float f8 = (point.x * f5) + f6;
        if (point.y < f8 - f3 || point.y > f8 + f3) {
            return false;
        }
        k.c(TAG, "isonline true: horizontal");
        return true;
    }

    /* JADX INFO: Access modifiers changed from: private */
    public Point a(Point point) {
        Point point2 = new Point();
        if (this.lu != BitmapDescriptorFactory.HUE_RED) {
            point2.x = (int) ((point.x * this.lu * (this.lz.width() / this.lj)) + this.ll + this.lz.left + this.ly.x);
            point2.y = (int) ((point.y * this.lu * (this.lz.height() / this.lk)) + this.lm + this.lz.top + this.ly.y);
        } else {
            point2.x = (int) ((point.x * (this.lz.width() / this.lj)) + this.ll + this.lz.left + this.ly.x);
            point2.y = (int) ((point.y * (this.lz.height() / this.lk)) + this.lm + this.lz.top + this.ly.y);
        }
        return point2;
    }

    /* JADX INFO: Access modifiers changed from: private */
    public Point b(Point point) {
        Point point2 = new Point();
        if (this.lu != BitmapDescriptorFactory.HUE_RED) {
            float f = point.x;
            float f2 = this.ll;
            point2.x = (int) ((((f - f2) - this.lz.left) - this.ly.x) / (this.lu * (this.lz.width() / this.lj)));
            float f3 = point.y;
            float f4 = this.lm;
            point2.y = (int) ((((f3 - f4) - this.lz.top) - this.ly.y) / (this.lu * (this.lz.height() / this.lk)));
        } else {
            float f5 = point.x;
            float f6 = this.ll;
            point2.x = (int) ((((f5 - f6) - this.lz.left) - this.ly.x) / (this.lz.width() / this.lj));
            float f7 = point.y;
            float f8 = this.lm;
            point2.y = (int) ((((f7 - f8) - this.lz.top) - this.ly.y) / (this.lz.height() / this.lk));
        }
        return point2;
    }

    @Override // android.view.View
    public Parcelable onSaveInstanceState() {
        Bundle bundle = new Bundle();
        bundle.putParcelable("instanceState", super.onSaveInstanceState());
        bundle.putBoolean("retainImage", this.lI);
        if (this.lI) {
            aA();
            String str = this.lH;
            if (str != null) {
                bundle.putString("bitmapKey", str);
            }
        }
        bundle.putSerializable("cacheType", this.lK);
        bundle.putParcelable("displayrect", this.lz);
        bundle.putFloat("currentScale", this.lu);
        bundle.putFloat("imgHt", this.lk);
        bundle.putFloat("imgWd", this.lj);
        bundle.putIntArray("p1", new int[]{this.ls.x, this.ls.y});
        bundle.putIntArray("p2", new int[]{this.lr.x, this.lr.y});
        bundle.putIntArray("p3", new int[]{this.lq.x, this.lq.y});
        bundle.putIntArray("p4", new int[]{this.lp.x, this.lp.y});
        bundle.putInt("linecolor", this.lC);
        bundle.putInt("cornercolor", this.lD);
        bundle.putSerializable("boundingTetragon", this.lG);
        BoundingTetragon boundingTetragon = this.lG;
        if (boundingTetragon != null) {
            bundle.putSerializable("boundingTetragon", boundingTetragon);
        }
        bundle.putBoolean("isVisibleRectangle", this.lt);
        bundle.putBoolean("isMoving", this.lh);
        bundle.putBoolean("isCropTetragonSetbyUser", this.lN);
        return bundle;
    }

    @Override // android.view.View
    public void onRestoreInstanceState(Parcelable parcelable) {
        if (parcelable instanceof Bundle) {
            Bundle bundle = (Bundle) parcelable;
            Bitmap bitmap = this.lw;
            if (bitmap != null) {
                bitmap.recycle();
                this.lw = null;
            }
            ImageCacheType imageCacheType = (ImageCacheType) bundle.getSerializable("cacheType");
            this.lK = imageCacheType;
            setImageCacheType(imageCacheType);
            this.lI = bundle.getBoolean("retainImage");
            this.lH = bundle.getString("bitmapKey");
            if (this.lI) {
                aB();
            } else {
                aC();
            }
            this.lu = bundle.getFloat("currentScale", this.lu);
            this.lC = bundle.getInt("linecolor");
            this.lD = bundle.getInt("cornercolor");
            this.lt = bundle.getBoolean("isVisibleRectangle");
            this.lh = bundle.getBoolean("isMoving");
            this.lN = bundle.getBoolean("isCropTetragonSetbyUser");
            this.ls = new Point(bundle.getIntArray("p1")[0], bundle.getIntArray("p1")[1]);
            this.lr = new Point(bundle.getIntArray("p2")[0], bundle.getIntArray("p2")[1]);
            this.lq = new Point(bundle.getIntArray("p3")[0], bundle.getIntArray("p3")[1]);
            this.lp = new Point(bundle.getIntArray("p4")[0], bundle.getIntArray("p4")[1]);
            this.le = false;
            this.li = false;
            this.state = 0;
            this.lG = (BoundingTetragon) bundle.getSerializable("boundingTetragon");
            super.onRestoreInstanceState(bundle.getParcelable("instanceState"));
            return;
        }
        super.onRestoreInstanceState(parcelable);
    }

    @Override // android.view.View
    protected void onSizeChanged(int i, int i2, int i3, int i4) {
        super.onSizeChanged(i, i2, i3, i4);
        if (this.lw != null) {
            this.rotation = ((WindowManager) getContext().getSystemService("window")).getDefaultDisplay().getRotation();
            av();
        }
    }

    private void az() {
        if (!Licensing.isSdkLicensed(Licensing.LicenseType.IMAGE_CAPTURE)) {
            throw new KmcRuntimeException(ErrorInfo.KMC_UT_LICENSE_IMAGE_CAPTURE);
        }
    }

    public void clearImage() {
        Bitmap bitmap = this.lw;
        if (bitmap != null) {
            bitmap.recycle();
        }
        this.image = null;
        clearHighlights();
        invalidate();
        aC();
    }

    private void aA() {
        Bitmap bitmap = this.lw;
        if (bitmap == null || bitmap.isRecycled() || m(this.lH)) {
            return;
        }
        aC();
        String obj = UUID.randomUUID().toString();
        if (this.lJ.a(obj, this.lw)) {
            this.lH = obj;
        }
    }

    private boolean m(String str) {
        c cVar = this.lJ;
        return (cVar == null || str == null || cVar.getBitmap(str) == null) ? false : true;
    }

    private void aB() {
        String str = this.lH;
        if (str != null) {
            this.lw = this.lJ.w(str);
            this.lH = null;
        }
    }

    private void aC() {
        String str = this.lH;
        if (str != null) {
            Bitmap w = this.lJ.w(str);
            if (w != null && !w.isRecycled()) {
                w.recycle();
            }
            this.lH = null;
        }
    }

    public void setRetainImage(boolean z) {
        this.lI = z;
    }

    public boolean getRetainImage() {
        return this.lI;
    }

    public Image getImage() {
        return this.image;
    }

    public int getCropLineColor() {
        return this.lC;
    }

    public int getCropCornerColor() {
        int i = this.lD;
        if (i == -1) {
            return -16776961;
        }
        return i;
    }
}