liteboxfs 0.1.0

use std::{ffi::OsStr, iter, path::PathBuf};

use rusqlite::OptionalExtension;

use crate::{
    FileOrigin, RootId,
    block::FileId as StoreFileId,
    path::NormalizedPath,
    sql::{FileDiscriminant, SqlStore},
};

#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum PathInsertResult {
    Inserted,
    AlreadyExists,
}

impl<'conn> SqlStore<'conn> {
    /// Resolve a normalized path to its row ID in `liteboxfs_paths`.
    pub(super) fn resolve_path_id(
        &self,
        root_row_id: i64,
        root_id: RootId,
        path: &NormalizedPath,
    ) -> crate::Result<i64> {
        let root_path_row_id: i64 = self
            .db
            .query_row(
                r#"
                SELECT
                    id
                FROM
                    liteboxfs_paths
                WHERE
                    root = ?
                    AND parent IS NULL
                    AND name = x'2f';
                "#,
                rusqlite::params![root_row_id],
                |row| row.get(0),
            )
            .map_err(|e| match e {
                rusqlite::Error::QueryReturnedNoRows => crate::Error::FileNotFound {
                    file: FileOrigin::Litebox {
                        root: root_id,
                        locator: path.to_path_buf().into(),
                    },
                },
                _ => e.into(),
            })?;

        let mut current_id = root_path_row_id;

        for component in path.components() {
            let next_id: Option<i64> = self
                .db
                .query_row(
                    r#"
                    SELECT
                        id
                    FROM
                        liteboxfs_paths
                    WHERE
                        root = ?
                        AND parent = ?
                        AND name = ?;
                    "#,
                    rusqlite::params![root_row_id, current_id, component.as_encoded_bytes()],
                    |row| row.get(0),
                )
                .optional()?;

            match next_id {
                Some(id) => current_id = id,
                None => {
                    return Err(crate::Error::FileNotFound {
                        file: FileOrigin::Litebox {
                            root: root_id,
                            locator: path.to_path_buf().into(),
                        },
                    });
                }
            }
        }

        Ok(current_id)
    }

    pub fn insert_path(
        &self,
        root_id: RootId,
        path: &NormalizedPath,
        file: StoreFileId,
    ) -> crate::Result<PathInsertResult> {
        let root_row_id: i64 = self.db.query_row(
            r#"
            SELECT
                id
            FROM
                liteboxfs_roots
            WHERE
                uuid = ?;
            "#,
            rusqlite::params![root_id.to_string()],
            |row| row.get(0),
        )?;

        let components = path.components().collect::<Vec<_>>();

        if components.is_empty() {
            let exists = self
                .db
                .query_row(
                    r#"
                    SELECT
                        id
                    FROM
                        liteboxfs_paths
                    WHERE
                        root = ?
                        AND parent IS NULL
                        AND name = x'2f';
                    "#,
                    rusqlite::params![root_row_id],
                    |row| row.get::<_, i64>(0),
                )
                .optional()?;

            if exists.is_some() {
                return Ok(PathInsertResult::AlreadyExists);
            }

            // If there is no root directory, insert one.
            self.db.execute(
                r#"
                INSERT INTO
                    liteboxfs_paths (file, root, name, parent)
                VALUES
                    (?, ?, x'2f', NULL);
                "#,
                rusqlite::params![file, root_row_id],
            )?;

            return Ok(PathInsertResult::Inserted);
        }

        // For non-root paths, start traversal from the root path.
        let root_path_row_id: i64 = self
            .db
            .query_row(
                r#"
                SELECT
                    id
                FROM
                    liteboxfs_paths
                WHERE
                    root = ?
                    AND parent IS NULL
                    AND name = x'2f';
                "#,
                rusqlite::params![root_row_id],
                |row| row.get(0),
            )
            .map_err(|e| match e {
                rusqlite::Error::QueryReturnedNoRows => crate::Error::NoParentDirectory {
                    file: FileOrigin::Litebox {
                        root: root_id,
                        locator: path.to_path_buf().into(),
                    },
                },
                _ => e.into(),
            })?;

        let mut last_parent_id: i64 = root_path_row_id;
        let num_components = components.len();

        for (i, component) in components.into_iter().enumerate() {
            let is_last_component = i == num_components - 1;

            let component_id = if is_last_component {
                self.db
                    .query_one(
                        r#"
                        SELECT
                            liteboxfs_paths.id
                        FROM
                            liteboxfs_paths
                        WHERE
                            liteboxfs_paths.root = ?
                            AND liteboxfs_paths.parent = ?
                            AND liteboxfs_paths.name = ?
                        LIMIT 1;
                        "#,
                        rusqlite::params![
                            root_row_id,
                            last_parent_id,
                            component.as_encoded_bytes(),
                        ],
                        |row| row.get::<_, i64>(0),
                    )
                    .optional()?
            } else {
                self.db
                    .query_one(
                        r#"
                        SELECT
                            liteboxfs_paths.id
                        FROM
                            liteboxfs_paths
                        JOIN
                            liteboxfs_files ON liteboxfs_paths.file = liteboxfs_files.id
                        WHERE
                            liteboxfs_paths.root = ?
                            AND liteboxfs_paths.parent = ?
                            AND liteboxfs_paths.name = ?
                            AND liteboxfs_files.kind = ?
                        LIMIT 1;
                        "#,
                        rusqlite::params![
                            root_row_id,
                            last_parent_id,
                            component.as_encoded_bytes(),
                            FileDiscriminant::Dir
                        ],
                        |row| row.get::<_, i64>(0),
                    )
                    .optional()?
            };

            match component_id {
                Some(_) if is_last_component => {
                    return Ok(PathInsertResult::AlreadyExists);
                }
                Some(component_id) => {
                    last_parent_id = component_id;
                }
                None if is_last_component => {
                    self.db.execute(
                        r#"
                        INSERT INTO
                            liteboxfs_paths (file, root, name, parent)
                        VALUES
                            (?, ?, ?, ?);
                        "#,
                        rusqlite::params![
                            file,
                            root_row_id,
                            component.as_encoded_bytes(),
                            last_parent_id
                        ],
                    )?;

                    return Ok(PathInsertResult::Inserted);
                }
                None => {
                    // Check whether the path segment:
                    // 1. Exists but is not a directory.
                    // 2. Does not exist at all.
                    let exists_as_non_dir: bool = self
                        .db
                        .query_one(
                            r#"
                            SELECT
                                1
                            FROM
                                liteboxfs_paths
                            WHERE
                                liteboxfs_paths.root = ?
                                AND liteboxfs_paths.parent = ?
                                AND liteboxfs_paths.name = ?
                            LIMIT 1;
                            "#,
                            rusqlite::params![
                                root_row_id,
                                last_parent_id,
                                component.as_encoded_bytes(),
                            ],
                            |_row| Ok(()),
                        )
                        .optional()?
                        .is_some();

                    if exists_as_non_dir {
                        // Reconstruct the partial path up to the current component.
                        let partial: PathBuf = iter::once(OsStr::new("/"))
                            .chain(path.components().take(i + 1))
                            .collect();
                        return Err(crate::Error::NotADirectory {
                            file: FileOrigin::Litebox {
                                root: root_id,
                                locator: NormalizedPath::new(&partial).to_path_buf().into(),
                            },
                        });
                    }

                    return Err(crate::Error::NoParentDirectory {
                        file: FileOrigin::Litebox {
                            root: root_id,
                            locator: path.to_path_buf().into(),
                        },
                    });
                }
            }
        }

        unreachable!()
    }

    pub fn rename_path_tree(
        &self,
        root_id: RootId,
        source: &NormalizedPath,
        dest: &NormalizedPath,
    ) -> crate::Result<()> {
        let root_row_id: i64 = self.db.query_row(
            r#"
            SELECT
                id
            FROM
                liteboxfs_roots
            WHERE
                uuid = ?;
            "#,
            rusqlite::params![root_id.to_string()],
            |row| row.get(0),
        )?;

        let source_path_id = self.resolve_path_id(root_row_id, root_id, source)?;

        let dest_exists = match self.resolve_path_id(root_row_id, root_id, dest) {
            Ok(_) => true,
            Err(crate::Error::FileNotFound { .. }) => false,
            Err(e) => return Err(e),
        };

        if dest_exists {
            return Err(crate::Error::FileAlreadyExists {
                path: FileOrigin::Litebox {
                    root: root_id,
                    locator: dest.to_path_buf(),
                },
            });
        }

        let dest_name = dest.file_name().expect("dest path should have a file name");

        let dest_parent = dest
            .parent()
            .map(NormalizedPath::new)
            .expect("dest path should have a parent");

        let dest_parent_id = self
            .resolve_path_id(root_row_id, root_id, &dest_parent)
            .map_err(|e| match e {
                crate::Error::FileNotFound { .. } => crate::Error::NoParentDirectory {
                    file: FileOrigin::Litebox {
                        root: root_id,
                        locator: dest.to_path_buf().into(),
                    },
                },
                _ => e,
            })?;

        let parent_kind: FileDiscriminant = self.db.query_row(
            r#"
            SELECT
                liteboxfs_files.kind
            FROM
                liteboxfs_paths
            JOIN
                liteboxfs_files ON liteboxfs_paths.file = liteboxfs_files.id
            WHERE
                liteboxfs_paths.id = ?;
            "#,
            rusqlite::params![dest_parent_id],
            |row| row.get(0),
        )?;

        if parent_kind != FileDiscriminant::Dir {
            return Err(crate::Error::NotADirectory {
                file: FileOrigin::Litebox {
                    root: root_id,
                    locator: dest.to_path_buf().into(),
                },
            });
        }

        // Updating the parent and name of the source row moves the entire subtree: every
        // descendant already references its parent by ID, so no other rows need updating.
        self.db.execute(
            r#"
            UPDATE
                liteboxfs_paths
            SET
                parent = ?1,
                name = ?2
            WHERE
                id = ?3;
            "#,
            rusqlite::params![dest_parent_id, dest_name.as_encoded_bytes(), source_path_id],
        )?;

        Ok(())
    }

    pub fn count_paths(&self, root_id: RootId, file: StoreFileId) -> crate::Result<u32> {
        let count: i64 = self.db.query_row(
            r#"
            SELECT
                COUNT(*)
            FROM
                liteboxfs_paths
            WHERE
                root = (
                    SELECT
                        id
                    FROM
                        liteboxfs_roots
                    WHERE
                        uuid = ?1
                )
                AND file = ?2;
            "#,
            rusqlite::params![root_id, file],
            |row| row.get(0),
        )?;

        Ok(count as u32)
    }
}