use crate::RootConfig;
use colored::*;
use colorsys::Rgb;
use serde_json::Value;

/// Defines a printable
///
/// # Properties
/// - `color` - The color that needs to be used for the unicode
/// - `count` - The number of contributions done by the user on that specific date
#[derive(Clone, Default, Debug, PartialEq, Eq)]
pub struct Printable {
    pub color: String,
    pub count: i64,
}

/// Defines all the options for the printable
///
/// This might be a little tricky, you might wanna read the detailed explained docs - https://takoyaki.vercel.app/docs/creating-print-options
pub struct PrintOptions<'a> {
    /// The root for the weeks array
    pub weeks_root: &'a str,
    /// The root for the day's contributions
    pub days_root: &'a str,
    /// Key for the contribution count
    pub contribution_count_key: &'a str,
    /// Key for the contribution color
    pub contribution_color_key: &'a str,
}

/// Handles printing the data to the terminal
pub struct PrintableGrid {
    /// The raw grid
    pub grid: Vec<Vec<Printable>>,
}

impl Default for PrintableGrid {
    fn default() -> Self {
        Self::new()
    }
}

impl PrintableGrid {
    /// Creates a new instance of the printable
    ///
    /// # Example:
    /// ```
    /// use takoyaki::PrintableGrid;
    ///
    /// let printable = Printable::new()
    /// ```
    pub fn new() -> Self {
        Self { grid: vec![] }
    }

    /// Iterates over the raw data and find the data at the specific destionation
    ///
    /// # Arguments
    /// - `data` - The raw data that needs to be looped through
    /// - `dest` - A string that includes all the key path to the destination separated by dots.
    ///
    /// # Example:
    /// ```
    /// use takoyaki::PrintableGrid;
    /// use serde_json::json;
    ///
    /// let data = json!({
    ///     "children": {
    ///         "are_human_dumb": true
    ///     }
    /// });
    ///
    /// assert_eq!(PrintableGrid::pluck(&data, "children.are_human_dumb"), json!(true))
    /// ```
    pub fn pluck(data: &Value, dest: &str) -> Value {
        // Clone the existing data
        let mut data_clone = data.clone();

        // Iterate through the path
        for i in dest.split('.') {
            // Mutate the data
            data_clone = data_clone.get(i).unwrap().clone();
        }

        // Return the path
        data_clone
    }

    /// Inserts a `item` at `x` and `y` positions in a 2d grid
    ///
    /// # Arguments
    /// - `x`: The position on the x asis
    /// - `y`: The position on the y asis
    /// - `item`: The item that needs to be inserted
    ///
    /// # Example
    /// ```
    /// use takoyaki::{PrintableGrid,Printable};
    ///
    /// let mut grid = PrintableGrid::new();
    ///
    /// let printable = Printable { color: "".to_string(), count: 0 };
    /// grid.insert_at(2, 2, printable.clone());
    ///
    /// assert_eq!(grid.grid[2][2], printable);
    /// ```
    pub fn insert_at(&mut self, x: usize, y: usize, item: Printable) {
        // Resize the grid on the x axis with vec![] as a default fill value
        if self.grid.len() <= x {
            self.grid.resize(x + 1, vec![])
        }

        // Resize the grid on the y axis with PrintableGrid::default() as a default fill value
        if self.grid[x].len() <= y {
            self.grid[x].resize(y, Printable::default())
        }

        // Insert at the specific location
        self.grid[x].insert(y, item);
    }

    /// Generates the grid according the the print option
    pub fn generate_grid(&mut self, opts: PrintOptions, data: Value) {
        // Traverse through the weeks
        let mut x = 0;

        for (y, week) in Self::pluck(&data, opts.weeks_root)
            .as_array()
            .unwrap()
            .iter()
            .enumerate()
        {
            // Iterate through the days
            for day in Self::pluck(week, opts.days_root).as_array().unwrap() {
                let color_temp = Self::pluck(day, opts.contribution_color_key);
                let color = color_temp.as_str().unwrap().to_string();
                let count = Self::pluck(day, opts.contribution_count_key)
                    .as_i64()
                    .unwrap();

                self.insert_at(x, y, Printable { color, count });

                x += 1;
            }

            x = 0;
        }
    }

    /// Pretty prints the grid
    pub fn pretty_print(&self) -> crate::Result<()> {
        let config = RootConfig::parse()?;

        for x in &self.grid {
            for y in x {
                // Create a fallback color
                let fallback_color = serde_json::Value::String(y.color.clone());

                // Get the color to use
                let raw_color = config
                    .colors
                    .get(format!("{}_contribution", y.count))
                    .or_else(|| config.colors.get("x_contribution"))
                    .unwrap_or(&fallback_color);

                // Convert it to rgb
                let color = Rgb::from_hex_str(raw_color.as_str().unwrap())?;

                if config.unicode.paint_bg {
                    // Print the unicode
                    print!(
                        "{}",
                        config.unicode.character.on_truecolor(
                            color.red() as u8,
                            color.green() as u8,
                            color.blue() as u8
                        )
                    )
                } else {
                    print!(
                        "{}",
                        config.unicode.character.truecolor(
                            color.red() as u8,
                            color.green() as u8,
                            color.blue() as u8
                        )
                    )
                }
            }

            println!()
        }

        Ok(())
    }
}