// Copyright 2020 The Fuchsia Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

use {
    anyhow::Error,
    argh::FromArgs,
    carnelian::{
        color::Color,
        drawing::{load_font, FontFace, GlyphMap, Text},
        geometry::Corners,
        input::{self},
        input_ext::TouchEventResampler,
        make_app_assistant,
        render::*,
        App, AppAssistant, Point, RenderOptions, Size, ViewAssistant, ViewAssistantContext,
        ViewAssistantPtr, ViewKey,
    },
    euclid::{
        default::{Rect, Vector2D},
        point2, size2, vec2,
    },
    fuchsia_trace::{self, counter, duration},
    fuchsia_trace_provider,
    fuchsia_zircon::{self as zx, AsHandleRef, Event, Signals, Time},
    lazy_static::lazy_static,
    lipsum::{lipsum_title, lipsum_words},
    rand::{thread_rng, Rng},
    std::{
        collections::{BTreeMap, VecDeque},
        f32,
        path::PathBuf,
    },
};

const BACKGROUND_COLOR: Color = Color { r: 255, g: 255, b: 255, a: 255 };

// Clamp scroll offset to this range for sanity.
const SCROLL_OFFSET_RANGE: [u32; 2] = [0, 1000000];

// Delay before starting to simulate scrolling.
const FAKE_SCROLL_DELAY_SECONDS: i64 = 10;

// Available scrolling methods.
#[derive(Copy, Clone, Debug)]
enum ScrollMethod {
    Redraw,
    CopyRedraw,
    SlidingOffset,
    MotionBlur,
}

impl std::str::FromStr for ScrollMethod {
    type Err = String;

    fn from_str(s: &str) -> Result<Self, Self::Err> {
        match s {
            "Redraw" => Ok(Self::Redraw),
            "CopyRedraw" => Ok(Self::CopyRedraw),
            "SlidingOffset" => Ok(Self::SlidingOffset),
            "MotionBlur" => Ok(Self::MotionBlur),
            _ => Err(format!("'{}' is not a valid value for ScrollMethod", s)),
        }
    }
}

lazy_static! {
    pub static ref FONT_FACE: FontFace =
        load_font(PathBuf::from("/pkg/data/fonts/RobotoSlab-Regular.ttf"))
            .expect("Failed to create font");
}

/// Infinite scroll.
#[derive(Clone, Debug, FromArgs)]
#[argh(name = "infinite_scroll_rs")]
struct Args {
    /// use spinel (GPU rendering back-end)
    #[argh(switch, short = 's')]
    use_spinel: bool,

    /// contents scale (default scale is 1.0)
    #[argh(option, default = "1.0")]
    scale: f32,

    /// scrolling method (Redraw|CopyRedraw|SlidingOffset|MotionBlur)
    #[argh(option, default = "ScrollMethod::Redraw")]
    scroll_method: ScrollMethod,

    /// motion blur exposure time
    #[argh(option, default = "1.0")]
    exposure: f32,

    /// touch sampling offset (relative to presentation time)
    #[argh(option, default = "38")]
    touch_sampling_offset_ms: i64,

    /// maximum number of columns
    #[argh(option, default = "std::u32::MAX")]
    max_columns: u32,

    /// disable text (improves rendering performance)
    #[argh(switch)]
    disable_text: bool,
}

#[derive(Default)]
struct InfiniteScrollAppAssistant {
    args: Option<Args>,
}

impl AppAssistant for InfiniteScrollAppAssistant {
    fn setup(&mut self) -> Result<(), Error> {
        let args: Args = argh::from_env();
        println!("back-end: {}", if args.use_spinel { "spinel" } else { "mold" });
        println!("scale: {}", args.scale);
        println!("scroll method: {:?}", args.scroll_method);
        match args.scroll_method {
            ScrollMethod::MotionBlur => {
                println!("exposure: {}", args.exposure);
            }
            _ => {}
        }
        println!("touch sampling offset: {} ms", args.touch_sampling_offset_ms);
        self.args = Some(args);
        Ok(())
    }

    fn create_view_assistant(&mut self, _: ViewKey) -> Result<ViewAssistantPtr, Error> {
        Ok(Box::new(InfiniteScrollViewAssistant::new(
            self.args.clone().expect("AppAssistant::setup not run"),
        )))
    }

    fn get_render_options(&self) -> RenderOptions {
        RenderOptions {
            use_spinel: self.args.as_ref().map(|args| args.use_spinel).unwrap_or_default(),
        }
    }
}

struct Box2D {
    min: Point,
    max: Point,
}

impl Box2D {
    fn new() -> Self {
        Box2D {
            min: point2(std::f32::MAX, std::f32::MAX),
            max: point2(std::f32::MIN, std::f32::MIN),
        }
    }

    fn union(&self, point: &Point) -> Self {
        Box2D {
            min: point2(self.min.x.min(point.x), self.min.y.min(point.y)),
            max: point2(self.max.x.max(point.x), self.max.y.max(point.y)),
        }
    }

    fn to_rect(&self) -> Rect<f32> {
        Rect { origin: self.min, size: (self.max - self.min).to_size() }
    }
}

fn lerp(t: f32, p0: Point, p1: Point) -> Point {
    point2(p0.x * (1.0 - t) + p1.x * t, p0.y * (1.0 - t) + p1.y * t)
}

fn cubic(
    path_builder: &mut PathBuilder,
    p0: Point,
    p1: Point,
    p2: Point,
    p3: Point,
    bounding_box: &mut Box2D,
) {
    duration!("gfx", "cubic");

    path_builder.move_to(p0);
    path_builder.cubic_to(p1, p2, p3);

    // Sub-divide curve to determine bounding box.

    let deviation_x = (p0.x + p2.x - 3.0 * (p1.x + p2.x)).abs();
    let deviation_y = (p0.y + p2.y - 3.0 * (p1.y + p2.y)).abs();
    let deviation_squared = deviation_x * deviation_x + deviation_y * deviation_y;

    const PIXEL_ACCURACY: f32 = 0.25;
    if deviation_squared < PIXEL_ACCURACY {
        *bounding_box = bounding_box.union(&p0).union(&p3);
        return;
    }

    const TOLERANCE: f32 = 3.0;
    let subdivisions = 1 + (TOLERANCE * deviation_squared).sqrt().sqrt().floor() as usize;
    let increment = (subdivisions as f32).recip();
    let mut t = 0.0;

    *bounding_box = bounding_box.union(&p0);
    for _ in 0..subdivisions - 1 {
        t += increment;
        let p_next = lerp(
            t,
            lerp(t, lerp(t, p0, p1), lerp(t, p1, p2)),
            lerp(t, lerp(t, p1, p2), lerp(t, p2, p3)),
        );
        *bounding_box = bounding_box.union(&p_next);
    }
    *bounding_box = bounding_box.union(&p3);
}

struct Flower {
    raster: Raster,
    bounding_box: Rect<f32>,
}

impl Flower {
    fn new(context: &mut Context, petal_count: usize, r1: f32, r2: f32) -> Self {
        duration!("gfx", "Flower::new");

        let mut bounding_box = Box2D::new();
        let mut path_builder = context.path_builder().unwrap();
        let mut rng = thread_rng();
        let u: f32 = rng.gen_range(10.0, 100.0) / 100.0;
        let v: f32 = rng.gen_range(0.0, 90.0) / 100.0;
        let dt: f32 = f32::consts::PI / (petal_count as f32);
        let mut t: f32 = 0.0;

        let mut p0 = point2(t.cos() * r1, t.sin() * r1);
        for _ in 0..petal_count {
            let x1 = t.cos() * r1;
            let y1 = t.sin() * r1;
            let x2 = (t + dt).cos() * r2;
            let y2 = (t + dt).sin() * r2;
            let x3 = (t + 2.0 * dt).cos() * r1;
            let y3 = (t + 2.0 * dt).sin() * r1;

            let p1 = point2(x1 - y1 * u, y1 + x1 * u);
            let p2 = point2(x2 + y2 * v, y2 - x2 * v);
            let p3 = point2(x2, y2);
            let p4 = point2(x2 - y2 * v, y2 + x2 * v);
            let p5 = point2(x3 + y3 * u, y3 - x3 * u);
            let p6 = point2(x3, y3);

            cubic(&mut path_builder, p0, p1, p2, p3, &mut bounding_box);
            cubic(&mut path_builder, p3, p4, p5, p6, &mut bounding_box);

            p0 = p6;
            t += dt * 2.0;
        }

        let mut raster_builder = context.raster_builder().unwrap();
        raster_builder.add(&path_builder.build(), None);

        Self { raster: raster_builder.build(), bounding_box: bounding_box.to_rect() }
    }
}

fn random_color_element() -> u8 {
    let mut rng = thread_rng();
    let c: u8 = rng.gen_range(0, 255);
    c
}

fn random_color() -> Color {
    Color {
        r: random_color_element(),
        g: random_color_element(),
        b: random_color_element(),
        a: 255,
    }
}

const ITEM_TYPE_TITLE: i32 = 0;
const ITEM_TYPE_BODY_MIN: i32 = 1;
const ITEM_TYPE_BODY_MAX: i32 = 3;
const ITEM_TYPE_FLOWER: i32 = 4;
const ITEM_TYPE_COUNT: i32 = 5;

struct Item {
    raster: Raster,
    bounding_box: Rect<f32>,
    bounding_box_raster: Raster,
    color: Color,
    id: i32,
}

struct Scene {
    scale: f32,
    exposure: f32,
    max_columns: u32,
    text_disabled: bool,
    scroll_offset_y: u32,
    last_scroll_offset_y: u32,
    title_glyphs: GlyphMap,
    body_glyphs: GlyphMap,
    columns: Vec<VecDeque<Item>>,
    total_items: usize,
}

impl Scene {
    fn new(scale: f32, exposure: f32, max_columns: u32, text_disabled: bool) -> Self {
        // Equal amount of coordinate space above and below.
        let scroll_offset_y = (SCROLL_OFFSET_RANGE[0] + SCROLL_OFFSET_RANGE[1]) / 2;

        Self {
            scale,
            exposure,
            max_columns,
            text_disabled,
            scroll_offset_y,
            last_scroll_offset_y: scroll_offset_y,
            title_glyphs: GlyphMap::new(),
            body_glyphs: GlyphMap::new(),
            columns: Vec::new(),
            total_items: 0,
        }
    }

    fn new_item(
        context: &mut Context,
        offset: Vector2D<i32>,
        align_bottom: bool,
        scale: f32,
        title_glyphs: &mut GlyphMap,
        body_glyphs: &mut GlyphMap,
        id: i32,
        column_width: f32,
        text_disabled: bool,
    ) -> Item {
        let item_type =
            if text_disabled { ITEM_TYPE_FLOWER } else { id.rem_euclid(ITEM_TYPE_COUNT) };
        // Alternate between title, body, and flower shape.
        let (raster, bounding_box, x, color) = match item_type {
            ITEM_TYPE_TITLE => {
                const TITLE_SIZE: f32 = 32.0;

                let size = TITLE_SIZE * scale;
                let wrap = column_width;
                let title = lipsum_title();
                let text = Text::new(context, &title, size, wrap, &FONT_FACE, title_glyphs);

                (text.raster, text.bounding_box.round_out(), 0, Color { r: 0, g: 0, b: 0, a: 255 })
            }
            ITEM_TYPE_BODY_MIN..=ITEM_TYPE_BODY_MAX => {
                const BODY_SIZE: f32 = 20.0;
                const BODY_MIN_WORDS: usize = 25;
                const BODY_MAX_WORDS: usize = 100;

                let size = BODY_SIZE * scale;
                let wrap = column_width;
                let mut rng = thread_rng();
                let body = lipsum_words(rng.gen_range(BODY_MIN_WORDS, BODY_MAX_WORDS));
                let text = Text::new(context, &body, size, wrap, &FONT_FACE, body_glyphs);

                (text.raster, text.bounding_box.round_out(), 0, Color { r: 0, g: 0, b: 0, a: 255 })
            }
            ITEM_TYPE_FLOWER => {
                const FLOWER_MIN_PETALS: usize = 3;
                const FLOWER_MAX_PETALS: usize = 8;
                const FLOWER_MIN_R1: f32 = 60.0;
                const FLOWER_MAX_R1: f32 = 95.0;
                const FLOWER_MIN_R2: f32 = 20.0;
                const FLOWER_MAX_R2: f32 = 60.0;

                let mut rng = thread_rng();
                let petal_count: usize = rng.gen_range(FLOWER_MIN_PETALS, FLOWER_MAX_PETALS);
                let r1: f32 = rng.gen_range(FLOWER_MIN_R1, FLOWER_MAX_R1) * scale;
                let r2: f32 = rng.gen_range(FLOWER_MIN_R2, FLOWER_MAX_R2) * scale;
                let flower = Flower::new(context, petal_count, r1, r2);
                let x = column_width as i32 / 2;
                let bounding_box = flower.bounding_box.round_out();

                (flower.raster, bounding_box.round_out(), x, random_color())
            }
            _ => unreachable!(),
        };

        // Create a bounding box raster that can be used for efficient clearing.
        let mut path_builder = context.path_builder().unwrap();
        path_builder.move_to(bounding_box.origin);
        path_builder.line_to(bounding_box.top_right());
        path_builder.line_to(bounding_box.bottom_right());
        path_builder.line_to(bounding_box.bottom_left());
        path_builder.line_to(bounding_box.origin);
        let mut raster_builder = context.raster_builder().unwrap();
        raster_builder.add(&path_builder.build(), None);
        let bounding_box_raster = raster_builder.build();

        let y = if align_bottom { -bounding_box.size.height } else { 0.0 };
        let offset = offset + vec2(x, (y - bounding_box.min_y()) as i32);

        Item {
            raster: raster.translate(offset),
            bounding_box: bounding_box.translate(offset.to_f32()),
            bounding_box_raster: bounding_box_raster.translate(offset),
            color,
            id,
        }
    }

    fn update(&mut self, context: &mut Context, size: &Size, scroll_delta: i32) {
        counter!("gfx", "scroll_dy", 0, "dy" => scroll_delta.abs());

        let new_offset = self.scroll_offset_y as i32 + scroll_delta;
        self.last_scroll_offset_y = self.scroll_offset_y;
        self.scroll_offset_y =
            new_offset.max(SCROLL_OFFSET_RANGE[0] as i32).min(SCROLL_OFFSET_RANGE[1] as i32) as u32;
        let top = self.scroll_offset_y as f32;

        const COLUMN_SIZE: f32 = 400.0;
        const PADDING: f32 = 50.0;
        const MIN_MARGIN: f32 = 50.0;
        const DISCARD_EXTRA_DISTANCE: f32 = 2048.0;

        let column_size = (COLUMN_SIZE * self.scale) as usize;
        let padding = PADDING * self.scale;
        let min_margin = (MIN_MARGIN * self.scale) as usize;
        let width = size.width as usize;
        let column_count = ((width - min_margin * 2) / (column_size + min_margin))
            .min(self.max_columns as usize)
            .max(1);
        let margin = (width - column_count * column_size) / (column_count + 1);

        if column_count != self.columns.len() {
            self.columns = (0..column_count).map(|_| VecDeque::new()).collect();
        }

        // Skip random number of body items.
        fn get_id_step(id: i32, base: i32) -> i32 {
            if id.rem_euclid(ITEM_TYPE_COUNT) == base {
                let mut rng = thread_rng();
                rng.gen_range(1, (ITEM_TYPE_BODY_MAX - ITEM_TYPE_BODY_MIN) + 1)
            } else {
                1
            }
        }

        // Discard distance needs to be at least height for clearing. Extra distance
        // avoids unnecessary work by keeping items around that are likely to become
        // visible again. This improves performance at the cost of increased memory
        // usage.
        let discard_distance = size.height + DISCARD_EXTRA_DISTANCE;

        self.total_items = 0;
        for (i, column) in self.columns.iter_mut().enumerate() {
            let margin = margin + (column_size + margin) * i;

            // Remove items at the bottom of column that are no longer visible and
            // outside discard distance.
            while !column.is_empty()
                && (column.back().unwrap().bounding_box.min_y() - top)
                    > (size.height + discard_distance)
            {
                column.pop_back();
            }

            // Remove items at the top of column that are no longer visible and
            // outside discard distance.
            while !column.is_empty()
                && (column.front().unwrap().bounding_box.max_y() - top) < -discard_distance
            {
                column.pop_front();
            }

            // Add new items at the bottom of column to fill visible region.
            while column.is_empty()
                || (column.back().unwrap().bounding_box.max_y() - top + padding) < size.height
            {
                let (id, y) = if let Some(item) = column.back() {
                    (item.id + get_id_step(item.id, ITEM_TYPE_BODY_MIN), item.bounding_box.max_y())
                } else {
                    (0, top)
                };
                column.push_back(Self::new_item(
                    context,
                    vec2(margin as i32, (y + padding) as i32),
                    false,
                    self.scale,
                    &mut self.title_glyphs,
                    &mut self.body_glyphs,
                    id,
                    column_size as f32,
                    self.text_disabled,
                ));
            }

            // Add new items at the top of column to fill visible region.
            while column.is_empty()
                || (column.front().unwrap().bounding_box.min_y() - top - padding) > 0.0
            {
                let (id, y) = if let Some(item) = column.front() {
                    (item.id - get_id_step(item.id, ITEM_TYPE_BODY_MAX), item.bounding_box.min_y())
                } else {
                    (0, top + size.height as f32)
                };
                column.push_front(Self::new_item(
                    context,
                    vec2(margin as i32, (y - padding) as i32),
                    true,
                    self.scale,
                    &mut self.title_glyphs,
                    &mut self.body_glyphs,
                    id,
                    column_size as f32,
                    self.text_disabled,
                ));
            }

            self.total_items += column.len();
        }
    }

    fn prepend_clear_layers_to_composition(
        &self,
        composition: &mut Composition,
        viewport: &Rect<f32>,
        ty: i32,
    ) {
        let layers = self
            .columns
            .iter()
            .flat_map(|column| column.iter())
            .filter(|item| viewport.intersects(&item.bounding_box))
            .map(|item| Layer {
                raster: item.bounding_box_raster.clone().translate(vec2(0, ty)),
                style: Style {
                    fill_rule: FillRule::WholeTile,
                    fill: Fill::Solid(BACKGROUND_COLOR),
                    blend_mode: BlendMode::Over,
                },
            });

        composition.replace(..0, layers);
    }

    fn prepend_layers_to_composition(
        &self,
        composition: &mut Composition,
        viewport: &Rect<f32>,
        ty: i32,
    ) {
        let layers = self
            .columns
            .iter()
            .flat_map(|column| column.iter())
            .filter(|item| viewport.intersects(&item.bounding_box))
            .map(|item| Layer {
                raster: item.raster.clone().translate(vec2(0, ty)),
                style: Style {
                    fill_rule: FillRule::NonZero,
                    fill: Fill::Solid(item.color),
                    blend_mode: BlendMode::Over,
                },
            });

        composition.replace(..0, layers);
    }
}

struct Contents {
    image: Image,
    scroll_method: ScrollMethod,
    scroll_offset_y: u32,
    size: Size,
    composition: Composition,
}

impl Contents {
    fn new(image: Image, scroll_method: ScrollMethod) -> Self {
        let composition = Composition::new(BACKGROUND_COLOR);

        Self { image, scroll_method, scroll_offset_y: 0, size: Size::zero(), composition }
    }

    fn update(
        &mut self,
        context: &mut Context,
        scene: &mut Scene,
        size: &Size,
        staging_image: &mut Option<Image>,
    ) {
        let width = size.width.floor() as u32;
        let height = size.height.floor() as u32;

        let mut ext = if self.size != *size {
            RenderExt {
                pre_clear: Some(PreClear { color: BACKGROUND_COLOR }),
                ..Default::default()
            }
        } else {
            RenderExt::default()
        };

        match self.scroll_method {
            // Method 1: Translate paths and redraw the whole scene each frame.
            ScrollMethod::Redraw => {
                self.composition.clear();

                // Add clear layers for previous viewport.
                let viewport = Rect::new(
                    point2(0.0, self.scroll_offset_y as f32),
                    size2(width as f32, height as f32),
                );
                scene.prepend_clear_layers_to_composition(
                    &mut self.composition,
                    &viewport,
                    -(self.scroll_offset_y as i32),
                );

                // Add layers for current viewport.
                let viewport = Rect::new(
                    point2(0.0, scene.scroll_offset_y as f32),
                    size2(width as f32, height as f32),
                );
                scene.prepend_layers_to_composition(
                    &mut self.composition,
                    &viewport,
                    -(scene.scroll_offset_y as i32),
                );

                // Render scene.
                context.render(&self.composition, None, self.image, &ext);
            }
            // Method 2: Copy the image area that is still visible and redraw exposed region.
            ScrollMethod::CopyRedraw => {
                let scroll_distance = scene.scroll_offset_y as f32 - self.scroll_offset_y as f32;
                let scroll_amount = scroll_distance.abs() as u32;
                // |scroll_height| is the area that can be copied and doesn't need to a redraw.
                let scroll_height = if self.size == *size {
                    // Round down to multiple of 32. This ensures that we can use the render clip
                    // to redraw the exposed region.
                    (height - scroll_amount.min(height)) & !31
                } else {
                    0
                };
                let mut clip = Rect::new(point2(0, 0), size2(width, height));
                // Determine area to copy and clip to render depending on scroll direction.
                if scroll_height > 0 {
                    match scroll_distance {
                        // Area at top exposed.
                        x if x > 0.0 => {
                            clip.origin.y = scroll_height;
                            clip.size.height = height - scroll_height;
                            ext.pre_copy = Some(PreCopy {
                                image: self.image,
                                copy_region: CopyRegion {
                                    src_offset: point2(0, scroll_amount),
                                    dst_offset: point2(0, 0),
                                    extent: size2(width, height - scroll_amount),
                                },
                            });
                        }
                        // Area at bottom exposed.
                        x if x < 0.0 => {
                            clip.origin.y = 0;
                            clip.size.height = height - scroll_height;
                            ext.pre_copy = Some(PreCopy {
                                image: self.image,
                                copy_region: CopyRegion {
                                    src_offset: point2(0, 0),
                                    dst_offset: point2(0, scroll_amount),
                                    extent: size2(width, height - scroll_amount),
                                },
                            });
                        }
                        // No new contents exposed.
                        _ => {
                            clip.size.height = 0;
                        }
                    }
                }

                self.composition.clear();

                // Add clear layers for previous viewport of clip.
                let viewport = Rect::new(
                    point2(
                        clip.origin.x as f32,
                        clip.origin.y as f32 + self.scroll_offset_y as f32,
                    ),
                    size2(clip.size.width as f32, clip.size.height as f32),
                );
                scene.prepend_clear_layers_to_composition(
                    &mut self.composition,
                    &viewport,
                    -(self.scroll_offset_y as i32),
                );

                // Add layers for current viewport of clip.
                let viewport = Rect::new(
                    point2(
                        clip.origin.x as f32,
                        clip.origin.y as f32 + scene.scroll_offset_y as f32,
                    ),
                    size2(clip.size.width as f32, clip.size.height as f32),
                );
                scene.prepend_layers_to_composition(
                    &mut self.composition,
                    &viewport,
                    -(scene.scroll_offset_y as i32),
                );

                // Render clip.
                context.render(&self.composition, Some(clip), self.image, &ext);
            }
            // Method 3: Allocate temporary buffer and use a sliding offset to minimize
            // redraw. Contents of temporary buffer is copied to image after rendering.
            // Method 4: Sliding offset method with motion blur effect.
            ScrollMethod::SlidingOffset | ScrollMethod::MotionBlur => {
                // Add 32 and round temporary buffer height up to multiple of 32 in order
                // to be able to use the render clip.
                let buffer_height = (height + 63) & !31;
                let top = scene.scroll_offset_y;
                let bottom = scene.scroll_offset_y + height;
                let next_y0 = top % buffer_height;
                let next_y1 = bottom % buffer_height;
                let scroll_distance =
                    scene.scroll_offset_y as i32 - scene.last_scroll_offset_y as i32;
                let scroll_amount = scroll_distance.abs();

                // Damage is the full area by default.
                let mut damage_y0 = next_y0;
                let mut damage_y1 = next_y1;
                let mut clear_offset = 0;

                // Determine smaller damage area based on scroll direction.
                if self.size == *size && scroll_amount < height as i32 {
                    if scroll_distance >= 0 {
                        damage_y0 = (bottom - scroll_amount as u32) % buffer_height;
                        damage_y1 = bottom % buffer_height;
                        clear_offset = -(buffer_height as i32);
                    } else {
                        damage_y0 = top % buffer_height;
                        damage_y1 = (top + scroll_amount as u32) % buffer_height;
                        clear_offset = buffer_height as i32;
                    }
                }

                // Convert upper bound to height instead of 0.
                if damage_y1 == 0 {
                    damage_y1 = buffer_height;
                }

                // Compute top/bottom spans. We end up with both a top and
                // bottom span if damage wraps around.
                let mut top_y0 = damage_y0;
                let mut top_y1 = damage_y1;
                let mut bottom_y0 = damage_y1;
                let mut bottom_y1 = damage_y1;
                if damage_y0 > damage_y1 {
                    top_y0 = 0;
                    top_y1 = damage_y1;
                    bottom_y0 = damage_y0;
                    bottom_y1 = buffer_height;
                }

                // Round to multiple of 32. This ensures that we can use the
                // render clip to redraw the exposed region.
                top_y0 = top_y0 & !31;
                top_y1 = (top_y1 + 31) & !31;
                if bottom_y0 < bottom_y1 {
                    bottom_y0 = bottom_y0 & !31;
                    bottom_y1 = (bottom_y1 + 31) & !31;
                }

                let image = staging_image
                    .take()
                    .unwrap_or_else(|| context.new_image(size2(width, buffer_height)));

                // Offset in staging image that translate to top of output.
                let y_start = next_y0;
                // Offsets that needs to be applied to contents in order to
                // render at the correct location in staging image.
                let mut dy = (top / buffer_height) * buffer_height;

                // Render bottom span if needed.
                if bottom_y0 < bottom_y1 {
                    let mut composition = Composition::new(BACKGROUND_COLOR);
                    let clip = Rect::new(point2(0, bottom_y0), size2(width, bottom_y1 - bottom_y0));

                    // Add layers for previous viewport of bottom clip.
                    let viewport = Rect::new(
                        point2(0.0, (clip.origin.y + dy) as f32 + clear_offset as f32),
                        clip.size.to_f32(),
                    );
                    scene.prepend_clear_layers_to_composition(
                        &mut composition,
                        &viewport,
                        -(dy as i32 + clear_offset as i32),
                    );

                    // Add layers for current viewport of bottom clip.
                    let viewport =
                        Rect::new(point2(0.0, (clip.origin.y + dy) as f32), clip.size.to_f32());
                    scene.prepend_layers_to_composition(&mut composition, &viewport, -(dy as i32));

                    // Render bottom clip.
                    context.render(&composition, Some(clip), image, &ext);

                    ext.pre_clear = None;
                }

                // Offset contents of top span if it is below top of output.
                if top_y1 <= y_start {
                    dy += buffer_height;
                }

                // Determine exposure if motion blur mode is used.
                let exposure = match self.scroll_method {
                    ScrollMethod::MotionBlur => {
                        (scroll_distance as f32 * scene.exposure).round() as i32
                    }
                    _ => 0,
                };

                // Copy temporary buffer to output image and apply motion blur.
                ext.post_copy = Some(PostCopy {
                    image: self.image,
                    color: BACKGROUND_COLOR,
                    exposure_distance: vec2(0, exposure),
                    copy_region: CopyRegion {
                        src_offset: point2(0, y_start),
                        dst_offset: point2(0, 0),
                        extent: size2(width, height),
                    },
                });

                let mut composition = Composition::new(BACKGROUND_COLOR);
                let clip = Rect::new(point2(0, top_y0), size2(width, top_y1 - top_y0));

                // Add layers for previous viewport of top clip.
                let viewport = Rect::new(
                    point2(0.0, (clip.origin.y + dy) as f32 + clear_offset as f32),
                    clip.size.to_f32(),
                );
                scene.prepend_clear_layers_to_composition(
                    &mut composition,
                    &viewport,
                    -(dy as i32 + clear_offset as i32),
                );

                // Add layers for current viewport of top clip.
                let viewport =
                    Rect::new(point2(0.0, (clip.origin.y + dy) as f32), clip.size.to_f32());
                scene.prepend_layers_to_composition(&mut composition, &viewport, -(dy as i32));

                // Render top clip.
                context.render(&composition, Some(clip), image, &ext);

                staging_image.replace(image);
            }
        }

        self.size = *size;
        self.scroll_offset_y = scene.scroll_offset_y;
    }
}

struct FlingCurve {
    curve_duration: f32,
    start_timestamp: Time,
    displacement_ratio: Vector2D<f32>,
    cumulative_scroll: Vector2D<f32>,
    previous_timestamp: Time,
    time_offset: f32,
    position_offset: f32,
}

// Alpha-beta-gamma filter constants taken from the Chromium project.
// These constants come from UX experiments.
const ALPHA: f32 = -5.70762e+03;
const BETA: f32 = 1.72e+02;
const GAMMA: f32 = 3.7e+00;

impl FlingCurve {
    fn get_position_at_time(t: f32) -> f32 {
        ALPHA * (-GAMMA * t).exp() - BETA * t - ALPHA
    }

    fn get_velocity_at_time(t: f32) -> f32 {
        -ALPHA * GAMMA * (-GAMMA * t).exp() - BETA
    }

    fn get_time_at_velocity(v: f32) -> f32 {
        -((v + BETA) / (-ALPHA * GAMMA)).ln() / GAMMA
    }

    fn new(velocity: Vector2D<f32>, start_timestamp: Time) -> Self {
        let max_start_velocity =
            velocity.x.abs().max(velocity.y.abs()).min(Self::get_velocity_at_time(0.0));
        assert!(max_start_velocity > 0.0);
        let displacement_ratio = velocity / max_start_velocity;
        let time_offset = Self::get_time_at_velocity(max_start_velocity);
        let position_offset = Self::get_position_at_time(time_offset);
        let curve_duration = Self::get_time_at_velocity(0.0);

        FlingCurve {
            curve_duration,
            start_timestamp,
            displacement_ratio,
            cumulative_scroll: Vector2D::zero(),
            previous_timestamp: start_timestamp,
            time_offset,
            position_offset,
        }
    }

    fn compute_scroll_offset(&mut self, timestamp: Time) -> (bool, Vector2D<f32>, Vector2D<f32>) {
        let elapsed_time = timestamp - self.start_timestamp;
        if elapsed_time < zx::Duration::from_nanos(0) {
            return (true, Vector2D::zero(), Vector2D::zero());
        }

        const SECONDS_PER_NANOSECOND: f32 = 1e-9;

        let offset_time =
            elapsed_time.into_nanos() as f32 * SECONDS_PER_NANOSECOND + self.time_offset;
        let (still_active, scalar_offset, scalar_velocity) = if offset_time < self.curve_duration {
            (
                true,
                Self::get_position_at_time(offset_time) - self.position_offset,
                Self::get_velocity_at_time(offset_time),
            )
        } else {
            (false, Self::get_position_at_time(self.curve_duration) - self.position_offset, 0.0)
        };

        (
            still_active,
            self.displacement_ratio * scalar_offset,
            self.displacement_ratio * scalar_velocity,
        )
    }

    fn compute_scroll_delta_at_time(&mut self, current: Time) -> (bool, Vector2D<f32>) {
        if current <= self.previous_timestamp {
            (true, Vector2D::zero())
        } else {
            self.previous_timestamp = current;
            let (still_active, offset, _) = self.compute_scroll_offset(current);
            let delta = offset - self.cumulative_scroll;
            self.cumulative_scroll = offset;
            (still_active, delta)
        }
    }
}

struct InfiniteScroll {
    scroll_method: ScrollMethod,
    touch_sampling_offset: zx::Duration,
    scene: Scene,
    contents: BTreeMap<u64, Contents>,
    last_presentation_time: Time,
    touch_event_resampler: TouchEventResampler,
    touch_points: Vec<Point>,
    touch_time: Time,
    previous_touch_points: Vec<Point>,
    scroll_origin: Vector2D<f32>,
    fling_curve: Option<FlingCurve>,
    fake_scroll_start: Time,
    fake_scroll_velocity: Option<f32>,
    staging_image: Option<Image>,
}

impl InfiniteScroll {
    pub fn new(
        scale: f32,
        scroll_method: ScrollMethod,
        exposure: f32,
        touch_sampling_offset: zx::Duration,
        max_columns: u32,
        text_disabled: bool,
    ) -> Self {
        let scene = Scene::new(scale, exposure, max_columns, text_disabled);
        let fake_scroll_start =
            Time::from_nanos(Time::get_monotonic().into_nanos().saturating_add(
                zx::Duration::from_seconds(FAKE_SCROLL_DELAY_SECONDS).into_nanos(),
            ));

        Self {
            scroll_method,
            touch_sampling_offset,
            scene,
            contents: BTreeMap::new(),
            last_presentation_time: Time::get_monotonic(),
            touch_event_resampler: TouchEventResampler::new(),
            touch_points: Vec::new(),
            touch_time: Time::from_nanos(0),
            previous_touch_points: Vec::new(),
            scroll_origin: Vector2D::zero(),
            fling_curve: None,
            fake_scroll_start,
            fake_scroll_velocity: None,
            staging_image: None,
        }
    }

    fn update(
        &mut self,
        render_context: &mut Context,
        context: &ViewAssistantContext,
    ) -> Result<(), Error> {
        duration!("gfx", "InfiniteScrollViewAssistant::update");

        let size = &context.size;
        let presentation_time = context.presentation_time;
        let elapsed = presentation_time - self.last_presentation_time;
        let scroll_method = self.scroll_method;

        // Scroll distance is set by input processing code below.
        let mut scroll_distance = None;

        // Process touch events.
        //
        // Smooth motion is achieved by re-sampling touch events at
        // a fixed offset relative to presentation time.
        //
        // Determine sample time by removing sampling offset from
        // presentation time.
        let sample_time = presentation_time - self.touch_sampling_offset;

        fn average(points: &Vec<Point>) -> Vector2D<f32> {
            points.iter().fold(Vector2D::zero(), |sum, x| sum + x.to_vector()) / points.len() as f32
        }

        let events = self.touch_event_resampler.dequeue_and_sample(sample_time);
        for event in events {
            if let input::EventType::Touch(touch_event) = event.event_type {
                // Save previous touch state.
                self.previous_touch_points.clear();
                self.previous_touch_points.extend(self.touch_points.drain(..));
                // Update touch points and origin. Origin is the average of
                // all touch points.
                for contact in touch_event.contacts.iter() {
                    match contact.phase {
                        input::touch::Phase::Down(point, _) => {
                            self.touch_points.push(point.to_f32())
                        }
                        input::touch::Phase::Moved(point, _) => {
                            self.touch_points.push(point.to_f32())
                        }
                        _ => {}
                    }
                }
                counter!("input", "touch_y", 0, "y" => (average(&self.touch_points)).y.round() as u32);

                // Ignore previous touch points and set scroll origin if number of
                // touch points changed.
                if self.previous_touch_points.len() != self.touch_points.len() {
                    self.scroll_origin = average(&self.touch_points);
                    self.previous_touch_points.clear();
                }
            }
        }

        if !self.touch_points.is_empty() && !self.previous_touch_points.is_empty() {
            let origin = average(&self.touch_points);
            let touch_latency = presentation_time - self.touch_time;
            // Print a warning if touch sampling offset is too low for
            // accurate touch point sampling.
            if touch_latency > self.touch_sampling_offset {
                println!(
                    "warning: high touch latency {:?} ms",
                    touch_latency.into_nanos() as f32 / 1e+6
                );
            }
            scroll_distance = Some(-(origin.y - self.scroll_origin.y));

            // Delay the start of fake scrolling.
            self.fake_scroll_start =
                Time::from_nanos(presentation_time.into_nanos().saturating_add(
                    zx::Duration::from_seconds(FAKE_SCROLL_DELAY_SECONDS).into_nanos(),
                ));
            self.fake_scroll_velocity = None;
        }

        const SECONDS_PER_NANOSECOND: f32 = 1e-9;

        // Fake scroll when idle.
        if presentation_time.into_nanos() > self.fake_scroll_start.into_nanos() {
            const MIN_FAKE_SPEED: f32 = 2048.0;
            const MAX_FAKE_SPEED: f32 = 8192.0;
            const FAKE_DIRECTIONS: [f32; 2] = [1.0, -1.0];

            let fake_scroll_velocity = self.fake_scroll_velocity.get_or_insert_with(|| {
                let mut rng = thread_rng();
                let speed: f32 = rng.gen_range(MIN_FAKE_SPEED, MAX_FAKE_SPEED);
                let direction: usize = rng.gen_range(0, FAKE_DIRECTIONS.len());
                speed * FAKE_DIRECTIONS[direction]
            });

            const ACCELERATION: f32 = 12000.0;
            let elapsed_seconds = (presentation_time.into_nanos()
                - self.fake_scroll_start.into_nanos()) as f32
                * SECONDS_PER_NANOSECOND;
            let velocity = (ACCELERATION * elapsed_seconds).min(fake_scroll_velocity.abs())
                * fake_scroll_velocity.signum();

            scroll_distance =
                Some(velocity * (elapsed.into_nanos() as f32 * SECONDS_PER_NANOSECOND));

            // Fake scroll last for one second. Add small delay before next
            // fake scroll starts.
            if elapsed_seconds > 1.0 {
                const NEXT_FAKE_SCROLL_DELAY_SECONDS: i64 = 2;
                self.fake_scroll_start =
                    Time::from_nanos(presentation_time.into_nanos().saturating_add(
                        zx::Duration::from_seconds(NEXT_FAKE_SCROLL_DELAY_SECONDS).into_nanos(),
                    ));
                self.fake_scroll_velocity = None;
            }
        }

        // Calculate scroll delta based on scroll distance and update fling
        // curve. If scroll distance is not set then allow fling curve to
        // determine scroll delta.
        let mut scroll_delta = 0;
        if let Some(distance) = scroll_distance {
            scroll_delta = distance.round() as i32;
            self.scroll_origin.y -= scroll_delta as f32;
            if distance != 0.0 && elapsed.into_nanos() > 0 {
                let velocity = distance / (elapsed.into_nanos() as f32 * SECONDS_PER_NANOSECOND);
                self.fling_curve = Some(FlingCurve::new(vec2(0.0, velocity), presentation_time));
            }
        } else if let Some(fling) = &mut self.fling_curve {
            let (fling_active, delta) = fling.compute_scroll_delta_at_time(presentation_time);
            scroll_delta = delta.y as i32;
            if !fling_active {
                self.fling_curve = None;
            }
        }

        // Update the scene using our scroll delta.
        self.scene.update(render_context, size, scroll_delta);

        let image_id = context.image_id;
        let image = render_context.get_current_image(context);
        let content =
            self.contents.entry(image_id).or_insert_with(|| Contents::new(image, scroll_method));

        content.update(render_context, &mut self.scene, size, &mut self.staging_image);

        self.last_presentation_time = presentation_time;

        Ok(())
    }

    fn handle_pointer_event(&mut self, event: &input::Event) {
        self.touch_event_resampler.enqueue(event.clone());
        if let input::EventType::Touch(_) = &event.event_type {
            self.touch_time = Time::from_nanos(event.event_time as i64);
        }
    }
}

struct InfiniteScrollViewAssistant {
    size: Size,
    args: Args,
    infinite_scroll: Option<InfiniteScroll>,
}

impl InfiniteScrollViewAssistant {
    pub fn new(args: Args) -> Self {
        Self { size: Size::zero(), args, infinite_scroll: None }
    }
}

impl ViewAssistant for InfiniteScrollViewAssistant {
    fn render(
        &mut self,
        render_context: &mut Context,
        ready_event: Event,
        context: &ViewAssistantContext,
    ) -> Result<(), Error> {
        if context.size != self.size || self.infinite_scroll.is_none() {
            let infinite_scroll = InfiniteScroll::new(
                self.args.scale,
                self.args.scroll_method,
                self.args.exposure,
                zx::Duration::from_millis(self.args.touch_sampling_offset_ms),
                self.args.max_columns,
                self.args.disable_text,
            );

            self.size = context.size;
            self.infinite_scroll = Some(infinite_scroll);
        }

        if let Some(infinite_scroll) = self.infinite_scroll.as_mut() {
            infinite_scroll.update(render_context, context).expect("infinite_scroll.update");
        }

        ready_event.as_handle_ref().signal(Signals::NONE, Signals::EVENT_SIGNALED)?;

        context.request_render();

        Ok(())
    }

    fn handle_pointer_event(
        &mut self,
        _context: &mut ViewAssistantContext,
        event: &input::Event,
        _pointer_event: &input::pointer::Event,
    ) -> Result<(), Error> {
        if let Some(infinite_scroll) = self.infinite_scroll.as_mut() {
            infinite_scroll.handle_pointer_event(event);
        }
        Ok(())
    }
}

fn main() -> Result<(), Error> {
    fuchsia_trace_provider::trace_provider_create_with_fdio();

    println!("Infinite Scroll Example");
    App::run(make_app_assistant::<InfiniteScrollAppAssistant>())
}