/**
 * Represents a command in an SVG path.
 */
sealed interface SvgPathCommand {
    /**
     * The end point of each SVG command
     */
    val p: Point

    /**
     * Represents a "Line To" command in an SVG path.
     * Draws a line from the current point to the given point.
     *
     * @property p The target point.
     */
    data class LineTo(override val p: Point) : SvgPathCommand

    /**
     * Represents a "Curve To" command in an SVG path.
     * Draws a cubic Bézier curve from the current point to the given point using two control points.
     *
     * @property p1 The first control point.
     * @property p2 The second control point.
     * @property p The target point.
     */
    data class CurveTo(
        val p1: Point,
        val p2: Point,
        override val p: Point,
    ) : SvgPathCommand

    /**
     * Represents a "Smooth Curve To" command in an SVG path.
     * Draws a cubic Bézier curve from the current point to the given point using one control point.
     *
     * @property p2 The control point.
     * @property p The target point.
     */
    data class SmoothCurveTo(val p2: Point, override val p: Point) : SvgPathCommand
}

@Composable
fun AirbnbLogo(
    modifier: Modifier = Modifier,
    color: Color = AirbnbLogo.COLOR_RAUSCH,
) {
    Canvas(
        modifier = modifier
            .fillMaxSize()
            .aspectRatio(LOGO_VECTOR_WIDTH / LOGO_VECTOR_HEIGHT)
    ) {
        val xScale = size.width / LOGO_VECTOR_WIDTH
        val yScale = size.height / LOGO_VECTOR_HEIGHT
        val path = svgCommandsToPath(xScale, yScale, AIRBNB_LOGO_PATH_COMMANDS)
        drawPath(path = path, color = color, style = Fill)
    }
}

interface Point {
    val x: Float
    val y: Float
}

fun Point(x: Float, y: Float) : Point = SinglePoint(x = x, y = y)

data class SinglePoint(
    override val x: Float,
    override val y: Float
) : Point

/** A point that takes 2 separate points and outputs their average */
data class PairPoint(
    val x1: Float,
    val y1: Float,
    val x2: Float,
    val y2: Float,
) : Point {
    override val x: Float = (x1 + x2) / 2f
    override val y: Float = (y1 + y2) / 2f
}

internal data class VectorNode(
    /** The first control point for the node */
    val cp1: Point,
    /** The second control point for the node */
    val cp2: Point,
    /** The end point we are drawing to for the node */
    val p: Point,
    /**
     * If true this is a point that will be drawn on again.
     */
    val isIntersection: Boolean = false,
)

fun calculateDistance(node1: VectorNode, node2: VectorNode): Float {
    return sqrt((node2.p.x - node1.p.x).pow(2) + (node2.p.y - node1.p.y).pow(2))
}

private fun Path.partialCubicBezier(
    start: Offset,
    c1: Offset,
    c2: Offset,
    end: Offset,
    drawPercent: Float,
): Offset {
    // Calculate intermediate points using De Casteljau's algorithm
    val partialControl1 = linearInterpolation(start, c1, drawPercent)
    val p1_1 = linearInterpolation(c1, c2, drawPercent)
    val p2_1 = linearInterpolation(c2, end, drawPercent)

    val partialControl2 = linearInterpolation(partialControl1, p1_1, drawPercent)
    val p1_2 = linearInterpolation(p1_1, p2_1, drawPercent)

    val partialEnd = linearInterpolation(partialControl2, p1_2, drawPercent)

    // Draw the cubic Bézier curve segment
    cubicTo(
        partialControl1.x, partialControl1.y,
        partialControl2.x, partialControl2.y,
        partialEnd.x, partialEnd.y,
    )

    return Offset(partialEnd.x, partialEnd.y)
}

private fun linearInterpolation(a: Offset, b: Offset, t: Float): Offset {
    return Offset(
        x = (1 - t) * a.x + t * b.x,
        y = (1 - t) * a.y + t * b.y
    )
}

private fun drawVectorNodes(
    canvas: Canvas,
    xScale: Float,
    yScale: Float,
    nodes: List<VectorNode>,
    distanceToDraw: Float,
    color: Color,
    strokeWidth: Float,
) {
    val path = Path()

    // The last node we were drawing
    var lastNode: VectorNode = nodes.first()
    // The total distance we've drawn.
    var distanceDrawn = 0f

    // Start at the location right before the first command
    path.moveTo(lastNode.p.x * xScale, lastNode.p.y * yScale)

    // Reset the paint
    val paint = Paint().apply {
        isAntiAlias = true
        style = PaintingStyle.Stroke
        this.strokeWidth = strokeWidth
        this.color = color
    }

    for (i in 1 ..< nodes.size) {
        val node: VectorNode = nodes[i]

        val nodeDistance = calculateDistance(lastNode, node)
        // Percent of line to the node to draw
        val nodeDrawPercent: Float = if (nodeDistance < (distanceToDraw - distanceDrawn)) {
            1f
        } else {
            if (distanceDrawn >= distanceToDraw) {
                // This can happen when the drawPercent is 0
                break
            }
            ((distanceToDraw - distanceDrawn) / nodeDistance).coerceAtMost(1f)
        }

        val c1: Point = lastNode.cp1
        val c2: Point = node.cp2
        val end: Point = node.p

        if (nodeDrawPercent == 1f) {
            val endX = end.x * xScale
            val endY = end.y * yScale
            path.cubicTo(
                c1.x * xScale, c1.y * yScale,
                c2.x * xScale, c2.y * yScale,
                endX, endY,
            )
            Offset(endX, endY)
        } else {
            // Use De Casteljau's Algorithm to animate to a partial point
            path.partialCubicBezier(
                Offset(lastNode.p.x * xScale, lastNode.p.y * yScale),
                Offset(c1.x * xScale, c1.y * yScale),
                Offset(c2.x * xScale, c2.y * yScale),
                Offset(end.x * xScale, end.y * yScale),
                nodeDrawPercent,
            )
        }

        lastNode = node
        distanceDrawn += nodeDistance
    }

    canvas.drawPath(path = path, paint)
}

@Composable
fun AirbnbLogo(
    modifier: Modifier = Modifier,
    color: Color = AirbnbLogo.COLOR_RAUSCH,
    delayMillis: Int = 0,
) {
    var targetDrawPercent: Float by remember { mutableFloatStateOf(0f) }

    val drawPercent: Float by animateFloatAsState(
        targetValue = targetDrawPercent,
        animationSpec = tween(1200, easing = EaseOut, delayMillis = delayMillis),
        label = "Draw Percent",
    )

    LaunchedEffect(Unit) {
        delay(300)
        // Trigger the animation to 1f
        targetDrawPercent = 1f
    }

    Canvas(
        modifier = modifier
            .fillMaxSize()
            .aspectRatio(LOGO_VECTOR_WIDTH / LOGO_VECTOR_HEIGHT)
    ) {
        drawAirbnbLogo(color, drawPercent)
    }
}

private fun DrawScope.drawAirbnbLogo(color: Color, drawPercent: Float) {
    val xScale = size.width / LOGO_VECTOR_WIDTH
    val yScale = size.height / LOGO_VECTOR_HEIGHT

    val scaledStrokeWidth = min(xScale, yScale) * STROKE_WIDTH

    drawIntoCanvas { canvas ->
        drawVectorNodes(
            canvas = canvas,
            xScale = xScale,
            yScale = yScale,
            side = DrawSide.LEFT,
            distanceToDraw = drawPercent * DrawSide.LEFT.distance,
            color = color,
            strokeWidth = scaledStrokeWidth
        )
    }
}

internal enum class DrawSide(
    val distance: Float,
    val nodes: List<VectorNode>,
) {
    LEFT(
        distance = 5817.2754f,
        nodes = AIRBNB_LOGO_LEFT_SIDE,
    ),
    RIGHT(
        distance = 2758.3904f,
        nodes = AIRBNB_LOGO_RIGHT_SIDE.asReversed(),
    ),
}

private fun DrawScope.drawAirbnbLogo(color: Color, drawPercent: Float) {
    val xScale = size.width / LOGO_VECTOR_WIDTH
    val yScale = size.height / LOGO_VECTOR_HEIGHT

    val scaledStrokeWidth = min(xScale, yScale) * STROKE_WIDTH

    drawIntoCanvas { canvas ->
        drawVectorNodes(
            canvas = canvas,
            xScale = xScale,
            yScale = yScale,
            side = DrawSide.LEFT,
            distanceToDraw = drawPercent * DrawSide.LEFT.distance,
            color = color,
            strokeWidth = scaledStrokeWidth
        )

        drawVectorNodes(
            canvas = canvas,
            xScale = xScale,
            yScale = yScale,
            side = DrawSide.RIGHT,
            distanceToDraw = drawPercent * DrawSide.RIGHT.distance,
            color = color,
            strokeWidth = scaledStrokeWidth,
        )
    }
}

@Composable
fun MultiColorAirbnbLogo(
    modifier: Modifier = Modifier,
) {
    Box(
        modifier = modifier
    ) {
        AirbnbLogo(
            modifier = Modifier.fillMaxSize(),
        )
        AirbnbLogo(
            modifier = Modifier.fillMaxSize(),
            color = Color(0xFF6FC8EE),
            delayMillis = 500,
        )
        AirbnbLogo(
            modifier = Modifier.fillMaxSize(),
            color = Color(0xFFF4D45A),
            delayMillis = 800,
        )
        AirbnbLogo(
            modifier = Modifier.fillMaxSize(),
            delayMillis = 1200,
        )
    }
}