use std::cmp::max;

use anyhow::{anyhow, Result};
use ironcalc::{
    base::{
        calc_result::Range, expressions::types::Area, types::{Border, Col, Fill, Font, Row, SheetData, Style, Worksheet}, worksheet::WorksheetDimension, Model, UserModel
    },
    export::save_xlsx_to_writer,
    import::load_from_xlsx,
};

use crate::ui::Address;

#[cfg(test)]
mod test;

const COL_PIXELS: f64 = 5.0;

#[derive(Debug, Clone)]
pub struct AddressRange<'book> {
    pub start: &'book Address,
    pub end: &'book Address,
}

impl<'book> AddressRange<'book> {
    pub fn as_rows(&self) -> Vec<Vec<Address>> {
        let (row_range, col_range) = self.get_ranges();
        let mut rows = Vec::with_capacity(row_range.len());
        for ri in row_range.iter() {
            let mut row = Vec::with_capacity(col_range.len());
            for ci in col_range.iter() {
                row.push(Address { row: *ri, col: *ci });
            }
            rows.push(row);
        }
        rows
    }

    pub fn as_series(&self) -> Vec<Address> {
        let (row_range, col_range) = self.get_ranges();
        let mut rows = Vec::with_capacity(row_range.len() * col_range.len());
        for ri in row_range.iter() {
            for ci in col_range.iter() {
                rows.push(Address { row: *ri, col: *ci });
            }
        }
        rows
    }

    fn get_ranges(&self) -> (Vec<usize>, Vec<usize>) {
        let row_range = if self.start.row <= self.end.row {
            (self.start.row..=self.end.row)
                .into_iter()
                .collect::<Vec<usize>>()
        } else {
            let mut v = (self.start.row..=self.end.row)
                .into_iter()
                .collect::<Vec<usize>>();
            v.reverse();
            v
        };
        let col_range = if self.start.col <= self.end.col {
            (self.start.col..=self.end.col)
                .into_iter()
                .collect::<Vec<usize>>()
        } else {
            let mut v = (self.start.col..=self.end.col)
                .into_iter()
                .collect::<Vec<usize>>();
            v.reverse();
            v
        };
        (row_range, col_range)
    }
}

/// A spreadsheet book with some internal state tracking.
pub struct Book {
    pub(crate) model: UserModel,
    pub current_sheet: u32,
    pub location: crate::ui::Address,
}

impl Book {
    /// Construct a new book from a Model
    pub fn new(model: UserModel) -> Self {
        Self {
            model,
            current_sheet: 0,
            location: Address::default(),
        }
    }

    pub fn from_model(model: Model) -> Self {
        Self::new(UserModel::from_model(model))
    }

    /// Construct a new book from an xlsx file.
    pub fn new_from_xlsx(path: &str) -> Result<Self> {
        Ok(Self::from_model(load_from_xlsx(
            path,
            "en",
            "America/New_York",
        )?))
    }

    /// Evaluate the spreadsheet calculating formulas and style changes.
    /// This can be an expensive operation.
    pub fn evaluate(&mut self) {
        self.model.evaluate();
    }

    // TODO(zaphar): Should I support ICalc?
    /// Construct a new book from a path.
    pub fn new_from_xlsx_with_locale(path: &str, locale: &str, tz: &str) -> Result<Self> {
        Ok(Self::from_model(load_from_xlsx(path, locale, tz)?))
    }

    /// Save book to an xlsx file.
    pub fn save_to_xlsx(&self, path: &str) -> Result<()> {
        // TODO(zaphar): Currently overwrites. Should we prompty in this case?
        let file_path = std::path::Path::new(path);
        let file = std::fs::File::create(file_path)?;
        let writer = std::io::BufWriter::new(file);
        save_xlsx_to_writer(self.model.get_model(), writer)?;
        Ok(())
    }

    /// Get all the sheet identiers a `Vec<(String, u32)>` where the string
    /// is the sheet name and the u32 is the sheet index.
    pub fn get_all_sheets_identifiers(&self) -> Vec<(String, u32)> {
        self.model
            .get_worksheets_properties()
            .iter()
            .map(|sheet| (sheet.name.to_owned(), sheet.sheet_id))
            .collect()
    }

    /// Get the current sheets name.
    pub fn get_sheet_name(&self) -> Result<&str> {
        Ok(&self.get_sheet()?.name)
    }

    pub fn set_sheet_name(&mut self, idx: u32, sheet_name: &str) -> Result<()> {
        self.model.rename_sheet(idx, sheet_name).map_err(|e| anyhow!(e))?;
        Ok(())
    }

    pub fn new_sheet(&mut self, sheet_name: Option<&str>) -> Result<()> {
        self.model.new_sheet().map_err(|e| anyhow!(e))?;
        let idx = self.model.get_selected_sheet();
        if let Some(name) = sheet_name {
            self.set_sheet_name(idx, name)?;
        }
        self.model.set_selected_sheet(self.current_sheet).map_err(|e| anyhow!(e))?;
        Ok(())
    }

    /// Get the sheet data for the current worksheet.
    pub fn get_sheet_data(&self) -> Result<&SheetData> {
        Ok(&self.get_sheet()?.sheet_data)
    }

    /// Move to a specific sheet location in the current sheet
    pub fn move_to(&mut self, Address { row, col }: &Address) -> Result<()> {
        // FIXME(zaphar): Check that this is safe first.
        self.location.row = *row;
        self.location.col = *col;
        Ok(())
    }

    /// Extend a cell to the rest of the range.
    pub fn extend_to(&mut self, from: &Address, to: &Address) -> Result<()> {
        for cell in (AddressRange {
            start: from,
            end: to,
        })
        .as_series()
        .iter()
        .skip(1)
        {
            // TODO(jeremy): Is there a better way to do this using UserModel?
            let contents = self
                .model
                .get_model()
                .extend_to(
                    self.current_sheet,
                    from.row as i32,
                    from.col as i32,
                    cell.row as i32,
                    cell.col as i32,
                )
                .map_err(|e| anyhow!(e))?;
            self.model
                .set_user_input(
                    self.current_sheet,
                    cell.row as i32,
                    cell.col as i32,
                    &contents,
                )
                .map_err(|e| anyhow!(e))?;
        }
        self.evaluate();
        Ok(())
    }

    pub fn clear_current_cell(&mut self) -> Result<()> {
        self.clear_cell_contents(self.current_sheet as u32, self.location.clone())
    }

    pub fn clear_current_cell_all(&mut self) -> Result<()> {
        self.clear_cell_all(self.current_sheet as u32, self.location.clone())
    }

    pub fn clear_cell_contents(&mut self, sheet: u32, Address { row, col }: Address) -> Result<()> {
        Ok(self
            .model
            .range_clear_contents(&Area {
                sheet,
                row: row as i32,
                column: col as i32,
                width: 1,
                height: 1,
            })
            .map_err(|s| anyhow!("Unable to clear cell contents {}", s))?)
    }

    pub fn clear_cell_range(&mut self, sheet: u32, start: Address, end: Address) -> Result<()> {
        let area = Area {
            sheet,
            row: start.row as i32,
            column: start.col as i32,
            width: (end.row - start.row) as i32,
            height: (end.col - end.row) as i32,
        };
        self.model
            .range_clear_contents(&area)
            .map_err(|s| anyhow!("Unable to clear cell contents {}", s))?;
        Ok(())
    }

    pub fn clear_cell_all(&mut self, sheet: u32, Address { row, col }: Address) -> Result<()> {
        Ok(self
            .model
            .range_clear_all(&Area {
                sheet,
                row: row as i32,
                column: col as i32,
                width: 1,
                height: 1,
            })
            .map_err(|s| anyhow!("Unable to clear cell contents {}", s))?)
    }

    pub fn clear_cell_range_all(&mut self, sheet: u32, start: Address, end: Address) -> Result<()> {
        let area = Area {
            sheet,
            row: start.row as i32,
            column: start.col as i32,
            width: (end.row - start.row) as i32,
            height: (end.col - end.row) as i32,
        };
        self.model.range_clear_all(&area)
            .map_err(|s| anyhow!("Unable to clear cell contents {}", s))?;
        Ok(())
    }

    /// Get a cells formatted content.
    pub fn get_current_cell_rendered(&self) -> Result<String> {
        Ok(self.get_cell_addr_rendered(&self.location)?)
    }

    pub fn get_cell_style(&self, sheet: u32, cell: &Address) -> Option<Style> {
        // TODO(jwall): This is modeled a little weird. We should probably record
        // the error *somewhere* but for the user there is nothing to be done except
        // not use a style.
        match self.model.get_model().get_style_for_cell(sheet, cell.row as i32, cell.col as i32)
        {
            Err(_) => None,
            Ok(s) => Some(s),
        }
    }

    fn get_column(&self, sheet: u32, col: usize) -> Result<Option<&Col>> {
        Ok(self.model.get_model().workbook.worksheet(sheet)
            .map_err(|e| anyhow!("{}", e))?.cols.get(col))
    }

    fn get_row(&self, sheet: u32, col: usize) -> Result<Option<&Row>> {
        Ok(self.model.get_model().workbook.worksheet(sheet)
            .map_err(|e| anyhow!("{}", e))?.rows.get(col))
    }

    pub fn get_column_style(&self, sheet: u32, col: usize) -> Result<Option<Style>> {
        // TODO(jwall): This is modeled a little weird. We should probably record
        // the error *somewhere* but for the user there is nothing to be done except
        // not use a style.
        if let Some(col) = self.get_column(sheet, col)? {
            if let Some(style_idx) = col.style.map(|idx| idx as usize) {
                let styles = &self.model.get_model().workbook.styles;
                if styles.cell_style_xfs.len() <= style_idx {
                    return Ok(Some(Style {
                        alignment: None,
                        num_fmt: styles.num_fmts[style_idx].format_code.clone(),
                        fill: styles.fills[style_idx].clone(),
                        font: styles.fonts[style_idx].clone(),
                        border: styles.borders[style_idx].clone(),
                        quote_prefix: false,
                    }));
                }
            }
        }
        return Ok(None);
    }

    pub fn get_row_style(&self, sheet: u32, row: usize) -> Result<Option<Style>> {
        // TODO(jwall): This is modeled a little weird. We should probably record
        // the error *somewhere* but for the user there is nothing to be done except
        // not use a style.
        if let Some(row) = self.get_row(sheet, row)? {
            let style_idx = row.s as usize;
            let styles = &self.model.get_model().workbook.styles;
            if styles.cell_style_xfs.len() <= style_idx {
                return Ok(Some(Style {
                    alignment: None,
                    num_fmt: styles.num_fmts[style_idx].format_code.clone(),
                    fill: styles.fills[style_idx].clone(),
                    font: styles.fonts[style_idx].clone(),
                    border: styles.borders[style_idx].clone(),
                    quote_prefix: false,
                }));
            }
        }
        return Ok(None);
    }

    pub fn create_style(&mut self) -> Style {
        Style {
            alignment: None,
            num_fmt: String::new(),
            fill: Fill::default(),
            font: Font::default(),
            border: Border::default(),
            quote_prefix: false,
        }
    }

    pub fn set_cell_style(&mut self, style: &[(&str, &str)], area: &Area) -> Result<()> {
        for (path, val) in style {
            self.model.update_range_style(area, path, val)
                .map_err(|s| anyhow!("Unable to format cell {}", s))?;
        }
        Ok(())
    }

    pub fn set_col_style(&mut self, style: &[(&str, &str)], sheet: u32, col: usize) -> Result<()> {
        todo!()
        //let idx = self.create_or_get_style_idx(style);
        //let sheet = self.model.workbook.worksheet_mut(sheet)
        //    .map_err(|e| anyhow!("{}", e))?;
        //let width = sheet.get_column_width(col as i32)
        //    .map_err(|e| anyhow!("{}", e))?;
        //sheet.set_column_style(col as i32, idx)
        //    .map_err(|e| anyhow!("{}", e))?;
        //sheet.set_column_width(col as i32, width)
        //    .map_err(|e| anyhow!("{}", e))?;
        //Ok(())
    }

    pub fn set_row_style(&mut self, style: &[(&str, &str)], sheet: u32, row: usize) -> Result<()> {
        todo!()
        //let idx = self.create_or_get_style_idx(style);
        //self.model.workbook.worksheet_mut(sheet)
        //    .map_err(|e| anyhow!("{}", e))?
        //    .set_row_style(row as i32, idx)
        //    .map_err(|e| anyhow!("{}", e))?;
        //Ok(())
    }

    /// Get a cells rendered content for display.
    pub fn get_cell_addr_rendered(&self, Address { row, col }: &Address) -> Result<String> {
        Ok(self
            .model
            .get_formatted_cell_value(self.current_sheet, *row as i32, *col as i32)
            .map_err(|s| anyhow!("Unable to format cell {}", s))?)
    }

    /// Get a cells actual content unformatted as a string.
    pub fn get_cell_addr_contents(&self, Address { row, col }: &Address) -> Result<String> {
        Ok(self
            .model
            .get_cell_content(self.current_sheet, *row as i32, *col as i32)
            .map_err(|s| anyhow!("Unable to format cell {}", s))?)
    }

    /// Get a cells actual content as a string.
    pub fn get_current_cell_contents(&self) -> Result<String> {
        Ok(self
            .model
            .get_cell_content(
                self.current_sheet,
                self.location.row as i32,
                self.location.col as i32,
            )
            .map_err(|s| anyhow!("Unable to format cell {}", s))?)
    }

    /// Update the current cell in a book.
    /// This update won't be reflected until you call `Book::evaluate`.
    pub fn edit_current_cell<S: Into<String>>(&mut self, value: S) -> Result<()> {
        self.update_cell(&self.location.clone(), value)?;
        Ok(())
    }

    /// Update an entry in the current sheet for a book.
    /// This update won't be reflected until you call `Book::evaluate`.
    pub fn update_cell<S: Into<String>>(&mut self, location: &Address, value: S) -> Result<()> {
        self.model
            .set_user_input(
                self.current_sheet,
                location.row as i32,
                location.col as i32,
                // TODO(jwall): This could probably be made more efficient
                &value.into(),
            )
            .map_err(|e| anyhow!("Invalid cell contents: {}", e))?;
        Ok(())
    }

    /// Insert `count` rows at a `row_idx`.
    pub fn insert_rows(&mut self, row_idx: usize, count: usize) -> Result<()> {
        for i in 0..count {
            self.model
                .insert_row(self.current_sheet, (row_idx + i) as i32)
                .map_err(|e| anyhow!("Unable to insert row(s): {}", e))?;
        }
        if self.location.row >= row_idx {
            self.move_to(&Address {
                row: self.location.row + count,
                col: self.location.col,
            })?;
        }
        Ok(())
    }

    /// Insert `count` columns at a `col_idx`.
    pub fn insert_columns(&mut self, col_idx: usize, count: usize) -> Result<()> {
        for i in 0..count {
            self.model
                .insert_column(self.current_sheet, (col_idx + i) as i32)
                .map_err(|e| anyhow!("Unable to insert column(s): {}", e))?;
        }
        if self.location.col >= col_idx {
            self.move_to(&Address {
                row: self.location.row,
                col: self.location.col + count,
            })?;
        }
        Ok(())
    }

    /// Get the current sheets dimensions. This is a somewhat expensive calculation.
    pub fn get_dimensions(&self) -> Result<WorksheetDimension> {
        Ok(self.get_sheet()?.dimension())
    }

    /// Get column size
    pub fn get_col_size(&self, idx: usize) -> Result<usize> {
        self.get_column_size_for_sheet(self.current_sheet, idx)
    }

    pub fn get_column_size_for_sheet(&self, sheet: u32, idx: usize) -> std::result::Result<usize, anyhow::Error> {
        Ok((self.model.get_column_width(sheet, idx as i32)
            .map_err(|e| anyhow!("Error getting column width: {:?}", e))?
            / COL_PIXELS) as usize)
    }

    pub fn set_col_size(&mut self, col: usize, width: usize) -> Result<()> {
        self.set_column_size_for_sheet(self.current_sheet, col, width)
    }

    pub fn set_column_size_for_sheet(&mut self, sheet: u32, col: usize, width: usize) -> std::result::Result<(), anyhow::Error> {
        self.model.set_column_width(sheet, col as i32, width as f64 * COL_PIXELS)
            .map_err(|e| anyhow!("Error setting column width: {:?}", e))?;
        Ok(())
    }

    // Get the size of the current sheet as a `(row_count, column_count)`
    pub fn get_size(&self) -> Result<(usize, usize)> {
        let sheet = &self.get_sheet()?.sheet_data;
        let mut row_count = 0 as i32;
        let mut col_count = 0 as i32;
        for (ri, cols) in sheet.iter() {
            row_count = max(*ri, row_count);
            for (ci, _) in cols.iter() {
                col_count = max(*ci, col_count);
            }
        }
        Ok((row_count as usize, col_count as usize))
    }

    /// Select a sheet by name.
    pub fn select_sheet_by_name(&mut self, name: &str) -> bool {
        if let Some((idx, _sheet)) = self
            .model.get_model()
            .workbook
            .worksheets
            .iter()
            .enumerate()
            .find(|(_idx, sheet)| sheet.name == name)
        {
            self.current_sheet = idx as u32;
            return true;
        }
        false
    }

    /// Get all sheet names
    pub fn get_sheet_names(&self) -> Vec<String> {
        self.model.get_model().workbook.get_worksheet_names()
    }

    pub fn select_next_sheet(&mut self) {
        // TODO(jwall): Is there a cleaner way to do this with UserModel?
        let len = self.model.get_model().workbook.worksheets.len() as u32;
        let mut next = self.current_sheet + 1;
        if next == len {
            next = 0;
        }
        self.current_sheet = next;
    }

    pub fn select_prev_sheet(&mut self) {
        // TODO(jwall): Is there a cleaner way to do this with UserModel?
        let len = self.model.get_model().workbook.worksheets.len() as u32;
        let next = if self.current_sheet == 0 {
            len - 1
        } else {
            self.current_sheet - 1
        };
        self.current_sheet = next;
    }

    /// Select a sheet by id.
    pub fn select_sheet_by_id(&mut self, id: u32) -> bool {
        // TODO(jwall): Is there a cleaner way to do this with UserModel?
        if let Some((idx, _sheet)) = self
            .model.get_model()
            .workbook
            .worksheets
            .iter()
            .enumerate()
            .find(|(_idx, sheet)| sheet.sheet_id == id)
        {
            self.current_sheet = idx as u32;
            return true;
        }
        false
    }

    /// Get the current `Worksheet`.
    pub(crate) fn get_sheet(&self) -> Result<&Worksheet> {
        // TODO(jwall): Is there a cleaner way to do this with UserModel?
        Ok(self
            .model.get_model()
            .workbook
            .worksheet(self.current_sheet)
            .map_err(|s| anyhow!("Invalid Worksheet id: {}: error: {}", self.current_sheet, s))?)
    }

    pub(crate) fn get_sheet_name_by_idx(&self, idx: usize) -> Result<&str> {
        // TODO(jwall): Is there a cleaner way to do this with UserModel?
        Ok(&self
            .model.get_model()
            .workbook
            .worksheet(idx as u32)
            .map_err(|s| anyhow!("Invalid Worksheet: {}", s))?
            .name)
    }
}

impl Default for Book {
    fn default() -> Self {
        let mut book =
            Book::new(UserModel::new_empty("default_name", "en", "America/New_York").unwrap());
        book.update_cell(&Address { row: 1, col: 1 }, "").unwrap();
        book
    }
}