//! Code to remove obsolete and extraneous files from a filesystem-based state

//! directory.

use std::path::{Path, PathBuf};

use tor_basic_utils::PathExt as _;

use tor_error::warn_report;

use tracing::warn;

use web_time_compat::{Duration, SystemTime};

/// Return true if `path` looks like a filename we'd like to remove from our

/// state directory.

            // We don't make toml files any more.  We migrated to json because

            // toml isn't so good for serializing arbitrary objects.

            // This file type is obsolete and was removed around 0.0.4.

/// How old must an obsolete-looking file be before we're willing to remove it?

//

// TODO: This could someday be configurable, if there are in fact users who want

// to keep obsolete files around in their state directories for months or years,

// or who need to get rid of them immediately.

const CUTOFF: Duration = Duration::from_secs(4 * 24 * 60 * 60);

/// Return true if `entry` is very old relative to `now` and therefore safe to delete.

        Err(_) => {

            // If duration_since failed, this file is actually from the future, and so it definitely isn't older than the cutoff.

        }

    })

/// Implementation helper for [`FsStateMgr::clean()`](super::FsStateMgr::clean):

/// list all files in `statepath` that are ready to delete as of `now`.

        use std::io::ErrorKind as EK;

                err,

            ),

        }

                Ok(false) => {

                    );

                }

                        err,

                    );

                }

            }

    }

#[cfg(all(test, not(miri) /* filesystem access */))]

mod test {

    // @@ begin test lint list maintained by maint/add_warning @@

    #![allow(clippy::bool_assert_comparison)]

    #![allow(clippy::clone_on_copy)]

    #![allow(clippy::dbg_macro)]

    #![allow(clippy::mixed_attributes_style)]

    #![allow(clippy::print_stderr)]

    #![allow(clippy::print_stdout)]

    #![allow(clippy::single_char_pattern)]

    #![allow(clippy::unwrap_used)]

    #![allow(clippy::unchecked_time_subtraction)]

    #![allow(clippy::useless_vec)]

    #![allow(clippy::needless_pass_by_value)]

    //! <!-- @@ end test lint list maintained by maint/add_warning @@ -->

    use super::*;

    use web_time_compat::SystemTimeExt;

    #[test]

    fn fnames() {

        let examples = vec![

            ("guards", false),

            ("default_guards.json", true),

            ("guards.toml", true),

            ("marzipan.toml", true),

            ("marzipan.json", false),

        ];

        for (name, obsolete) in examples {

            assert_eq!(fname_looks_obsolete(Path::new(name)), obsolete);

        }

    }

    #[test]

    fn age() {

        let dir = tempfile::TempDir::new().unwrap();

        let fname1 = dir.path().join("quokka");

        let now = SystemTime::get();

        std::fs::write(fname1, "hello world").unwrap();

        let mut r = std::fs::read_dir(dir.path()).unwrap();

        let ent = r.next().unwrap().unwrap();

        assert!(!very_old(&ent, now).unwrap());

        assert!(very_old(&ent, now + CUTOFF * 2).unwrap());

    }

    #[test]

    fn list() {

        let dir = tempfile::TempDir::new().unwrap();

        let now = SystemTime::get();

        let fname1 = dir.path().join("quokka.toml");

        std::fs::write(fname1, "hello world").unwrap();

        let fname2 = dir.path().join("wombat.json");

        std::fs::write(fname2, "greetings").unwrap();

        let removable_now = files_to_delete(dir.path(), now);

        assert!(removable_now.is_empty());

        let removable_later = files_to_delete(dir.path(), now + CUTOFF * 2);

        assert_eq!(removable_later.len(), 1);

        assert_eq!(removable_later[0].file_stem().unwrap(), "quokka");

        // Make sure we tolerate files written "in the future"

        let removable_earlier = files_to_delete(dir.path(), now - CUTOFF * 2);

        assert!(removable_earlier.is_empty());

    }

    #[test]

    fn absent() {

        let dir = tempfile::TempDir::new().unwrap();

        let dir2 = dir.path().join("subdir_that_doesnt_exist");

        let r = files_to_delete(&dir2, SystemTime::get());

        assert!(r.is_empty());

    }

}