package com.airbnb.lottie

import android.content.Context
import android.content.res.Resources
import android.graphics.*
import android.graphics.drawable.ColorDrawable
import android.os.Environment
import android.util.Log
import android.util.TypedValue
import android.view.ViewGroup
import android.widget.FrameLayout
import android.widget.ImageView
import com.airbnb.happo.SnapshotProvider
import com.airbnb.lottie.model.KeyPath
import com.airbnb.lottie.value.*
import java.io.File
import java.io.IOException
import java.util.concurrent.LinkedBlockingQueue
import java.util.concurrent.ThreadPoolExecutor
import java.util.concurrent.TimeUnit

private class SnapshotInfo(val canvas: Canvas, val progress: Float)

class LottieSnapshotProvider internal constructor(private val context: Context) : SnapshotProvider() {

    private val queue = LinkedBlockingQueue<Runnable>()
    private val executor = ThreadPoolExecutor(CORES, CORES, 15, TimeUnit.MINUTES, queue)
    // Bitmap to return from an ImageAssetDelegate to make testing animations with images easier.
    private val dummyBitmap: Bitmap = BitmapFactory.decodeResource(context.resources, com.airbnb.lottie.samples.R.drawable.airbnb)
    private val renderBitmap: Bitmap = Bitmap.createBitmap(1000, 1000, Bitmap.Config.ARGB_8888)
    private val clearPaint = Paint().apply {
        xfermode = PorterDuffXfermode(PorterDuff.Mode.CLEAR)
    }
    private val renderCanvas = Canvas(renderBitmap)
    private val snapshotInfos: List<SnapshotInfo> by lazy {
        ArrayList<SnapshotInfo>(25).apply {
            for (row in 0..4) {
                for (col in 0..4) {
                    val matrix = Matrix()
                    matrix.setRectToRect(
                            RectF(0f, 0f, 1000f, 1000f),
                            RectF(col * 200f, row * 200f, col * 200f + 200f, row * 200f + 200f),
                            Matrix.ScaleToFit.CENTER
                    )
                    val canvas = Canvas(renderBitmap)
                    canvas.matrix = matrix
                    canvas.scale(0.2f, 0.2f, 0f, 0f)
                    canvas.translate(col * 1000f, row * 1000f)

                    add(SnapshotInfo(canvas, 0.04f * (row * 5f + col)))
                }
            }
        }
    }

    private var remainingTasks = 0

    override fun beginSnapshotting() {
        Log.d(L.TAG, "beginSnapshotting")
        try {
            snapshotAssets(context.assets.list(""))
            val tests = context.assets.list("Tests")
            for (i in tests!!.indices) {
                tests[i] = "Tests/" + tests[i]
            }
            snapshotAssets(tests)

            val lottiefiles = context.assets.list("lottiefiles")
            for (i in lottiefiles!!.indices) {
                lottiefiles[i] = "lottiefiles/" + lottiefiles[i]
            }
            snapshotAssets(lottiefiles)
        } catch (e: IOException) {
            onError(e)
        }

        testFrameBoundary()
        testFrameBoundary2()
        testScaleTypes()
        testDynamicProperties()
        testSwitchingToDrawableAndBack()
        testStartEndFrameWithStartEndProgress()
        testUrl()
    }

    private fun snapshotAssets(animations: Array<String>?) {
        val dir = File(Environment.getExternalStorageDirectory().toString() + "/Snapshots")

        dir.mkdirs()
        for (file in dir.listFiles()) {

            file.delete()
        }
        for (animation in animations!!) {
            if (!animation.contains(".json") && !animation.contains(".zip")) {
                continue
            }
            remainingTasks += 1
            Log.d(L.TAG, "Enqueueing $animation")
            executor.execute {
                runAnimation(animation)
                decrementAndCompleteIfDone()
            }
        }
    }

    private fun runAnimation(name: String) {
        Log.d(L.TAG, "Running $name")
        val result = LottieCompositionFactory.fromAssetSync(context, name)
        if (result.exception != null) throw IllegalStateException(result.exception)
        val composition = result.value ?: return

        val bounds = composition.bounds
        val width = bounds.width()
        val height = bounds.height()
        val displayMetrics = Resources.getSystem().displayMetrics
        if (width > 4 * displayMetrics.widthPixels || height > 4 * displayMetrics.heightPixels) {
            Log.d("Happo", name + " is too large. Skipping (" + width + "x" + height + ")")
            return
        }
        drawComposition(composition, name)
    }

    private fun drawComposition(composition: LottieComposition, name: String) {
        Log.d(L.TAG, "Drawing $name")
        val drawable = LottieDrawable()
        drawable.composition = composition
        drawable.setImageAssetDelegate { dummyBitmap }
        drawable.scale = maxOf(composition.bounds.width(), composition.bounds.height()) / 200f

        val strokeWidth = 7f
        val outlinePaint = Paint().apply {
            style = Paint.Style.STROKE
            color = Color.RED
            this.strokeWidth = strokeWidth
        }

        clearBitmap()
        snapshotInfos.forEach {
            drawable.progress = it.progress
            drawable.draw(it.canvas)
            it.canvas.drawRect(strokeWidth, strokeWidth, it.canvas.width - strokeWidth, it.canvas.height - strokeWidth, outlinePaint)
        }
        recordSnapshot(renderBitmap, "android", name, "Main")
    }

    override fun stopSnapshotting() {
        queue.clear()
    }

    private fun decrementAndCompleteIfDone() {
        remainingTasks--
        Log.d(L.TAG, "There are $remainingTasks tasks left.")
        Log.d("Happo", "There are $remainingTasks remaining tasks.")
        if (remainingTasks < 0) {
            throw IllegalStateException("Remaining tasks cannot be negative.")
        }
        if (remainingTasks == 0) {
            onComplete()
        }
    }

    private fun testScaleTypes() {
        val composition = LottieComposition.Factory.fromFileSync(
                context, "LottieLogo1.json")

        var params = FrameLayout.LayoutParams(
                ViewGroup.LayoutParams.WRAP_CONTENT, ViewGroup.LayoutParams.WRAP_CONTENT)
        testScaleTypeView(context, composition, "Wrap Content", params, null, null)

        params = FrameLayout.LayoutParams(dpToPx(300), dpToPx(300))
        testScaleTypeView(context, composition, "300x300 @4x", params, null, 4f)

        params = FrameLayout.LayoutParams(dpToPx(300), dpToPx(300))
        testScaleTypeView(context, composition, "300x300 centerCrop", params,
                ImageView.ScaleType.CENTER_CROP, null)

        params = FrameLayout.LayoutParams(dpToPx(300), dpToPx(300))
        testScaleTypeView(context, composition, "300x300 centerInside", params,
                ImageView.ScaleType.CENTER_INSIDE, null)

        params = FrameLayout.LayoutParams(dpToPx(300), dpToPx(300))
        testScaleTypeView(context, composition, "300x300 centerInside @2x", params,
                ImageView.ScaleType.CENTER_INSIDE, 2f)

        params = FrameLayout.LayoutParams(dpToPx(300), dpToPx(300))
        testScaleTypeView(context, composition, "300x300 centerCrop @2x", params,
                ImageView.ScaleType.CENTER_CROP, 2f)

        params = FrameLayout.LayoutParams(dpToPx(300), dpToPx(300))
        testScaleTypeView(context, composition, "300x300 @2x", params, null, 2f)

        params = FrameLayout.LayoutParams(dpToPx(600), dpToPx(300))
        testScaleTypeView(context, composition, "600x300 centerInside", params,
                ImageView.ScaleType.CENTER_INSIDE, null)

        params = FrameLayout.LayoutParams(dpToPx(300), dpToPx(600))
        testScaleTypeView(context, composition, "300x600 centerInside", params,
                ImageView.ScaleType.CENTER_INSIDE, null)

        params = FrameLayout.LayoutParams(
                ViewGroup.LayoutParams.MATCH_PARENT, ViewGroup.LayoutParams.MATCH_PARENT)
        testScaleTypeView(context, composition, "Match Parent", params, null, null)
    }

    private fun testScaleTypeView(context: Context, composition: LottieComposition?,
                                  name: String, params: FrameLayout.LayoutParams, scaleType: ImageView.ScaleType?,
                                  scale: Float?) {
        val container = FrameLayout(context)
        val animationView = LottieAnimationView(context)
        animationView.setComposition(composition!!)
        animationView.progress = 1f
        if (scaleType != null) {
            animationView.scaleType = scaleType
        }
        if (scale != null) {
            animationView.scale = scale
        }
        container.addView(animationView, params)

        recordSnapshot(container, 1080, "android", "Scale Types", name, ViewGroup.LayoutParams(
                ViewGroup.LayoutParams.WRAP_CONTENT, ViewGroup.LayoutParams.WRAP_CONTENT))
    }

    private fun testFrameBoundary() {
        val animationView = LottieAnimationView(context)
        val composition = LottieComposition.Factory.fromFileSync(context, "Tests/Frame.json")
        animationView.setComposition(composition!!)
        val params = ViewGroup.LayoutParams(
                ViewGroup.LayoutParams.WRAP_CONTENT, ViewGroup.LayoutParams.WRAP_CONTENT)

        animationView.frame = 16
        recordSnapshot(animationView, 1080, "android", "Frame Boundary", "Frame 16 Red", params)
        animationView.frame = 17
        recordSnapshot(animationView, 1080, "android", "Frame Boundary", "Frame 17 Blue", params)
        animationView.frame = 50
        recordSnapshot(animationView, 1080, "android", "Frame Boundary", "Frame 50 Blue", params)
        animationView.frame = 51
        recordSnapshot(animationView, 1080, "android", "Frame Boundary", "Frame 51 Green", params)
    }

    private fun testFrameBoundary2() {
        val animationView = LottieAnimationView(context)
        val composition = LottieComposition.Factory.fromFileSync(context, "Tests/RGB.json")
        animationView.setComposition(composition!!)
        val params = ViewGroup.LayoutParams(
                ViewGroup.LayoutParams.WRAP_CONTENT, ViewGroup.LayoutParams.WRAP_CONTENT)

        animationView.frame = 0
        recordSnapshot(animationView, 1080, "android", "Frame Boundary", "Frame 0 Red", params)
        animationView.frame = 1
        recordSnapshot(animationView, 1080, "android", "Frame Boundary", "Frame 1 Green", params)
        animationView.frame = 2
        recordSnapshot(animationView, 1080, "android", "Frame Boundary", "Frame 2 Blue", params)
    }

    private fun testDynamicProperties() {
        testDynamicProperty(
                "Fill color (Green)",
                KeyPath("Shape Layer 1", "Rectangle", "Fill 1"),
                LottieProperty.COLOR,
                LottieValueCallback(Color.GREEN))

        testDynamicProperty(
                "Fill color (Yellow)",
                KeyPath("Shape Layer 1", "Rectangle", "Fill 1"),
                LottieProperty.COLOR,
                LottieValueCallback(Color.YELLOW))

        testDynamicProperty(
                "Fill opacity",
                KeyPath("Shape Layer 1", "Rectangle", "Fill 1"),
                LottieProperty.OPACITY,
                LottieValueCallback(50))

        testDynamicProperty(
                "Stroke color",
                KeyPath("Shape Layer 1", "Rectangle", "Stroke 1"),
                LottieProperty.STROKE_COLOR,
                LottieValueCallback(Color.GREEN))

        testDynamicProperty(
                "Stroke width",
                KeyPath("Shape Layer 1", "Rectangle", "Stroke 1"),
                LottieProperty.STROKE_WIDTH,
                LottieRelativeFloatValueCallback(50f))

        testDynamicProperty(
                "Stroke opacity",
                KeyPath("Shape Layer 1", "Rectangle", "Stroke 1"),
                LottieProperty.OPACITY,
                LottieValueCallback(50))

        testDynamicProperty(
                "Transform anchor point",
                KeyPath("Shape Layer 1", "Rectangle"),
                LottieProperty.TRANSFORM_ANCHOR_POINT,
                LottieRelativePointValueCallback(PointF(20f, 20f)))

        testDynamicProperty(
                "Transform position",
                KeyPath("Shape Layer 1", "Rectangle"),
                LottieProperty.TRANSFORM_POSITION,
                LottieRelativePointValueCallback(PointF(20f, 20f)))

        testDynamicProperty(
                "Transform position (relative)",
                KeyPath("Shape Layer 1", "Rectangle"),
                LottieProperty.TRANSFORM_POSITION,
                LottieRelativePointValueCallback(PointF(20f, 20f)))

        testDynamicProperty(
                "Transform opacity",
                KeyPath("Shape Layer 1", "Rectangle"),
                LottieProperty.TRANSFORM_OPACITY,
                LottieValueCallback(50))

        testDynamicProperty(
                "Transform rotation",
                KeyPath("Shape Layer 1", "Rectangle"),
                LottieProperty.TRANSFORM_ROTATION,
                LottieValueCallback(45f))

        testDynamicProperty(
                "Transform scale",
                KeyPath("Shape Layer 1", "Rectangle"),
                LottieProperty.TRANSFORM_SCALE,
                LottieValueCallback(ScaleXY(0.5f, 0.5f)))

        testDynamicProperty(
                "Ellipse position",
                KeyPath("Shape Layer 1", "Ellipse", "Ellipse Path 1"),
                LottieProperty.POSITION,
                LottieRelativePointValueCallback(PointF(20f, 20f)))

        testDynamicProperty(
                "Ellipse size",
                KeyPath("Shape Layer 1", "Ellipse", "Ellipse Path 1"),
                LottieProperty.ELLIPSE_SIZE,
                LottieRelativePointValueCallback(PointF(40f, 60f)))

        testDynamicProperty(
                "Star points",
                KeyPath("Shape Layer 1", "Star", "Polystar Path 1"),
                LottieProperty.POLYSTAR_POINTS,
                LottieValueCallback(8f))

        testDynamicProperty(
                "Star rotation",
                KeyPath("Shape Layer 1", "Star", "Polystar Path 1"),
                LottieProperty.POLYSTAR_ROTATION,
                LottieValueCallback(10f))

        testDynamicProperty(
                "Star position",
                KeyPath("Shape Layer 1", "Star", "Polystar Path 1"),
                LottieProperty.POSITION,
                LottieRelativePointValueCallback(PointF(20f, 20f)))

        testDynamicProperty(
                "Star inner radius",
                KeyPath("Shape Layer 1", "Star", "Polystar Path 1"),
                LottieProperty.POLYSTAR_INNER_RADIUS,
                LottieValueCallback(10f))

        testDynamicProperty(
                "Star inner roundedness",
                KeyPath("Shape Layer 1", "Star", "Polystar Path 1"),
                LottieProperty.POLYSTAR_INNER_ROUNDEDNESS,
                LottieValueCallback(100f))

        testDynamicProperty(
                "Star outer radius",
                KeyPath("Shape Layer 1", "Star", "Polystar Path 1"),
                LottieProperty.POLYSTAR_OUTER_RADIUS,
                LottieValueCallback(60f))

        testDynamicProperty(
                "Star outer roundedness",
                KeyPath("Shape Layer 1", "Star", "Polystar Path 1"),
                LottieProperty.POLYSTAR_OUTER_ROUNDEDNESS,
                LottieValueCallback(100f))

        testDynamicProperty(
                "Polygon points",
                KeyPath("Shape Layer 1", "Polygon", "Polystar Path 1"),
                LottieProperty.POLYSTAR_POINTS,
                LottieValueCallback(8f))

        testDynamicProperty(
                "Polygon rotation",
                KeyPath("Shape Layer 1", "Polygon", "Polystar Path 1"),
                LottieProperty.POLYSTAR_ROTATION,
                LottieValueCallback(10f))

        testDynamicProperty(
                "Polygon position",
                KeyPath("Shape Layer 1", "Polygon", "Polystar Path 1"),
                LottieProperty.POSITION,
                LottieRelativePointValueCallback(PointF(20f, 20f)))

        testDynamicProperty(
                "Polygon radius",
                KeyPath("Shape Layer 1", "Polygon", "Polystar Path 1"),
                LottieProperty.POLYSTAR_OUTER_RADIUS,
                LottieRelativeFloatValueCallback(60f))

        testDynamicProperty(
                "Polygon roundedness",
                KeyPath("Shape Layer 1", "Polygon", "Polystar Path 1"),
                LottieProperty.POLYSTAR_OUTER_ROUNDEDNESS,
                LottieValueCallback(100f))

        testDynamicProperty(
                "Repeater transform position",
                KeyPath("Shape Layer 1", "Repeater Shape", "Repeater 1"),
                LottieProperty.TRANSFORM_POSITION,
                LottieRelativePointValueCallback(PointF(100f, 100f)))

        testDynamicProperty(
                "Repeater transform start opacity",
                KeyPath("Shape Layer 1", "Repeater Shape", "Repeater 1"),
                LottieProperty.TRANSFORM_START_OPACITY,
                LottieValueCallback(25f))

        testDynamicProperty(
                "Repeater transform end opacity",
                KeyPath("Shape Layer 1", "Repeater Shape", "Repeater 1"),
                LottieProperty.TRANSFORM_END_OPACITY,
                LottieValueCallback(25f))

        testDynamicProperty(
                "Repeater transform rotation",
                KeyPath("Shape Layer 1", "Repeater Shape", "Repeater 1"),
                LottieProperty.TRANSFORM_ROTATION,
                LottieValueCallback(45f))

        testDynamicProperty(
                "Repeater transform scale",
                KeyPath("Shape Layer 1", "Repeater Shape", "Repeater 1"),
                LottieProperty.TRANSFORM_SCALE,
                LottieValueCallback(ScaleXY(2f, 2f)))

        testDynamicProperty(
                "Time remapping",
                KeyPath("Circle 1"),
                LottieProperty.TIME_REMAP,
                LottieValueCallback(1f))

        testDynamicProperty(
                "Color Filter",
                KeyPath("**"),
                LottieProperty.COLOR_FILTER,
                LottieValueCallback<ColorFilter>(SimpleColorFilter(Color.GREEN)))

        val blueColorFilter = LottieValueCallback<ColorFilter>(SimpleColorFilter(Color.GREEN))
        val animationView = LottieAnimationView(context)
        val composition = LottieComposition.Factory.fromFileSync(context, "Tests/Shapes.json")
        animationView.setComposition(composition!!)
        animationView.progress = 0f
        val params = ViewGroup.LayoutParams(ViewGroup.LayoutParams.WRAP_CONTENT, ViewGroup.LayoutParams.WRAP_CONTENT)
        animationView.addValueCallback(KeyPath("**"), LottieProperty.COLOR_FILTER, blueColorFilter)
        recordSnapshot(animationView, 1080, "android", "Dynamic Properties", "Color Filter before blue", params)
        blueColorFilter.setValue(SimpleColorFilter(Color.BLUE))
        recordSnapshot(animationView, 1080, "android", "Dynamic Properties", "Color Filter after blue", params)

        testDynamicProperty(
                "Null Color Filter",
                KeyPath("**"),
                LottieProperty.COLOR_FILTER,
                LottieValueCallback<ColorFilter>(null))

        testDynamicProperty(
                "Opacity interpolation (0)",
                KeyPath("Shape Layer 1", "Rectangle"),
                LottieProperty.TRANSFORM_OPACITY,
                LottieInterpolatedIntegerValue(10, 100),
                0f)

        testDynamicProperty(
                "Opacity interpolation (0.5)",
                KeyPath("Shape Layer 1", "Rectangle"),
                LottieProperty.TRANSFORM_OPACITY,
                LottieInterpolatedIntegerValue(10, 100),
                0.5f)

        testDynamicProperty(
                "Opacity interpolation (1)",
                KeyPath("Shape Layer 1", "Rectangle"),
                LottieProperty.TRANSFORM_OPACITY,
                LottieInterpolatedIntegerValue(10, 100),
                1f)
    }

    private fun <T> testDynamicProperty(
            name: String, keyPath: KeyPath, property: T, callback: LottieValueCallback<T>) {
        testDynamicProperty(name, keyPath, property, callback, 0f)
    }

    private fun <T> testDynamicProperty(
            name: String, keyPath: KeyPath, property: T, callback: LottieValueCallback<T>, progress: Float) {
        val animationView = LottieAnimationView(context)
        val composition = LottieComposition.Factory.fromFileSync(context, "Tests/Shapes.json")
        animationView.setComposition(composition!!)
        animationView.progress = progress
        val params = ViewGroup.LayoutParams(
                ViewGroup.LayoutParams.WRAP_CONTENT, ViewGroup.LayoutParams.WRAP_CONTENT)
        animationView.addValueCallback(keyPath, property, callback)
        recordSnapshot(animationView, 1080, "android", "Dynamic Properties", name, params)
    }

    private fun testSwitchingToDrawableAndBack() {
        val composition = LottieComposition.Factory.fromFileSync(context, "Tests/Shapes.json")
        val view = LottieAnimationView(context)
        view.setComposition(composition!!)
        view.setImageDrawable(ColorDrawable(Color.RED))
        view.setComposition(composition)
        val params = ViewGroup.LayoutParams(
                ViewGroup.LayoutParams.WRAP_CONTENT, ViewGroup.LayoutParams.WRAP_CONTENT)
        recordSnapshot(view, 1080, "android", "Reset Animation", "Drawable and back", params)
    }

    private fun testStartEndFrameWithStartEndProgress() {
        var composition = LottieComposition.Factory.fromFileSync(context, "Tests/StartEndFrame.json")
        var view = LottieAnimationView(context)
        view.setComposition(composition!!)
        val params = ViewGroup.LayoutParams(
                ViewGroup.LayoutParams.WRAP_CONTENT, ViewGroup.LayoutParams.WRAP_CONTENT)
        view.setMinProgress(0f)
        view.progress = 0f
        recordSnapshot(view, 1080, "android", "MinMaxFrame", "minProgress 0", params)
        view.setMinProgress(0.25f)
        view.progress = 0f
        recordSnapshot(view, 1080, "android", "MinMaxFrame", "minProgress 0.25", params)
        view.setMinProgress(0.75f)
        view.progress = 0f
        recordSnapshot(view, 1080, "android", "MinMaxFrame", "minProgress 0.75", params)
        view.setMinProgress(1f)
        view.progress = 0f
        recordSnapshot(view, 1080, "android", "MinMaxFrame", "minProgress 1", params)

        view.setMaxProgress(0f)
        view.progress = 1f
        recordSnapshot(view, 1080, "android", "MinMaxFrame", "maxProgress 0", params)
        view.setMaxProgress(0.25f)
        view.progress = 1f
        recordSnapshot(view, 1080, "android", "MinMaxFrame", "maxProgress 0.25", params)
        view.setMaxProgress(0.75f)
        view.progress = 1f
        recordSnapshot(view, 1080, "android", "MinMaxFrame", "maxProgress 0.75", params)
        view.setMaxProgress(1f)
        view.progress = 1f
        recordSnapshot(view, 1080, "android", "MinMaxFrame", "maxProgress 1", params)

        composition = LottieComposition.Factory.fromFileSync(context, "Tests/EndFrame.json")
        view = LottieAnimationView(context)
        view.setComposition(composition!!)
        view.frame = 29
        recordSnapshot(view, 1080, "android", "EndFrame", "End Frame (red)", params)
        view.frame = 30
        recordSnapshot(view, 1080, "android", "EndFrame", "End Frame (blue)", params)

    }

    private fun testUrl() {
        val composition = LottieCompositionFactory.fromUrlSync(context, "https://www.lottiefiles.com/download/427").value ?: return
        drawComposition(composition, "GiftBox from LottieFiles URL (427)")
    }

    private fun dpToPx(dp: Int): Int {
        val resources = context.resources
        return TypedValue.applyDimension(1, dp.toFloat(), resources.displayMetrics).toInt()
    }

    private fun clearBitmap() {
        renderCanvas.drawRect(0f, 0f, renderBitmap.width.toFloat(), renderBitmap.height.toFloat(), clearPaint)
    }

    companion object {
        private val CORES = 1 //Runtime.getRuntime().availableProcessors();
    }
}