//! This module defines core operations and config of tabular data view (CSV table)
//! It operates in 2 coordinate systems:
//! - `DataCellId` - indices of src data cells
//! - `DisplayCellId` - indices of data after applied transformations like sorting/filtering, which is used to render cell on the screen
//!
//! It's designed to contain core logic of operations without relying on `CsvPreviewView`, context or window handles.

use std::{collections::HashMap, sync::Arc};

use ui::table_row::TableRow;

use crate::{
    table_data_engine::sorting_by_column::{AppliedSorting, sort_data_rows},
    types::{DataRow, DisplayRow, TableCell, TableLikeContent},
};

pub mod sorting_by_column;

#[derive(Default)]
pub(crate) struct TableDataEngine {
    pub applied_sorting: Option<AppliedSorting>,
    d2d_mapping: DisplayToDataMapping,
    pub contents: TableLikeContent,
}

impl TableDataEngine {
    pub(crate) fn d2d_mapping(&self) -> &DisplayToDataMapping {
        &self.d2d_mapping
    }

    pub(crate) fn apply_sort(&mut self) {
        self.d2d_mapping
            .apply_sorting(self.applied_sorting, &self.contents.rows);
        self.d2d_mapping.merge_mappings();
    }

    /// Applies sorting and filtering to the data and produces display to data mapping
    pub(crate) fn calculate_d2d_mapping(&mut self) {
        self.d2d_mapping
            .apply_sorting(self.applied_sorting, &self.contents.rows);
        self.d2d_mapping.merge_mappings();
    }
}

/// Relation of Display (rendered) rows to Data (src) rows with applied transformations
/// Transformations applied:
/// - sorting by column
#[derive(Debug, Default)]
pub struct DisplayToDataMapping {
    /// All rows sorted, regardless of applied filtering. Applied every time sorting changes
    pub sorted_rows: Vec<DataRow>,
    /// Filtered and sorted rows. Computed cheaply from `sorted_mapping` and `filtered_out_rows`
    pub mapping: Arc<HashMap<DisplayRow, DataRow>>,
}

impl DisplayToDataMapping {
    /// Get the data row for a given display row
    pub fn get_data_row(&self, display_row: DisplayRow) -> Option<DataRow> {
        self.mapping.get(&display_row).copied()
    }

    /// Get the number of filtered rows
    pub fn visible_row_count(&self) -> usize {
        self.mapping.len()
    }

    /// Computes sorting
    fn apply_sorting(&mut self, sorting: Option<AppliedSorting>, rows: &[TableRow<TableCell>]) {
        let data_rows: Vec<DataRow> = (0..rows.len()).map(DataRow).collect();

        let sorted_rows = if let Some(sorting) = sorting {
            sort_data_rows(&rows, data_rows, sorting)
        } else {
            data_rows
        };

        self.sorted_rows = sorted_rows;
    }

    /// Take pre-computed sorting and filtering results, and apply them to the mapping
    fn merge_mappings(&mut self) {
        self.mapping = Arc::new(
            self.sorted_rows
                .iter()
                .enumerate()
                .map(|(display, data)| (DisplayRow(display), *data))
                .collect(),
        );
    }
}