// Forked/repurposed from `font-rs` code: https://github.com/raphlinus/font-rs
// Copyright 2015 Google Inc. All rights reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//
// Modifications copyright (C) 2020 Alex Butler
//
// Cubic bezier drawing adapted from stb_truetype: https://github.com/nothings/stb
#[cfg(all(feature = "libm", not(feature = "std")))]
use crate::nostd_float::FloatExt;
#[cfg(not(feature = "std"))]
use alloc::vec::Vec;

use crate::geometry::{lerp, Point};

type DrawLineFn = unsafe fn(&mut Rasterizer, Point, Point);

/// Coverage rasterizer for lines, quadratic & cubic beziers.
pub struct Rasterizer {
    width: usize,
    height: usize,
    a: Vec<f32>,
    draw_line_fn: DrawLineFn,
}

impl Rasterizer {
    /// Allocates a new rasterizer that can draw onto a `width` x `height` alpha grid.
    ///
    /// ```
    /// use ab_glyph_rasterizer::Rasterizer;
    /// let mut rasterizer = Rasterizer::new(14, 38);
    /// ```
    pub fn new(width: usize, height: usize) -> Self {
        Self {
            width,
            height,
            a: vec![0.0; width * height + 4],
            draw_line_fn: optimal_draw_line_fn(),
        }
    }

    /// Resets the rasterizer to an empty `width` x `height` alpha grid. This method behaves as if
    /// the Rasterizer were re-created, with the advantage of not allocating if the total number of
    /// pixels of the grid does not increase.
    ///
    /// ```
    /// # use ab_glyph_rasterizer::Rasterizer;
    /// # let mut rasterizer = Rasterizer::new(14, 38);
    /// rasterizer.reset(12, 24);
    /// assert_eq!(rasterizer.dimensions(), (12, 24));
    /// ```
    pub fn reset(&mut self, width: usize, height: usize) {
        self.width = width;
        self.height = height;
        self.a.truncate(0);
        self.a.resize(width * height + 4, 0.0);
    }

    /// Clears the rasterizer. This method behaves as if the Rasterizer were re-created with the same
    /// dimensions, but does not perform an allocation.
    ///
    /// ```
    /// # use ab_glyph_rasterizer::Rasterizer;
    /// # let mut rasterizer = Rasterizer::new(14, 38);
    /// rasterizer.clear();
    /// ```
    pub fn clear(&mut self) {
        for px in &mut self.a {
            *px = 0.0;
        }
    }

    /// Returns the dimensions the rasterizer was built to draw to.
    ///
    /// ```
    /// # use ab_glyph_rasterizer::*;
    /// let rasterizer = Rasterizer::new(9, 8);
    /// assert_eq!((9, 8), rasterizer.dimensions());
    /// ```
    pub fn dimensions(&self) -> (usize, usize) {
        (self.width, self.height)
    }

    /// Adds a straight line from `p0` to `p1` to the outline.
    ///
    /// ```
    /// # use ab_glyph_rasterizer::*;
    /// # let mut rasterizer = Rasterizer::new(9, 8);
    /// rasterizer.draw_line(point(0.0, 0.48), point(1.22, 0.48));
    /// ```
    pub fn draw_line(&mut self, p0: Point, p1: Point) {
        unsafe { (self.draw_line_fn)(self, p0, p1) }
    }

    #[inline(always)] // must inline for simd versions
    fn draw_line_scalar(&mut self, p0: Point, p1: Point) {
        if (p0.y - p1.y).abs() <= core::f32::EPSILON {
            return;
        }
        let (dir, p0, p1) = if p0.y < p1.y {
            (1.0, p0, p1)
        } else {
            (-1.0, p1, p0)
        };
        let dxdy = (p1.x - p0.x) / (p1.y - p0.y);
        let mut x = p0.x;
        let y0 = p0.y as usize; // note: implicit max of 0 because usize
        if p0.y < 0.0 {
            x -= p0.y * dxdy;
        }
        for y in y0..self.height.min(p1.y.ceil() as usize) {
            let linestart = y * self.width;
            let dy = ((y + 1) as f32).min(p1.y) - (y as f32).max(p0.y);
            let xnext = x + dxdy * dy;
            let d = dy * dir;
            let (x0, x1) = if x < xnext { (x, xnext) } else { (xnext, x) };
            let x0floor = x0.floor();
            let x0i = x0floor as i32;
            let x1ceil = x1.ceil();
            let x1i = x1ceil as i32;
            if x1i <= x0i + 1 {
                let xmf = 0.5 * (x + xnext) - x0floor;
                let linestart_x0i = linestart as isize + x0i as isize;
                if linestart_x0i < 0 {
                    continue; // oob index
                }
                self.a[linestart_x0i as usize] += d - d * xmf;
                self.a[linestart_x0i as usize + 1] += d * xmf;
            } else {
                let s = (x1 - x0).recip();
                let x0f = x0 - x0floor;
                let a0 = 0.5 * s * (1.0 - x0f) * (1.0 - x0f);
                let x1f = x1 - x1ceil + 1.0;
                let am = 0.5 * s * x1f * x1f;
                let linestart_x0i = linestart as isize + x0i as isize;
                if linestart_x0i < 0 {
                    continue; // oob index
                }
                self.a[linestart_x0i as usize] += d * a0;
                if x1i == x0i + 2 {
                    self.a[linestart_x0i as usize + 1] += d * (1.0 - a0 - am);
                } else {
                    let a1 = s * (1.5 - x0f);
                    self.a[linestart_x0i as usize + 1] += d * (a1 - a0);
                    for xi in x0i + 2..x1i - 1 {
                        self.a[linestart + xi as usize] += d * s;
                    }
                    let a2 = a1 + (x1i - x0i - 3) as f32 * s;
                    self.a[linestart + (x1i - 1) as usize] += d * (1.0 - a2 - am);
                }
                self.a[linestart + x1i as usize] += d * am;
            }
            x = xnext;
        }
    }

    /// Adds a quadratic Bézier curve from `p0` to `p2` to the outline using `p1` as the control.
    ///
    /// ```
    /// # use ab_glyph_rasterizer::*;
    /// # let mut rasterizer = Rasterizer::new(14, 38);
    /// rasterizer.draw_quad(point(6.2, 34.5), point(7.2, 34.5), point(9.2, 34.0));
    /// ```
    pub fn draw_quad(&mut self, p0: Point, p1: Point, p2: Point) {
        let devx = p0.x - 2.0 * p1.x + p2.x;
        let devy = p0.y - 2.0 * p1.y + p2.y;
        let devsq = devx * devx + devy * devy;
        if devsq < 0.333 {
            self.draw_line(p0, p2);
            return;
        }
        let tol = 3.0;
        let n = 1 + (tol * devsq).sqrt().sqrt().floor() as usize;
        let mut p = p0;
        let nrecip = (n as f32).recip();
        let mut t = 0.0;
        for _i in 0..n - 1 {
            t += nrecip;
            let pn = lerp(t, lerp(t, p0, p1), lerp(t, p1, p2));
            self.draw_line(p, pn);
            p = pn;
        }
        self.draw_line(p, p2);
    }

    /// Adds a cubic Bézier curve from `p0` to `p3` to the outline using `p1` as the control
    /// at the beginning of the curve and `p2` at the end of the curve.
    ///
    /// ```
    /// # use ab_glyph_rasterizer::*;
    /// # let mut rasterizer = Rasterizer::new(12, 20);
    /// rasterizer.draw_cubic(
    ///     point(10.3, 16.4),
    ///     point(8.6, 16.9),
    ///     point(7.7, 16.5),
    ///     point(8.2, 15.2),
    /// );
    /// ```
    pub fn draw_cubic(&mut self, p0: Point, p1: Point, p2: Point, p3: Point) {
        self.tesselate_cubic(p0, p1, p2, p3, 0);
    }

    // stb_truetype style cubic approximation by lines.
    fn tesselate_cubic(&mut self, p0: Point, p1: Point, p2: Point, p3: Point, n: u8) {
        // ...I'm not sure either ¯\_(ツ)_/¯
        const OBJSPACE_FLATNESS: f32 = 0.35;
        const OBJSPACE_FLATNESS_SQUARED: f32 = OBJSPACE_FLATNESS * OBJSPACE_FLATNESS;
        const MAX_RECURSION_DEPTH: u8 = 16;

        let longlen = p0.distance_to(p1) + p1.distance_to(p2) + p2.distance_to(p3);
        let shortlen = p0.distance_to(p3);
        let flatness_squared = longlen * longlen - shortlen * shortlen;

        if n < MAX_RECURSION_DEPTH && flatness_squared > OBJSPACE_FLATNESS_SQUARED {
            let p01 = lerp(0.5, p0, p1);
            let p12 = lerp(0.5, p1, p2);
            let p23 = lerp(0.5, p2, p3);

            let pa = lerp(0.5, p01, p12);
            let pb = lerp(0.5, p12, p23);

            let mp = lerp(0.5, pa, pb);

            self.tesselate_cubic(p0, p01, pa, mp, n + 1);
            self.tesselate_cubic(mp, pb, p23, p3, n + 1);
        } else {
            self.draw_line(p0, p3);
        }
    }

    /// Run a callback for each pixel `index` & `alpha`, with indices in `0..width * height`.
    ///
    /// An `alpha` coverage value of `0.0` means the pixel is not covered at all by the glyph,
    /// whereas a value of `1.0` (or greater) means the pixel is totally covered.
    ///
    /// ```
    /// # use ab_glyph_rasterizer::*;
    /// # let (width, height) = (1, 1);
    /// # let mut rasterizer = Rasterizer::new(width, height);
    /// let mut pixels = vec![0u8; width * height];
    /// rasterizer.for_each_pixel(|index, alpha| {
    ///     pixels[index] = (alpha * 255.0) as u8;
    /// });
    /// ```
    pub fn for_each_pixel<O: FnMut(usize, f32)>(&self, mut px_fn: O) {
        let mut acc = 0.0;
        self.a[..self.width * self.height]
            .iter()
            .enumerate()
            .for_each(|(idx, c)| {
                acc += c;
                px_fn(idx, acc.abs());
            });
    }

    /// Run a callback for each pixel x position, y position & alpha.
    ///
    /// Convenience wrapper for [`Rasterizer::for_each_pixel`].
    ///
    /// ```
    /// # use ab_glyph_rasterizer::*;
    /// # let mut rasterizer = Rasterizer::new(1, 1);
    /// # struct Img;
    /// # impl Img { fn set_pixel(&self, x: u32, y: u32, a: u8) {} }
    /// # let image = Img;
    /// rasterizer.for_each_pixel_2d(|x, y, alpha| {
    ///     image.set_pixel(x, y, (alpha * 255.0) as u8);
    /// });
    /// ```
    pub fn for_each_pixel_2d<O: FnMut(u32, u32, f32)>(&self, mut px_fn: O) {
        let width32 = self.width as u32;
        self.for_each_pixel(|idx, alpha| px_fn(idx as u32 % width32, idx as u32 / width32, alpha));
    }
}

/// ```
/// let rasterizer = ab_glyph_rasterizer::Rasterizer::new(3, 4);
/// assert_eq!(
///     &format!("{:?}", rasterizer),
///     "Rasterizer { width: 3, height: 4 }"
/// );
/// ```
impl core::fmt::Debug for Rasterizer {
    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
        f.debug_struct("Rasterizer")
            .field("width", &self.width)
            .field("height", &self.height)
            .finish()
    }
}

#[cfg(all(feature = "std", any(target_arch = "x86", target_arch = "x86_64")))]
#[target_feature(enable = "avx2")]
unsafe fn draw_line_avx2(rast: &mut Rasterizer, p0: Point, p1: Point) {
    rast.draw_line_scalar(p0, p1)
}

#[cfg(all(feature = "std", any(target_arch = "x86", target_arch = "x86_64")))]
#[target_feature(enable = "sse4.2")]
unsafe fn draw_line_sse4_2(rast: &mut Rasterizer, p0: Point, p1: Point) {
    rast.draw_line_scalar(p0, p1)
}

/// Return most optimal `DrawLineFn` impl.
///
/// With feature `std` on x86/x86_64 will use one-time runtime detection
/// to pick the best SIMD impl. Otherwise uses a scalar version.
fn optimal_draw_line_fn() -> DrawLineFn {
    unsafe {
        // safe as write synchronised by Once::call_once or no-write
        static mut DRAW_LINE_FN: DrawLineFn = Rasterizer::draw_line_scalar;

        #[cfg(all(feature = "std", any(target_arch = "x86", target_arch = "x86_64")))]
        {
            static INIT: std::sync::Once = std::sync::Once::new();
            INIT.call_once(|| {
                // runtime detect optimal simd impls
                if is_x86_feature_detected!("avx2") {
                    DRAW_LINE_FN = draw_line_avx2
                } else if is_x86_feature_detected!("sse4.2") {
                    DRAW_LINE_FN = draw_line_sse4_2
                }
            });
        }

        DRAW_LINE_FN
    }
}