#[derive(Clone)]
struct LazyReader {
    path: PathBuf,
    rechunk: bool,
    row_count: Option<RowCount>,
    n_rows: Option<usize>,
}

impl AnonymousScan for LazyReader {
    fn as_any(&self) -> &dyn std::any::Any {
        self
    }

    fn scan(&self, _scan_opts: AnonymousScanOptions) -> PolarsResult<DataFrame> {
        df!["test" => ["testValue1", "testValue2"]]
    }

    fn schema(&self, _infer_schema_length: Option<usize>) -> PolarsResult<Schema> {
        Ok(Schema::from(
            [Field::new("test", DataType::Utf8)].into_iter(),
        ))
    }
}

impl LazyFileListReader for LazyReader {
    fn finish_no_glob(self) -> PolarsResult<LazyFrame> {
        let options = ScanArgsAnonymous::default();
        LazyFrame::anonymous_scan(Arc::new(self), options)
    }

    fn path(&self) -> &Path {
        &self.path
    }

    fn with_path(mut self, path: PathBuf) -> Self {
        self.path = path;
        self
    }

    fn rechunk(&self) -> bool {
        self.rechunk
    }

    #[must_use]
    fn with_rechunk(mut self, toggle: bool) -> Self {
        self.rechunk = toggle;
        self
    }

    fn n_rows(&self) -> Option<usize> {
        self.n_rows
    }

    fn row_count(&self) -> Option<&RowCount> {
        self.row_count.as_ref()
    }
}

fn main() -> Result<()> {
    let args: Vec<String> = env::args().collect();

    LazyReader {
        path: "test".into(),
        rechunk: false,
        row_count: None,
        n_rows: None,
    }
    .finish()?
    .sink_parquet(
        args[2].clone().into(),
        ParquetWriteOptions {
            compression: ParquetCompression::Zstd(None),
            ..ParquetWriteOptions::default()
        },
    )?;

    Ok(())
}