use gpui::prelude::FluentBuilder;
use gpui::{
    AbsoluteLength, AnyElement, App, Bounds, Div, Hsla, ImageSource, InteractiveElement,
    Interactivity, IntoElement, ObjectFit, ParentElement, PathBuilder, Pixels, Point, RenderOnce,
    SharedString, StyleRefinement, Styled, StyledImage, Window, canvas, div, img, point, px,
};
use theme::ActiveTheme;

use crate::{Selectable, Sizable, Size, StyledExt};

/// Number of rows and columns in the generated pixel grid.
const PIXEL_GRID: usize = 8;
/// Empty cells kept between the pattern and the avatar edge.
const MARGIN: usize = 1;
/// Probability that a cell in the left half of the pattern area is filled.
const FILL_PROBABILITY: f32 = 0.42;
/// Probability that a filled cell uses the accent shade instead of the main color.
const ACCENT_PROBABILITY: f32 = 0.25;
/// Minimum number of filled left-half cells, so a pattern never reads as empty.
const MIN_FILLED: usize = 5;
/// Fallback seed for an avatar that has neither a picture nor a seed of its own.
const FALLBACK_SEED: &str = "coop";
/// Number of segments used to approximate the avatar circle.
const CIRCLE_SEGMENTS: usize = 32;

/// Returns the size of the avatar based on the given [`Size`].
pub(super) fn avatar_size(size: Size) -> AbsoluteLength {
    match size {
        Size::Large => px(64.).into(),
        Size::Medium => px(32.).into(),
        Size::Small => px(24.).into(),
        Size::XSmall => px(18.).into(),
        Size::Size(size) => size.into(),
    }
}

/// A deterministic, offline pixel-art avatar derived from a seed.
#[derive(IntoElement)]
pub(crate) struct PixelAvatar {
    seed: u64,
    size: Size,
    style: StyleRefinement,
}

impl PixelAvatar {
    /// Creates a pixel avatar from `seed`.
    pub fn new(seed: impl AsRef<str>) -> Self {
        Self {
            seed: fnv1a(seed.as_ref().as_bytes()),
            size: Size::Medium,
            style: StyleRefinement::default(),
        }
    }
}

impl Sizable for PixelAvatar {
    fn with_size(mut self, size: impl Into<Size>) -> Self {
        self.size = size.into();
        self
    }
}

impl Styled for PixelAvatar {
    fn style(&mut self) -> &mut StyleRefinement {
        &mut self.style
    }
}

impl RenderOnce for PixelAvatar {
    fn render(self, window: &mut Window, _cx: &mut App) -> impl IntoElement {
        let side = avatar_size(self.size).to_pixels(window.rem_size());
        let seed = self.seed;

        canvas(
            move |_bounds, _window, _cx| seed,
            move |bounds, seed, window, cx| {
                let theme = cx.theme();
                let main = Hsla {
                    h: seed as f32 / u64::MAX as f32,
                    s: 0.6,
                    l: if theme.is_dark() { 0.6 } else { 0.45 },
                    a: 1.,
                };
                let shade = if theme.is_dark() {
                    Hsla {
                        l: (main.l * 1.6).min(0.95),
                        ..main
                    }
                } else {
                    Hsla {
                        l: (main.l * 0.45).max(0.18),
                        ..main
                    }
                };

                let circle = circle_polygon(bounds.center(), bounds.size.width.as_f32() / 2.);
                paint_polygons(window, std::iter::once(&circle), main.opacity(0.16));

                let pattern = pixel_pattern(seed);
                let mut cells = Vec::new();

                for (value, color) in [(1u8, main), (2u8, shade)] {
                    cells.clear();

                    for row in 0..PIXEL_GRID {
                        for col in 0..PIXEL_GRID {
                            if pattern[row * PIXEL_GRID + col] != value {
                                continue;
                            }

                            let cell = clip_polygon(&cell_polygon(&bounds, row, col), &circle);
                            if cell.len() >= 3 {
                                cells.push(cell);
                            }
                        }
                    }

                    paint_polygons(window, cells.iter(), color);
                }
            },
        )
        .refine_style(&self.style)
        .size(side)
        .flex_shrink_0()
    }
}

/// Builds the mirrored fill pattern for `seed`.
fn pixel_pattern(seed: u64) -> [u8; PIXEL_GRID * PIXEL_GRID] {
    let mut rng = PixelRng::new(seed);
    let mut pattern = [0u8; PIXEL_GRID * PIXEL_GRID];
    let mut filled = 0usize;

    let art_rows = PIXEL_GRID - 2 * MARGIN;
    let art_columns = PIXEL_GRID / 2 - MARGIN;

    for row in MARGIN..PIXEL_GRID - MARGIN {
        for col in MARGIN..PIXEL_GRID / 2 {
            if rng.chance(FILL_PROBABILITY) {
                let accent = rng.chance(ACCENT_PROBABILITY);
                set_cell(&mut pattern, row, col, if accent { 2 } else { 1 });
                filled += 1;
            }
        }
    }

    if filled < MIN_FILLED {
        let total = art_rows * art_columns;
        let start = (rng.next() % total as u64) as usize;

        for offset in 0..total {
            if filled >= MIN_FILLED {
                break;
            }

            let ix = (start + offset) % total;
            let row = MARGIN + ix / art_columns;
            let col = MARGIN + ix % art_columns;

            if pattern[row * PIXEL_GRID + col] == 0 {
                set_cell(&mut pattern, row, col, 1);
                filled += 1;
            }
        }
    }

    pattern
}

/// Paints `polygons` as a single anti-aliased filled path in `color`.
fn paint_polygons<'a>(
    window: &mut Window,
    polygons: impl IntoIterator<Item = &'a Vec<Point<Pixels>>>,
    color: Hsla,
) {
    let mut builder = PathBuilder::fill();
    let mut painted = false;

    for polygon in polygons {
        if polygon.len() >= 3 {
            builder.add_polygon(polygon, true);
            painted = true;
        }
    }

    if painted && let Ok(path) = builder.build() {
        window.paint_path(path, color);
    }
}

/// Approximates the circle of `radius` around `center` as a convex polygon,
/// wound so that its interior is on the left of every directed edge.
fn circle_polygon(center: Point<Pixels>, radius: f32) -> Vec<Point<Pixels>> {
    let center_x = center.x.as_f32();
    let center_y = center.y.as_f32();

    (0..CIRCLE_SEGMENTS)
        .map(|index| {
            let angle = std::f32::consts::TAU * index as f32 / CIRCLE_SEGMENTS as f32;
            point(
                px(center_x + radius * angle.cos()),
                px(center_y + radius * angle.sin()),
            )
        })
        .collect()
}

/// The four corners of cell `(row, col)` of the grid laid out in `bounds`.
fn cell_polygon(bounds: &Bounds<Pixels>, row: usize, col: usize) -> [Point<Pixels>; 4] {
    let cell = bounds.size.width.as_f32() / PIXEL_GRID as f32;
    let left = bounds.origin.x.as_f32() + col as f32 * cell;
    let top = bounds.origin.y.as_f32() + row as f32 * cell;

    [
        point(px(left), px(top)),
        point(px(left + cell), px(top)),
        point(px(left + cell), px(top + cell)),
        point(px(left), px(top + cell)),
    ]
}

/// Clips `subject` to the convex `clip` polygon, keeping the part inside it.
fn clip_polygon(subject: &[Point<Pixels>], clip: &[Point<Pixels>]) -> Vec<Point<Pixels>> {
    let mut current = subject.to_vec();
    let mut next = Vec::with_capacity(subject.len() + 4);

    for (&start, &end) in clip.iter().zip(clip.iter().cycle().skip(1)) {
        if current.is_empty() {
            break;
        }

        next.clear();
        let mut previous = match current.last() {
            Some(&vertex) => vertex,
            None => break,
        };

        for &vertex in current.iter() {
            let previous_inside = is_inside(start, end, previous);
            let vertex_inside = is_inside(start, end, vertex);

            if vertex_inside {
                if !previous_inside
                    && let Some(crossing) = line_intersection(start, end, previous, vertex)
                {
                    next.push(crossing);
                }
                next.push(vertex);
            } else if previous_inside
                && let Some(crossing) = line_intersection(start, end, previous, vertex)
            {
                next.push(crossing);
            }

            previous = vertex;
        }

        std::mem::swap(&mut current, &mut next);
    }

    current
}

/// Whether `vertex` lies on the interior side of the directed edge `start -> end`.
fn is_inside(start: Point<Pixels>, end: Point<Pixels>, vertex: Point<Pixels>) -> bool {
    let start_x = start.x.as_f32();
    let start_y = start.y.as_f32();
    let edge_x = end.x.as_f32() - start_x;
    let edge_y = end.y.as_f32() - start_y;
    let to_vertex_x = vertex.x.as_f32() - start_x;
    let to_vertex_y = vertex.y.as_f32() - start_y;

    edge_x * to_vertex_y - edge_y * to_vertex_x >= 0.
}

/// The intersection of segment `from -> to` with the infinite line `start -> end`.
fn line_intersection(
    start: Point<Pixels>,
    end: Point<Pixels>,
    from: Point<Pixels>,
    to: Point<Pixels>,
) -> Option<Point<Pixels>> {
    let start_x = start.x.as_f32();
    let start_y = start.y.as_f32();
    let edge_x = end.x.as_f32() - start_x;
    let edge_y = end.y.as_f32() - start_y;
    let from_x = from.x.as_f32();
    let from_y = from.y.as_f32();
    let segment_x = to.x.as_f32() - from_x;
    let segment_y = to.y.as_f32() - from_y;
    let denominator = edge_x * segment_y - edge_y * segment_x;

    if denominator.abs() < f32::EPSILON {
        return None;
    }

    let offset_x = from_x - start_x;
    let offset_y = from_y - start_y;
    let t = (edge_y * offset_x - edge_x * offset_y) / denominator;

    Some(point(
        px(from_x + segment_x * t),
        px(from_y + segment_y * t),
    ))
}

/// Fills `cell (row, col)` and its horizontal mirror.
fn set_cell(pattern: &mut [u8; PIXEL_GRID * PIXEL_GRID], row: usize, col: usize, value: u8) {
    pattern[row * PIXEL_GRID + col] = value;
    pattern[row * PIXEL_GRID + (PIXEL_GRID - 1 - col)] = value;
}

/// FNV-1a 64-bit hash, stable across platforms and runs.
fn fnv1a(bytes: &[u8]) -> u64 {
    let mut hash = 0xcbf2_9ce4_8422_2325u64;
    for &byte in bytes {
        hash ^= byte as u64;
        hash = hash.wrapping_mul(0x0000_0100_0000_01b3);
    }
    hash
}

/// Tiny xorshift64* PRNG for deriving the pattern from the seed.
struct PixelRng(u64);

impl PixelRng {
    fn new(seed: u64) -> Self {
        Self(seed.max(1))
    }

    fn next(&mut self) -> u64 {
        let mut x = self.0;
        x ^= x >> 12;
        x ^= x << 25;
        x ^= x >> 27;
        self.0 = x;
        x.wrapping_mul(0x2545_f491_4f6c_dd1d)
    }

    fn chance(&mut self, probability: f32) -> bool {
        self.next() as f32 / (u64::MAX as f32) < probability
    }
}

/// Renders the generated pixel avatar shown in place of a missing picture.
fn generated_avatar(seed: Option<&str>, size: Pixels) -> AnyElement {
    PixelAvatar::new(seed.unwrap_or(FALLBACK_SEED))
        .with_size(size)
        .into_any_element()
}

/// An element that renders a user avatar with customizable appearance options.
#[derive(IntoElement)]
pub struct Avatar {
    base: Div,
    picture: Option<ImageSource>,
    grayscale: bool,
    seed: Option<String>,
    style: StyleRefinement,
    size: Size,
    border_color: Option<Hsla>,
    selected: bool,
}

impl Avatar {
    /// Creates an avatar for an entity whose profile picture may be missing.
    pub fn new(picture: Option<SharedString>) -> Self {
        Self::from_source(picture)
    }

    /// Creates an avatar from an already-resolved source, which may be missing.
    pub fn from_source(picture: Option<impl Into<ImageSource>>) -> Self {
        Self::from_picture(picture.map(Into::into))
    }

    fn from_picture(picture: Option<ImageSource>) -> Self {
        Avatar {
            base: div(),
            picture,
            grayscale: false,
            seed: None,
            style: StyleRefinement::default(),
            size: Size::Medium,
            border_color: None,
            selected: false,
        }
    }

    /// Sets the seed for the generated pixel avatar.
    pub fn seed(mut self, seed: impl Into<String>) -> Self {
        self.seed = Some(seed.into());
        self
    }

    /// Applies a grayscale filter to the avatar image.
    pub fn grayscale(mut self, grayscale: bool) -> Self {
        self.grayscale = grayscale;
        self
    }

    /// Sets the border color of the avatar.
    pub fn border_color(mut self, color: impl Into<Hsla>) -> Self {
        self.border_color = Some(color.into());
        self
    }
}

impl Sizable for Avatar {
    fn with_size(mut self, size: impl Into<Size>) -> Self {
        self.size = size.into();
        self
    }
}

impl Styled for Avatar {
    fn style(&mut self) -> &mut StyleRefinement {
        &mut self.style
    }
}

impl Selectable for Avatar {
    fn is_selected(&self) -> bool {
        self.selected
    }

    fn selected(mut self, selected: bool) -> Self {
        self.selected = selected;
        self
    }
}

impl InteractiveElement for Avatar {
    fn interactivity(&mut self) -> &mut Interactivity {
        self.base.interactivity()
    }
}

impl RenderOnce for Avatar {
    fn render(self, window: &mut Window, cx: &mut App) -> impl IntoElement {
        let border_width = if self.border_color.is_some() {
            px(2.)
        } else {
            px(0.)
        };

        let image_size = avatar_size(self.size).to_pixels(window.rem_size());
        let container_size = image_size + border_width * 2.;

        let content = match self.picture {
            Some(picture) => {
                let seed = self.seed;
                let grayscale = self.grayscale;

                img(picture)
                    .size(image_size)
                    .rounded_full()
                    .object_fit(ObjectFit::Cover)
                    .grayscale(grayscale)
                    .bg(cx.theme().ghost_element_background)
                    .with_fallback(move || generated_avatar(seed.as_deref(), image_size))
                    .into_any_element()
            }
            None => generated_avatar(self.seed.as_deref(), image_size),
        };

        div()
            .flex_shrink_0()
            .size(container_size)
            .rounded_full()
            .overflow_hidden()
            .when_some(self.border_color, |this, color| {
                this.border(border_width).border_color(color)
            })
            .child(content)
    }
}