oxigdal-bench 0.1.7

//! Vector operation benchmark scenarios.
//!
//! This module provides benchmark scenarios for vector operations including:
//! - Reading and writing vector formats (GeoJSON, Shapefile, etc.)
//! - Geometry simplification
//! - Buffer operations
//! - Spatial indexing
//! - Geometric operations

use crate::error::{BenchError, Result};
use crate::scenarios::BenchmarkScenario;
use std::path::PathBuf;

/// GeoJSON read benchmark scenario.
pub struct GeoJsonReadScenario {
    input_path: PathBuf,
    feature_count: Option<usize>,
}

impl GeoJsonReadScenario {
    /// Creates a new GeoJSON read benchmark scenario.
    pub fn new<P: Into<PathBuf>>(input_path: P) -> Self {
        Self {
            input_path: input_path.into(),
            feature_count: None,
        }
    }

    /// Sets the expected feature count for validation.
    pub fn with_feature_count(mut self, count: usize) -> Self {
        self.feature_count = Some(count);
        self
    }
}

impl BenchmarkScenario for GeoJsonReadScenario {
    fn name(&self) -> &str {
        "geojson_read"
    }

    fn description(&self) -> &str {
        "Benchmark GeoJSON file reading performance"
    }

    fn setup(&mut self) -> Result<()> {
        if !self.input_path.exists() {
            return Err(BenchError::scenario_failed(
                self.name(),
                format!("Input file does not exist: {}", self.input_path.display()),
            ));
        }

        Ok(())
    }

    fn execute(&mut self) -> Result<()> {
        #[cfg(feature = "vector")]
        {
            // let reader = GeoJsonReader::open(&self.input_path)?;
            // let features = reader.read_all()?;

            // if let Some(expected) = self.feature_count {
            //     if features.len() != expected {
            //         return Err(BenchError::DataValidation(
            //             format!("Expected {} features, got {}", expected, features.len())
            //         ));
            //     }
            // }
        }

        #[cfg(not(feature = "vector"))]
        {
            return Err(BenchError::missing_dependency("oxigdal-geojson", "vector"));
        }

        Ok(())
    }

    fn teardown(&mut self) -> Result<()> {
        Ok(())
    }
}

/// GeoJSON write benchmark scenario.
pub struct GeoJsonWriteScenario {
    output_path: PathBuf,
    #[allow(dead_code)]
    feature_count: usize,
    geometry_complexity: usize,
    created: bool,
}

impl GeoJsonWriteScenario {
    /// Creates a new GeoJSON write benchmark scenario.
    pub fn new<P: Into<PathBuf>>(output_path: P, feature_count: usize) -> Self {
        Self {
            output_path: output_path.into(),
            feature_count,
            geometry_complexity: 10,
            created: false,
        }
    }

    /// Sets the geometry complexity (number of coordinates per geometry).
    pub fn with_complexity(mut self, complexity: usize) -> Self {
        self.geometry_complexity = complexity;
        self
    }
}

impl BenchmarkScenario for GeoJsonWriteScenario {
    fn name(&self) -> &str {
        "geojson_write"
    }

    fn description(&self) -> &str {
        "Benchmark GeoJSON file writing performance"
    }

    fn setup(&mut self) -> Result<()> {
        if let Some(parent) = self.output_path.parent() {
            std::fs::create_dir_all(parent)?;
        }

        Ok(())
    }

    fn execute(&mut self) -> Result<()> {
        #[cfg(feature = "vector")]
        {
            // Generate test features
            // let features = generate_test_features(
            //     self.feature_count,
            //     self.geometry_complexity,
            // )?;

            // Write to GeoJSON
            // let writer = GeoJsonWriter::create(&self.output_path)?;
            // writer.write_features(&features)?;

            self.created = true;
        }

        #[cfg(not(feature = "vector"))]
        {
            return Err(BenchError::missing_dependency("oxigdal-geojson", "vector"));
        }

        Ok(())
    }

    fn teardown(&mut self) -> Result<()> {
        if self.created && self.output_path.exists() {
            std::fs::remove_file(&self.output_path)?;
        }
        Ok(())
    }
}

/// Geometry simplification benchmark scenario.
pub struct SimplificationScenario {
    input_path: PathBuf,
    #[allow(dead_code)]
    tolerance: f64,
    algorithm: SimplificationAlgorithm,
}

/// Simplification algorithms to benchmark.
#[derive(Debug, Clone, Copy)]
pub enum SimplificationAlgorithm {
    /// Douglas-Peucker algorithm.
    DouglasPeucker,
    /// Visvalingam-Whyatt algorithm.
    VisvalingamWhyatt,
    /// Topology-preserving simplification.
    TopologyPreserving,
}

impl SimplificationScenario {
    /// Creates a new simplification benchmark scenario.
    pub fn new<P: Into<PathBuf>>(input_path: P, tolerance: f64) -> Self {
        Self {
            input_path: input_path.into(),
            tolerance,
            algorithm: SimplificationAlgorithm::DouglasPeucker,
        }
    }

    /// Sets the simplification algorithm.
    pub fn with_algorithm(mut self, algorithm: SimplificationAlgorithm) -> Self {
        self.algorithm = algorithm;
        self
    }
}

impl BenchmarkScenario for SimplificationScenario {
    fn name(&self) -> &str {
        "geometry_simplification"
    }

    fn description(&self) -> &str {
        "Benchmark geometry simplification algorithms"
    }

    fn setup(&mut self) -> Result<()> {
        if !self.input_path.exists() {
            return Err(BenchError::scenario_failed(
                self.name(),
                format!("Input file does not exist: {}", self.input_path.display()),
            ));
        }

        Ok(())
    }

    #[allow(unreachable_code)]
    fn execute(&mut self) -> Result<()> {
        #[cfg(all(feature = "vector", feature = "algorithms"))]
        {
            // let reader = GeoJsonReader::open(&self.input_path)?;
            // let features = reader.read_all()?;

            // for feature in features {
            //     let simplified = match self.algorithm {
            //         SimplificationAlgorithm::DouglasPeucker => {
            //             simplify_douglas_peucker(&feature.geometry, self.tolerance)?
            //         }
            //         SimplificationAlgorithm::VisvalingamWhyatt => {
            //             simplify_visvalingam_whyatt(&feature.geometry, self.tolerance)?
            //         }
            //         SimplificationAlgorithm::TopologyPreserving => {
            //             simplify_topology_preserving(&feature.geometry, self.tolerance)?
            //         }
            //     };
            // }
        }

        #[cfg(not(all(feature = "vector", feature = "algorithms")))]
        {
            return Err(BenchError::missing_dependency(
                "oxigdal simplification",
                "vector and algorithms",
            ));
        }

        Ok(())
    }

    fn teardown(&mut self) -> Result<()> {
        Ok(())
    }
}

/// Buffer operation benchmark scenario.
pub struct BufferScenario {
    input_path: PathBuf,
    #[allow(dead_code)]
    buffer_distance: f64,
    resolution: usize,
}

impl BufferScenario {
    /// Creates a new buffer benchmark scenario.
    pub fn new<P: Into<PathBuf>>(input_path: P, buffer_distance: f64) -> Self {
        Self {
            input_path: input_path.into(),
            buffer_distance,
            resolution: 16,
        }
    }

    /// Sets the buffer resolution (number of segments per quadrant).
    pub fn with_resolution(mut self, resolution: usize) -> Self {
        self.resolution = resolution;
        self
    }
}

impl BenchmarkScenario for BufferScenario {
    fn name(&self) -> &str {
        "geometry_buffer"
    }

    fn description(&self) -> &str {
        "Benchmark geometry buffer operations"
    }

    fn setup(&mut self) -> Result<()> {
        if !self.input_path.exists() {
            return Err(BenchError::scenario_failed(
                self.name(),
                format!("Input file does not exist: {}", self.input_path.display()),
            ));
        }

        Ok(())
    }

    #[allow(unreachable_code)]
    fn execute(&mut self) -> Result<()> {
        #[cfg(all(feature = "vector", feature = "algorithms"))]
        {
            // let reader = GeoJsonReader::open(&self.input_path)?;
            // let features = reader.read_all()?;

            // for feature in features {
            //     let buffered = buffer(
            //         &feature.geometry,
            //         self.buffer_distance,
            //         self.resolution,
            //     )?;
            // }
        }

        #[cfg(not(all(feature = "vector", feature = "algorithms")))]
        {
            return Err(BenchError::missing_dependency(
                "oxigdal buffer",
                "vector and algorithms",
            ));
        }

        Ok(())
    }

    fn teardown(&mut self) -> Result<()> {
        Ok(())
    }
}

/// Spatial indexing benchmark scenario.
pub struct SpatialIndexScenario {
    input_path: PathBuf,
    index_type: SpatialIndexType,
    query_count: usize,
}

/// Spatial index types to benchmark.
#[derive(Debug, Clone, Copy)]
pub enum SpatialIndexType {
    /// R-tree index.
    RTree,
    /// Quadtree index.
    Quadtree,
    /// KD-tree index.
    KdTree,
}

impl SpatialIndexScenario {
    /// Creates a new spatial indexing benchmark scenario.
    pub fn new<P: Into<PathBuf>>(input_path: P) -> Self {
        Self {
            input_path: input_path.into(),
            index_type: SpatialIndexType::RTree,
            query_count: 1000,
        }
    }

    /// Sets the index type.
    pub fn with_index_type(mut self, index_type: SpatialIndexType) -> Self {
        self.index_type = index_type;
        self
    }

    /// Sets the number of queries to perform.
    pub fn with_query_count(mut self, count: usize) -> Self {
        self.query_count = count;
        self
    }
}

impl BenchmarkScenario for SpatialIndexScenario {
    fn name(&self) -> &str {
        "spatial_indexing"
    }

    fn description(&self) -> &str {
        "Benchmark spatial index construction and query performance"
    }

    fn setup(&mut self) -> Result<()> {
        if !self.input_path.exists() {
            return Err(BenchError::scenario_failed(
                self.name(),
                format!("Input file does not exist: {}", self.input_path.display()),
            ));
        }

        Ok(())
    }

    #[allow(unreachable_code)]
    fn execute(&mut self) -> Result<()> {
        #[cfg(all(feature = "vector", feature = "algorithms"))]
        {
            // let reader = GeoJsonReader::open(&self.input_path)?;
            // let features = reader.read_all()?;

            // Build index
            // let index = match self.index_type {
            //     SpatialIndexType::RTree => build_rtree_index(&features)?,
            //     SpatialIndexType::Quadtree => build_quadtree_index(&features)?,
            //     SpatialIndexType::KdTree => build_kdtree_index(&features)?,
            // };

            // Perform queries
            // for _ in 0..self.query_count {
            //     let bbox = generate_random_bbox();
            //     let results = index.query(&bbox)?;
            // }
        }

        #[cfg(not(all(feature = "vector", feature = "algorithms")))]
        {
            return Err(BenchError::missing_dependency(
                "oxigdal spatial indexing",
                "vector and algorithms",
            ));
        }

        Ok(())
    }

    fn teardown(&mut self) -> Result<()> {
        Ok(())
    }
}

/// Intersection operation benchmark scenario.
pub struct IntersectionScenario {
    input_path1: PathBuf,
    input_path2: PathBuf,
}

impl IntersectionScenario {
    /// Creates a new intersection benchmark scenario.
    pub fn new<P1, P2>(input_path1: P1, input_path2: P2) -> Self
    where
        P1: Into<PathBuf>,
        P2: Into<PathBuf>,
    {
        Self {
            input_path1: input_path1.into(),
            input_path2: input_path2.into(),
        }
    }
}

impl BenchmarkScenario for IntersectionScenario {
    fn name(&self) -> &str {
        "geometry_intersection"
    }

    fn description(&self) -> &str {
        "Benchmark geometry intersection operations"
    }

    fn setup(&mut self) -> Result<()> {
        if !self.input_path1.exists() {
            return Err(BenchError::scenario_failed(
                self.name(),
                format!(
                    "Input file 1 does not exist: {}",
                    self.input_path1.display()
                ),
            ));
        }

        if !self.input_path2.exists() {
            return Err(BenchError::scenario_failed(
                self.name(),
                format!(
                    "Input file 2 does not exist: {}",
                    self.input_path2.display()
                ),
            ));
        }

        Ok(())
    }

    #[allow(unreachable_code)]
    fn execute(&mut self) -> Result<()> {
        #[cfg(all(feature = "vector", feature = "algorithms"))]
        {
            // let reader1 = GeoJsonReader::open(&self.input_path1)?;
            // let features1 = reader1.read_all()?;

            // let reader2 = GeoJsonReader::open(&self.input_path2)?;
            // let features2 = reader2.read_all()?;

            // for f1 in &features1 {
            //     for f2 in &features2 {
            //         let intersection = intersect(&f1.geometry, &f2.geometry)?;
            //     }
            // }
        }

        #[cfg(not(all(feature = "vector", feature = "algorithms")))]
        {
            return Err(BenchError::missing_dependency(
                "oxigdal intersection",
                "vector and algorithms",
            ));
        }

        Ok(())
    }

    fn teardown(&mut self) -> Result<()> {
        Ok(())
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_geojson_read_scenario_creation() {
        let scenario = GeoJsonReadScenario::new(std::env::temp_dir().join("test.geojson"))
            .with_feature_count(100);

        assert_eq!(scenario.name(), "geojson_read");
        assert_eq!(scenario.feature_count, Some(100));
    }

    #[test]
    fn test_simplification_scenario_creation() {
        let scenario =
            SimplificationScenario::new(std::env::temp_dir().join("test.geojson"), 0.001)
                .with_algorithm(SimplificationAlgorithm::VisvalingamWhyatt);

        assert_eq!(scenario.name(), "geometry_simplification");
        assert_eq!(scenario.tolerance, 0.001);
    }

    #[test]
    fn test_buffer_scenario_creation() {
        let scenario = BufferScenario::new(std::env::temp_dir().join("test.geojson"), 10.0)
            .with_resolution(32);

        assert_eq!(scenario.name(), "geometry_buffer");
        assert_eq!(scenario.resolution, 32);
    }

    #[test]
    fn test_spatial_index_scenario_creation() {
        let scenario = SpatialIndexScenario::new(std::env::temp_dir().join("test.geojson"))
            .with_index_type(SpatialIndexType::Quadtree)
            .with_query_count(500);

        assert_eq!(scenario.name(), "spatial_indexing");
        assert_eq!(scenario.query_count, 500);
    }
}