use crate::colours::DEFAULT_COLOURS;
use crate::map::Map;
use crate::math::{self, Rect, Vec2};
use crate::transform::Transform;
use nalgebra::{Matrix3, Vector2};
use raylib::drawing::RaylibDraw;
use raylib::ffi::{Color, KeyboardKey};
use raylib::RaylibHandle;

/// A state the [DimensionIndicator] is currently in. This determines the behaviour of it and what
/// inputs it might be waiting for.
enum State {
    /// In this state, the indicator is not trying to read any keyboard input, but will instead watch
    /// for any changes to the dimensions from a different source, updating its display.
    Watching,
    /// In this state, the indicator will capture keyboard input and attempt to set the dimensions
    /// according to whatever was entered. If the dimensions cannot be set, the indicator will use
    /// the last valid dimensions.
    Ruling {
        dim_x: String,
        dim_y: String,
        editing_x: bool,
    },
}

/// Used to render the horizontal and vertical dimensions of whatever is selected on the map and, if
/// the user so desires edit them directly by entering values into it.
pub struct DimensionIndicator {
    /// The [State] the dimension indicator is currently in.
    state: State,
    /// The last dimensions that were valid.
    bounds: Rect<f64>,
}

impl Default for State {
    fn default() -> Self {
        Self::Watching
    }
}

impl DimensionIndicator {
    /// Create a new dimension indicator. While it is possible to have multiple instances, this is
    /// not generally recommended, since they will need to be managed carefully or otherwise steal
    /// keystrokes from each other.
    pub fn new() -> Self {
        Self {
            state: State::default(),
            bounds: Rect::new(0., 0., 0., 0.),
        }
    }

    /// Update whatever is selected on the map according to the dimension indicator rules and rulers.
    pub fn update(&mut self, map: &mut Map, rl: &mut RaylibHandle) {
        match &self.state {
            &State::Watching => self.update_watching(map, rl),
            &State::Ruling { .. } => self.update_ruling(map, rl),
        };
    }

    fn update_watching(&mut self, map: &Map, rl: &RaylibHandle) {
        let mut min: Vec2<f64> = Vec2::default();
        let mut max: Vec2<f64> = Vec2::default();

        /* Try to find selected items. If no items exist, the dimension indicator is set to its
         * default, otherwise it is adjusted to the size of the combined selection.
         */
        let mut selection_exists = false;
        for e in map.elements() {
            if e.selected() {
                let element_bounds = e.bounding_rect();
                if selection_exists {
                    // Adjust the currently detected selection size.
                    min.x = math::partial_min(min.x, element_bounds.x);
                    min.y = math::partial_min(min.y, element_bounds.y);
                    max.x = math::partial_max(max.x, element_bounds.x + element_bounds.w);
                    max.y = math::partial_max(max.y, element_bounds.y + element_bounds.h);
                } else {
                    // No selection size detected yet. Set now.
                    min.x = element_bounds.x;
                    min.y = element_bounds.y;
                    max.x = element_bounds.x + element_bounds.w;
                    max.y = element_bounds.y + element_bounds.h;
                }
                selection_exists = true;
            }
        }

        // Set the current selection limits, if any.
        self.bounds = if selection_exists {
            Rect::bounding_rect(min, max)
        } else {
            Rect::new(0., 0., 0., 0.)
        };

        // Check if the user wants to change into editing mode, which the user can only do if there
        // is a selection to begin with.
        if selection_exists && rl.is_key_pressed(KeyboardKey::KEY_TAB) {
            self.state = State::Ruling {
                dim_x: self.bounds.w.to_string(),
                dim_y: self.bounds.h.to_string(),
                editing_x: true,
            };
        }
    }

    fn update_ruling(&mut self, map: &mut Map, rl: &mut RaylibHandle) {
        // Get the currently edited dimension for processing.
        let (edited_dim, editing_x) = match &mut self.state {
            State::Watching => panic!("Called ruler update when in watching state"),
            State::Ruling {
                dim_x,
                dim_y,
                editing_x,
            } => {
                if *editing_x {
                    (dim_x, editing_x)
                } else {
                    (dim_y, editing_x)
                }
            }
        };

        // Switch the currently edited dimension when pressing tab.
        if rl.is_key_pressed(KeyboardKey::KEY_TAB) {
            *editing_x = !*editing_x;
            return;
        }
        // Finish editing mode on enter.
        if rl.is_key_pressed(KeyboardKey::KEY_ENTER) {
            self.state = State::Watching;
            return;
        }

        // Marker to see if the dimensions will have to be checked for an update.
        let mut dimension_changed = false;
        // Delete the last character of the dimension on backspace.
        if rl.is_key_pressed(KeyboardKey::KEY_BACKSPACE) {
            edited_dim.pop();
            dimension_changed = true;
        }
        /* Capture the current key and try to add it to the string of the current dimension,
         * if possible.
         */
        else if let Some(key) = rl.get_key_pressed() {
            match key {
                // Add a decimal point to the dimension if possible.
                KeyboardKey::KEY_PERIOD => {
                    if !edited_dim.contains('.') {
                        edited_dim.push('.');
                    }
                    // Nothing changed here, since there is an implicit .0 at the end.
                }
                // Handle the entered key if it is a number to append it to the currently edited dimension.
                _ => {
                    if key as u16 >= KeyboardKey::KEY_ZERO as u16
                        && key as u16 <= KeyboardKey::KEY_NINE as u16
                    {
                        edited_dim.push(key as u8 as char);
                        dimension_changed = true;
                    }
                }
            };
        }

        if dimension_changed {
            /* Try to parse the dimension from the currently edited string. If it
             * is valid, change the dimensions of the currently selected items. If
             * not, ignore the change and wait for a valid dimension.
             */
            if let Ok(dim) = edited_dim.parse::<f64>() {
                let new_bounds = if *editing_x {
                    Rect::new(self.bounds.x, self.bounds.y, dim, self.bounds.h)
                } else {
                    Rect::new(self.bounds.x, self.bounds.y, self.bounds.h, dim)
                };

                self.set_bounds(map, new_bounds);
            }
        }
    }

    /// Set the selection boundaries to the given bounds. Tries to transform the
    /// currently selected items in the map so they fit inside of the new bounding box.
    ///
    /// # Panics
    /// If the `bounds` have a negative value for width or height, the dimensions
    /// cannot be set and the function will panic.
    pub fn set_bounds(&mut self, map: &mut Map, bounds: Rect<f64>) {
        if bounds.w <= 0. || bounds.h <= 0. {
            panic!("Cannot set dimensions of elements to zero.");
        }

        // If the bounds are the same as before, there is nothing to do.
        if self.bounds == bounds {
            return;
        }

        /* Create a matrix to transform from the current rectangle bounds into the
         * new bounds. Internally, this is a three-step process. First, we
         * translate the points currently in the bounding box to the origin
         * (0, 0) origin vector of the map, then scale and finally move it to the
         * origin of the new rectangle. This needs to be applied to all vertices
         * of all elements that can be scaled.
         */
        let scale = Vector2::new(bounds.w / self.bounds.w, bounds.h / self.bounds.h);
        let transform = Matrix3::new_translation(&Vector2::new(-self.bounds.x, -self.bounds.y))
            .append_nonuniform_scaling(&scale)
            .append_translation(&Vector2::new(bounds.x, bounds.y));

        for element in map.elements_mut() {
            if element.selected() {
                if let Some(transformable) = element.as_non_rigid_mut() {
                    transformable.apply_matrix(&transform);
                }
            }
        }

        self.bounds = bounds;
    }

    pub fn draw(&self, rld: &mut impl RaylibDraw, transform: &Transform) {
        /* Ignore a selection that has no non-null dimensions, since this usually
         * indicates that there is nothing to be scaled.
         */
        if self.bounds.w == 0. && self.bounds.h == 0. {
            return;
        }

        let (dim_str_width, dim_str_height) = match &self.state {
            State::Watching => (self.bounds.w.to_string(), self.bounds.h.to_string()),
            State::Ruling { dim_x, dim_y, .. } => (dim_x.clone(), dim_y.clone()),
        };

        // Draw the horizontal dimension at the bottom and the vertical dimension to the right.
        // Use the valid dimensions, but show the edited dimensions in the String (should they differ)
        let top_right = Vec2::new(self.bounds.x + self.bounds.w, self.bounds.y);
        let bot_left = Vec2::new(self.bounds.x, self.bounds.y + self.bounds.h);
        let bot_right = Vec2::new(self.bounds.x + self.bounds.w, self.bounds.y + self.bounds.h);
        let dimensions = [
            (bot_left, bot_right, dim_str_width),
            (bot_right, top_right, dim_str_height),
        ];
        for (start, end, dim_str) in &dimensions {
            // Don't draw anything if the length is zero.
            if start == end {
                continue;
            }

            /* Get the vector that is perpendicular and points right/down from the line, assuming
             * the lines prefer left as start over right and bottom over top.
             */
            let line_normal = {
                // Start with the direction of the line vector.
                let dir = *start - *end;
                // Calculate perpendicular vec and normalise.
                dir.rotated_90_clockwise() / dir.length()
            };

            // To not have the line directly in the rect, move start and end outside a bit.
            let start_px = transform.point_m_to_px(start) + line_normal * 10.;
            let end_px = transform.point_m_to_px(end) + line_normal * 10.;

            /* Draw the indicator line, with stubs at both ends. */
            // First the two stubs.
            rld.draw_line_ex(
                start_px - line_normal * 5.,
                start_px + line_normal * 5.,
                2.,
                DEFAULT_COLOURS.dimension_indicators,
            );
            rld.draw_line_ex(
                end_px - line_normal * 5.,
                end_px + line_normal * 5.,
                2.,
                DEFAULT_COLOURS.dimension_indicators,
            );
            // Then the actual indicator line.
            rld.draw_line_ex(start_px, end_px, 2., DEFAULT_COLOURS.dimension_indicators);

            /* Draw the indicator text showing how long this line is in meters.
             * It should be placed in the middle of the line, but not into the line directly, so it
             * will be moved out by the normal.
             */
            let text_pos = transform.point_m_to_px(&((*end + *start) / 2.)) + line_normal * 20.;
            rld.draw_text(
                &format!("{}m", dim_str),
                text_pos.x as i32,
                text_pos.y as i32,
                20,
                DEFAULT_COLOURS.dimension_text,
            );
        }
    }
}